CXX0030: Error: expression cannot be evaluated

[justinlm]

#pragma once
#include "StdAfx.h"

#define NODE_EMPTY -1
#define SIZE  8

// define node
template <class Type>
class Node
{
public:
	Node(void);
	~Node(void);
	Node(Node * pNode);

	Node<Type>* pNext; //指向下一个节点
	Node<Type>* pPrev;//指向前一个节点
	Type value;
};

template <class Type> Node<Type>::Node(void)
:pNext(NULL),pPrev(NULL),value(NULL)
{
}

template <class Type> Node<Type>::~Node(void)
{
}


// define a iterator
template <class Type>
class MyIterator
{
public:
	typedef Node<Type> Node;

public:
	MyIterator(void);
	MyIterator(Node* node);
	~MyIterator(void);

	const MyIterator& operator = (Node* pos);
	MyIterator&       operator ++ (void);
	MyIterator&       operator -- (void);
	Type&             operator * (void);
	bool              operator == (Node* pos);
	bool              operator != (Node* pos);

private:
	Node *pNode;
};

template <class Type> MyIterator<Type>::MyIterator(void)
:pNode(NULL)
{
}

template <class Type> MyIterator<Type>::MyIterator(Node* node)
:pNode (node)
{
}

template <class Type> MyIterator<Type>::~MyIterator(void)
{
	pNode = NULL;
}

template <class Type>
MyIterator<Type>& MyIterator<Type>::operator ++(void)
{
	pNode = pNode->pNext;
	return *this;
}

template <class Type>
Type&  MyIterator<Type>::operator *(void)
{
	return pNode->value;
}

template <class Type>
bool MyIterator<Type>::operator !=(typename MyIterator<Type>::Node *pos)
{
	return (pNode != pos);
}

template <class Type>
bool MyIterator<Type>::operator ==(typename MyIterator<Type>::Node *pos)
{
	return (pNode == pos);
}

template <class Type>
MyIterator<Type>& MyIterator<Type>::operator --(void)
{
	pNode = pNode->pPrev;
	return *this;
}


// DoubleLinkList
template <class Type>
class DoubleLinkList
{
public :
	typedef Node<Type> Node;
	typedef MyIterator<Type> Iterator;

public:
	DoubleLinkList(void);
	~DoubleLinkList(void);


	Node* pHead;                               //指向头节点
	Node* pTail;                               //指向尾节点

public:
	void insertHead(Type value);               //在头部插入数据            
	void insertTail(Type value);               //在尾部插入数据
	void removeHead(void);                     //删除头部数据
	void removeTail(void);                     //删除尾部数据
	void insertBefore(Type value,Node *nodeB); //在nodeB前面插入数据
	void insertAfter(Type value,Node *nodeA);  //在nodeA后面插入数据
	void removeNode(Node *newNode);            //删除newNode

	Node* begin(void);   
	Node* end(void);

};

template <class Type>
DoubleLinkList<Type>::DoubleLinkList(void)
:pHead(NULL),pTail(NULL)
{
}

template <class Type> 
DoubleLinkList<Type>::~DoubleLinkList(void)
{
}

template <class Type> 
void DoubleLinkList<Type>::insertBefore(Type value, Node *nodeB)
{  
	Node *newNode;
	newNode = new Node();
	newNode->pPrev = nodeB->pPrev;
	nodeB->pPrev->pNext = newNode;//这里应该也有错
	newNode->pNext = nodeB;
	newNode->value = value;	
	if(nodeB->pPrev == NULL)
	{
		this->pHead = newNode;	
	}
	nodeB->pPrev = newNode;
}


template <class Type>
void DoubleLinkList<Type>::insertAfter(Type value, Node *nodeA)
{
	Node *newNode;
	newNode = new Node();
	newNode->pNext = nodeA->pNext;
	nodeA->pNext->pPrev = newNode;//出现编译错误
	newNode->pPrev = nodeA;
	newNode->value = value;	
	if(nodeA->pNext == NULL)
	{
		this->pTail = newNode;	
	}
	nodeA->pNext = newNode;
}

template <class Type>
void DoubleLinkList<Type>::insertHead(Type value) 
{
	Node *newNode;

	if(this->pHead == NULL)
	{
		newNode = new Node();
		this->pHead = newNode;
		this->pTail = newNode;
		newNode->pPrev = NULL;
		newNode->pNext = NULL;
		newNode->value = value;

	}
	else
	{
		insertBefore(value,this->pHead);
	}

}

template <class Type>
void DoubleLinkList<Type>::insertTail(Type value)
{
	Node *newNode;

	if(this->pTail == NULL)
	{
		insertHead(value);
	}
	else 
		insertAfter(value, this->pTail);
}

template <class Type>
void DoubleLinkList<Type>::removeNode(Node *nodeToRemove)
{
	try {
		if(nodeToRemove != NULL )
		{
			if(nodeToRemove == this->pHead)
			{
				this->pHead = this->pHead->pNext;
				this->pHead->pPrev = NULL;
			}
			else if (nodeToRemove == this->pTail)
			{
				this->pTail = this->back->prev;
				this->pTail->pNext = NULL;
			}
			else
			{
				nodeToRemove->pPrev->pNext = nodeToRemove->pNext;
				nodeToRemove->pNext->pPrev = nodeToRemove->pPrev;
			}

			delete nodeToRemove;
			nodeToRemove = NULL;
		}

		else throw (NODE_EMPTY);
	}
	catch(int)
	{
		cerr<<"NODE_EMPTY"<<endl;
		exit(1);
	}	
}

template <class Type>
void DoubleLinkList<Type>::removeHead(void)
{
	removeNode(this->pHead);
}

template <class Type>
void DoubleLinkList<Type>::removeTail(void)
{
	removeNode(this->pTail);
}


template <class Type>
Node<Type>* DoubleLinkList<Type>::begin(void)
{
	return pHead;
}

template <class Type>
Node<Type>* DoubleLinkList<Type>::end(void)
{
	return pTail->pNext;
}

一下为调用

// DoubleLinkList_Iterator.cpp : Defines the entry point for the console application.
//

#include "stdafx.h"
#include "DoubleLinkList.h"


int _tmain(int argc, _TCHAR* argv[])
{
	DoubleLinkList<int> DLList;


	for(int i = 0; i<= SIZE; ++i)
	{
		DLList.insertTail(i);
	}

	DoubleLinkList<int>::Iterator itor = DLList.begin(); 
	
	for(; itor != DLList.end(); ++ itor)
	{
		cout<<*itor<<endl;
	}

}

麻烦哪位帮我改改，谢谢啦，我实在是不懂了

此函数调用会有编译错误。
template <class Type>
void DoubleLinkList<Type>::insertAfter(Type value, Node *nodeA)
{
Node *newNode;
newNode = new Node();
newNode->pNext = nodeA->pNext;
nodeA->pNext->pPrev = newNode;//出现编译错误
newNode->pPrev = nodeA;
newNode->value = value;
if(nodeA->pNext == NULL)
{
this->pTail = newNode;
}
nodeA->pNext = newNode;
}

[azure110]

好长，等有空的人 解决吧 。。

[pengzhixi]

template <class Type> Node<Type>::Node()
:pNext(NULL),pPrev(NULL),value(0)//mark
{
}

[pengzhixi]

#include <iostream>
#include <vector>
#include <string>
using namespace std;

#define NODE_EMPTY -1
#define SIZE  8

// define node
template <class Type>
class Node
{
public:
    Node(void);
    ~Node(void);
    Node(Node * pNode);

    Node<Type>* pNext; //指向下一个节点
    Node<Type>* pPrev;//指向前一个节点
    Type value;
};

template <class Type> Node<Type>::Node()
:pNext(NULL),pPrev(NULL),value(0)
{
}

template <class Type> Node<Type>::~Node(void)
{
}


// define a iterator
template <class Type>
class MyIterator
{
public:
    typedef Node<Type> Node;

public:
    MyIterator(void);
    MyIterator(Node* node);
    ~MyIterator(void);

    const MyIterator& operator = (Node* pos);
    MyIterator&       operator ++ (void);
    MyIterator&       operator -- (void);
    Type&             operator * (void);
    bool              operator == (Node* pos);
    bool              operator != (Node* pos);

private:
    Node *pNode;
};

template <class Type> MyIterator<Type>::MyIterator(void)
:pNode(NULL)
{
}

template <class Type> MyIterator<Type>::MyIterator(Node* node)
:pNode (node)
{
}

template <class Type> MyIterator<Type>::~MyIterator(void)
{
    pNode = NULL;
}

template <class Type>
MyIterator<Type>& MyIterator<Type>::operator ++(void)
{
    pNode = pNode->pNext;
    return *this;
}

template <class Type>
Type&  MyIterator<Type>::operator *(void)
{
    return pNode->value;
}

template <class Type>
bool MyIterator<Type>::operator !=(typename MyIterator<Type>::Node *pos)
{
    return (pNode != pos);
}

template <class Type>
bool MyIterator<Type>::operator ==(typename MyIterator<Type>::Node *pos)
{
    return (pNode == pos);
}

template <class Type>
MyIterator<Type>& MyIterator<Type>::operator --(void)
{
    pNode = pNode->pPrev;
    return *this;
}


// DoubleLinkList
template <class Type>
class DoubleLinkList
{
public :
    typedef Node<Type> Node;
    typedef MyIterator<Type> Iterator;

public:
    DoubleLinkList(void);
    ~DoubleLinkList(void);


    Node* pHead;                               //指向头节点
    Node* pTail;                               //指向尾节点

public:
    void insertHead(Type value);               //在头部插入数据            
    void insertTail(Type value);               //在尾部插入数据
    void removeHead(void);                     //删除头部数据
    void removeTail(void);                     //删除尾部数据
    void insertBefore(Type value,Node *nodeB); //在nodeB前面插入数据
    void insertAfter(Type value,Node *nodeA);  //在nodeA后面插入数据
    void removeNode(Node *newNode);            //删除newNode

    Node* begin(void);   
    Node* end(void);

};

template <class Type>
DoubleLinkList<Type>::DoubleLinkList(void)
:pHead(NULL),pTail(NULL)
{
}

template <class Type> 
DoubleLinkList<Type>::~DoubleLinkList(void)
{
}

template <class Type> 
void DoubleLinkList<Type>::insertBefore(Type value, Node *nodeB)
{  
     Node *newNode;
    newNode = new Node();
    newNode->value = value;
     if(nodeB == pHead)
    {
        newNode->pNext = pHead;
        pHead->pPrev= nodeB;
        newNode->pPrev=NULL;
        this->pHead = newNode;    
    }else{
    newNode->pNext = nodeB;
    newNode->pPrev= nodeB->pPrev;
    nodeB->pPrev->pNext = newNode;//这里应该也有错
    nodeB->pPrev=newNode;}    
}


template <class Type>
void DoubleLinkList<Type>::insertAfter(Type value, Node *nodeA)
{
     Node *newNode;
    newNode = new Node();
    newNode->value = value;
     if(nodeA==pTail)
     {
                     this->pTail = newNode;
                     newNode->pNext=NULL;
                     newNode->pPrev=pTail;
                     pTail=newNode;
                     }else{
    newNode->pPrev = nodeA;
    newNode->pNext=nodeA->pNext;
    nodeA->pNext = newNode;//出现编译错误
    newNode->pNext->pPrev = newNode;
    nodeA->pNext = newNode;
    }
    
}

template <class Type>
void DoubleLinkList<Type>::insertHead(Type value) 
{
    Node *newNode;

    if(this->pHead == NULL)
    {
        newNode = new Node;
        this->pHead = newNode;
        this->pTail = newNode;
        newNode->pPrev = NULL;
        newNode->pNext = NULL;
        newNode->value = value;

    }
    else
    {
        insertBefore(value,this->pHead);
    }

}

template <class Type>
void DoubleLinkList<Type>::insertTail(Type value)
{
  //  Node *newNode;

    if(this->pTail == NULL)
    {
        this->insertHead(value);
    }
    else 
        insertAfter(value, this->pTail);
}

template <class Type>
void DoubleLinkList<Type>::removeNode(Node *nodeToRemove)
{
    try {
        if(nodeToRemove != NULL )
        {
            if(nodeToRemove == this->pHead)
            {
                this->pHead = this->pHead->pNext;
                this->pHead->pPrev = NULL;
            }
            else if (nodeToRemove == this->pTail)
            {
                this->pTail = this->back->prev;
                this->pTail->pNext = NULL;
            }
            else
            {
                nodeToRemove->pPrev->pNext = nodeToRemove->pNext;
                nodeToRemove->pNext->pPrev = nodeToRemove->pPrev;
            }

            delete nodeToRemove;
            nodeToRemove = NULL;
        }

        else throw (NODE_EMPTY);
    }
    catch(int)
    {
        cerr<<"NODE_EMPTY"<<endl;
        exit(1);
    }    
}

template <class Type>
void DoubleLinkList<Type>::removeHead(void)
{
    removeNode(this->pHead);
}

template <class Type>
void DoubleLinkList<Type>::removeTail(void)
{
    removeNode(this->pTail);
}


template <class Type>
Node<Type>* DoubleLinkList<Type>::begin(void)
{
    return pHead;
}

template <class Type>
Node<Type>* DoubleLinkList<Type>::end(void)
{
    return pTail->pNext;
}



int main()
{
    DoubleLinkList<int> DLList;


    for(int i = 0; i<= SIZE; ++i)
    {
        DLList.insertTail(i);
    }

    DoubleLinkList<int>::Iterator itor = DLList.begin(); 
    
    for(; itor != DLList.end(); ++ itor)
    {
        cout<<*itor<<endl;
    }

    system("pause");
    return 0;
}

可以编译运行了，但是还有很大的逻辑上的问题。你自己修改吧

[pengzhixi]

#include <iostream>
#include <vector>
#include <string>
using namespace std;

#define NODE_EMPTY -1
#define SIZE  8

// define node
template <class Type>
class Node
{
public:
    Node(void);
    ~Node(void);
    Node(Node * pNode);

    Node<Type>* pNext; //指向下一个节点
    Node<Type>* pPrev;//指向前一个节点
    Type value;
};

template <class Type> Node<Type>::Node()
:pNext(NULL),pPrev(NULL),value(0)
{
}

template <class Type> Node<Type>::~Node(void)
{
}


// define a iterator
template <class Type>
class MyIterator
{
public:
    typedef Node<Type> Node;

public:
    MyIterator(void);
    MyIterator(Node* node);
    ~MyIterator(void);

    const MyIterator& operator = (Node* pos);
    MyIterator&       operator ++ (void);
    MyIterator&       operator -- (void);
    Type&             operator * (void);
    bool              operator == (Node* pos);
    bool              operator != (Node* pos);

private:
    Node *pNode;
};

template <class Type> MyIterator<Type>::MyIterator(void)
:pNode(NULL)
{
}

template <class Type> MyIterator<Type>::MyIterator(Node* node)
:pNode (node)
{
}

template <class Type> MyIterator<Type>::~MyIterator(void)
{
    pNode = NULL;
}

template <class Type>
MyIterator<Type>& MyIterator<Type>::operator ++(void)
{
    pNode = pNode->pNext;
    return *this;
}

template <class Type>
Type&  MyIterator<Type>::operator *(void)
{
    return pNode->value;
}

template <class Type>
bool MyIterator<Type>::operator !=(typename MyIterator<Type>::Node *pos)
{
    return (pNode != pos);
}

template <class Type>
bool MyIterator<Type>::operator ==(typename MyIterator<Type>::Node *pos)
{
    return (pNode == pos);
}

template <class Type>
MyIterator<Type>& MyIterator<Type>::operator --(void)
{
    pNode = pNode->pPrev;
    return *this;
}


// DoubleLinkList
template <class Type>
class DoubleLinkList
{
public :
    typedef Node<Type> Node;
    typedef MyIterator<Type> Iterator;

public:
    DoubleLinkList(void);
    ~DoubleLinkList(void);


    Node* pHead;                               //指向头节点
    Node* pTail;                               //指向尾节点

public:
    void insertHead(Type value);               //在头部插入数据            
    void insertTail(Type value);               //在尾部插入数据
    void removeHead(void);                     //删除头部数据
    void removeTail(void);                     //删除尾部数据
    void insertBefore(Type value,Node *nodeB); //在nodeB前面插入数据
    void insertAfter(Type value,Node *nodeA);  //在nodeA后面插入数据
    void removeNode(Node *newNode);            //删除newNode

    Node* begin(void);   
    Node* end(void);

};

template <class Type>
DoubleLinkList<Type>::DoubleLinkList(void)
:pHead(NULL),pTail(NULL)
{
}

template <class Type> 
DoubleLinkList<Type>::~DoubleLinkList(void)
{
}

template <class Type> 
void DoubleLinkList<Type>::insertBefore(Type value, Node *nodeB)
{  
     Node *newNode;
    newNode = new Node();
    newNode->value = value;
     if(nodeB == pHead)
    {
        newNode->pNext = pHead;
        pHead->pPrev= nodeB;
        newNode->pPrev=NULL;
        this->pHead = newNode;    
    }else{
    newNode->pNext = nodeB;
    newNode->pPrev= nodeB->pPrev;
    nodeB->pPrev->pNext = newNode;//这里应该也有错
    nodeB->pPrev=newNode;}    
}


template <class Type>
void DoubleLinkList<Type>::insertAfter(Type value, Node *nodeA)
{
     Node *newNode;
    newNode = new Node();
    newNode->value = value;
     if(nodeA==pTail)
     {
                     this->pTail->pNext = newNode;
                     newNode->pNext=NULL;
                     newNode->pPrev=pTail;
                     pTail=newNode;
                     }else{
    newNode->pPrev = nodeA;
    newNode->pNext=nodeA->pNext;
    nodeA->pNext = newNode;//出现编译错误
    newNode->pNext->pPrev = newNode;
    nodeA->pNext = newNode;
    }
    
}

template <class Type>
void DoubleLinkList<Type>::insertHead(Type value) 
{
    Node *newNode;

    if(this->pHead == NULL)
    {
        newNode = new Node;
        this->pTail=this->pHead = newNode;
        this->pTail = newNode;
        newNode->pPrev = NULL;
        newNode->pNext = NULL;
        newNode->value = value;

    }
    else
    {
        insertBefore(value,this->pHead);
    }

}

template <class Type>
void DoubleLinkList<Type>::insertTail(Type value)
{
  //  Node *newNode;

    if(this->pTail == NULL)
    {
        this->insertHead(value);
    }
    else 
        insertAfter(value, this->pTail);
}

template <class Type>
void DoubleLinkList<Type>::removeNode(Node *nodeToRemove)
{
    try {
        if(nodeToRemove != NULL )
        {
            if(nodeToRemove == this->pHead)
            {
                this->pHead = this->pHead->pNext;
                this->pHead->pPrev = NULL;
            }
            else if (nodeToRemove == this->pTail)
            {
                this->pTail = this->back->prev;
                this->pTail->pNext = NULL;
            }
            else
            {
                nodeToRemove->pPrev->pNext = nodeToRemove->pNext;
                nodeToRemove->pNext->pPrev = nodeToRemove->pPrev;
            }

            delete nodeToRemove;
            nodeToRemove = NULL;
        }

        else throw (NODE_EMPTY);
    }
    catch(int)
    {
        cerr<<"NODE_EMPTY"<<endl;
        exit(1);
    }    
}

template <class Type>
void DoubleLinkList<Type>::removeHead(void)
{
    removeNode(this->pHead);
}

template <class Type>
void DoubleLinkList<Type>::removeTail(void)
{
    removeNode(this->pTail);
}


template <class Type>
Node<Type>* DoubleLinkList<Type>::begin(void)
{
    return pHead;
}

template <class Type>
Node<Type>* DoubleLinkList<Type>::end(void)
{
    return pTail->pNext;
}



int main()
{
    DoubleLinkList<int> DLList;


    for(int i = 0; i<= SIZE; ++i)
    {
        DLList.insertTail(i);
    }

    DoubleLinkList<int>::Iterator itor = DLList.begin(); 
    
    for(; itor != DLList.end(); ++ itor)
    {
        cout<<*itor<<endl;
    }

    system("pause");
    return 0;
}

改好了，一个小地方没注意。

[justinlm]

非常感谢呀！！