首先， 开门见山， 这个难题的解决办法是用this指针， 或者使用父类配合着scope resolution。 这个问题是我在学习linked list as an ADT , linked list 是含有纯虚函数， 所以是抽象基础类。 然后又linked list 继承出unordered linked list。 注意， 还可以
首先， 开门见山， 这个难题的解决办法是用this指针， 或者使用父类配合着scope resolution。
这个问题是我在学习linked list as an ADT , linked list 是含有纯虚函数， 所以是抽象基础类。 然后又linked list 继承出unordered linked list。 注意， 还可以由linked list 继承出ordered linked list。
言归正传， 出现问题的代码如下：
linkedlist.h 文件如下：
#ifndef H_LinkedListType #define H_LinkedListType #include#include using namespace std; //Definition of the node template struct nodeType { Type info; nodeType *link; }; template class linkedListIterator { public: linkedListIterator(); //Default constructor //Postcondition: current = NULL; linkedListIterator(nodeType *ptr); //Constructor with a parameter. //Postcondition: current = ptr; Type operator*(); //Function to overload the dereferencing operator *. //Postcondition: Returns the info contained in the node. linkedListIterator operator++(); //Overload the pre-increment operator. //Postcondition: The iterator is advanced to the next // node. bool operator==(const linkedListIterator & right) const; //Overload the equality operator. //Postcondition: Returns true if this iterator is equal to // the iterator specified by right, // otherwise it returns the value false. bool operator!=(const linkedListIterator & right) const; //Overload the not equal to operator. //Postcondition: Returns true if this iterator is not // equal to the iterator specified by // right; otherwise it returns the value // false. private: nodeType *current; //pointer to point to the current //node in the linked list }; template linkedListIterator ::linkedListIterator() { current = NULL; } template linkedListIterator :: linkedListIterator(nodeType *ptr) { current = ptr; } template Type linkedListIterator ::operator*() { return current->info; } template linkedListIterator linkedListIterator ::operator++() { current = current->link; return *this; } template bool linkedListIterator ::operator== (const linkedListIterator & right) const { return (current == right.current); } template bool linkedListIterator ::operator!= (const linkedListIterator & right) const { return (current != right.current); } //***************** class linkedListType **************** template class linkedListType { public: const linkedListType & operator= (const linkedListType &); //Overload the assignment operator. void initializeList(); //Initialize the list to an empty state. //Postcondition: first = NULL, last = NULL, count = 0; bool isEmptyList() const; //Function to determine whether the list is empty. //Postcondition: Returns true if the list is empty, // otherwise it returns false. void print() const; //Function to output the data contained in each node. //Postcondition: none int length() const; //Function to return the number of nodes in the list. //Postcondition: The value of count is returned. void destroyList(); //Function to delete all the nodes from the list. //Postcondition: first = NULL, last = NULL, count = 0; Type front() const; //Function to return the first element of the list. //Precondition: The list must exist and must not be // empty. //Postcondition: If the list is empty, the program // terminates; otherwise, the first // element of the list is returned. Type back() const; //Function to return the last element of the list. //Precondition: The list must exist and must not be // empty. //Postcondition: If the list is empty, the program // terminates; otherwise, the last // element of the list is returned. virtual bool search(const Type& searchItem) const = 0; //Function to determine whether searchItem is in the list. //Postcondition: Returns true if searchItem is in the // list, otherwise the value false is // returned. virtual void insertFirst(const Type& newItem) = 0; //Function to insert newItem at the beginning of the list. //Postcondition: first points to the new list, newItem is // inserted at the beginning of the list, // last points to the last node in the list, // and count is incremented by 1. virtual void insertLast(const Type& newItem) = 0; //Function to insert newItem at the end of the list. //Postcondition: first points to the new list, newItem // is inserted at the end of the list, // last points to the last node in the list, // and count is incremented by 1. virtual void deleteNode(const Type& deleteItem) = 0; //Function to delete deleteItem from the list. //Postcondition: If found, the node containing // deleteItem is deleted from the list. // first points to the first node, last // points to the last node of the updated // list, and count is decremented by 1. linkedListIterator begin(); //Function to return an iterator at the begining of the //linked list. //Postcondition: Returns an iterator such that current is // set to first. linkedListIterator end(); //Function to return an iterator one element past the //last element of the linked list. //Postcondition: Returns an iterator such that current is // set to NULL. linkedListType(); //default constructor //Initializes the list to an empty state. //Postcondition: first = NULL, last = NULL, count = 0; linkedListType(const linkedListType & otherList); //copy constructor ~linkedListType(); //destructor //Deletes all the nodes from the list. //Postcondition: The list object is destroyed. protected: int count; //variable to store the number of //elements in the list nodeType *first; //pointer to the first node of the list nodeType *last; //pointer to the last node of the list private: void copyList(const linkedListType & otherList); //Function to make a copy of otherList. //Postcondition: A copy of otherList is created and // assigned to this list. }; template bool linkedListType ::isEmptyList() const { return(first == NULL); } template linkedListType ::linkedListType() //default constructor { first = NULL; last = NULL; count = 0; } template void linkedListType ::destroyList() { nodeType *temp; //pointer to deallocate the memory //occupied by the node while (first != NULL) //while there are nodes in the list { temp = first; //set temp to the current node first = first->link; //advance first to the next node delete temp; //deallocate the memory occupied by temp } last = NULL; //initialize last to NULL; first has already //been set to NULL by the while loop count = 0; } template void linkedListType ::initializeList() { destroyList(); //if the list has any nodes, delete them } template void linkedListType ::print() const { nodeType *current; //pointer to traverse the list current = first; //set current so that it points to //the first node while (current != NULL) //while more data to print { cout info link; } }//end print template int linkedListType ::length() const { return count; } //end length template Type linkedListType ::front() const { assert(first != NULL); return first->info; //return the info of the first node }//end front template Type linkedListType ::back() const { assert(last != NULL); return last->info; //return the info of the last node }//end back template linkedListIterator linkedListType ::begin() { linkedListIterator temp(first); return temp; } template linkedListIterator linkedListType ::end() { linkedListIterator temp(NULL); return temp; } template void linkedListType ::copyList (const linkedListType & otherList) { nodeType *newNode; //pointer to create a node nodeType *current; //pointer to traverse the list if (first != NULL) //if the list is nonempty, make it empty destroyList(); if (otherList.first == NULL) //otherList is empty { first = NULL; last = NULL; count = 0; } else { current = otherList.first; //current points to the //list to be copied count = otherList.count; //copy the first node first = new nodeType ; //create the node first->info = current->info; //copy the info first->link = NULL; //set the link field of //the node to NULL last = first; //make last point to the //first node current = current->link; //make current point to //the next node //copy the remaining list while (current != NULL) { newNode = new nodeType ; //create a node newNode->info = current->info; //copy the info newNode->link = NULL; //set the link of //newNode to NULL last->link = newNode; //attach newNode after last last = newNode; //make last point to //the actual last node current = current->link; //make current point //to the next node }//end while }//end else }//end copyList template linkedListType ::~linkedListType() //destructor { destroyList(); }//end destructor template linkedListType ::linkedListType (const linkedListType & otherList) { first = NULL; copyList(otherList); }//end copy constructor //overload the assignment operator template const linkedListType & linkedListType ::operator= (const linkedListType & otherList) { if (this != &otherList) //avoid self-copy { copyList(otherList); }//end else return *this; } #endif
#ifndef H_UnorderedLinkedList #define H_UnorderedLinkedList #include "linkedList.h" using namespace std; templateclass unorderedLinkedList: public linkedListType { public: bool search(const Type& searchItem) const; //Function to determine whether searchItem is in the list. //Postcondition: Returns true if searchItem is in the // list, otherwise the value false is // returned. void insertFirst(const Type& newItem); //Function to insert newItem at the beginning of the list. //Postcondition: first points to the new list, newItem is // inserted at the beginning of the list, // last points to the last node in the // list, and count is incremented by 1. void insertLast(const Type& newItem); //Function to insert newItem at the end of the list. //Postcondition: first points to the new list, newItem // is inserted at the end of the list, // last points to the last node in the // list, and count is incremented by 1. void deleteNode(const Type& deleteItem); //Function to delete deleteItem from the list. //Postcondition: If found, the node containing // deleteItem is deleted from the list. // first points to the first node, last // points to the last node of the updated // list, and count is decremented by 1. }; template bool unorderedLinkedList :: search(const Type& searchItem) const { nodeType *current; //pointer to traverse the list bool found = false; current = first; //set current to point to the first //node in the list while (current != NULL && !found) //search the list if (current->info == searchItem) //searchItem is found found = true; else current = current->link; //make current point to //the next node return found; }//end search template void unorderedLinkedList ::insertFirst(const Type& newItem) { nodeType *newNode; //pointer to create the new node newNode = new nodeType ; //create the new node newNode->info = newItem; //store the new item in the node newNode->link = this -> first; //insert newNode before first first = newNode; //make first point to the //actual first node count++; //increment count if (last == NULL) //if the list was empty, newNode is also //the last node in the list last = newNode; }//end insertFirst template void unorderedLinkedList ::insertLast(const Type& newItem) { nodeType *newNode; //pointer to create the new node newNode = new nodeType ; //create the new node newNode->info = newItem; //store the new item in the node newNode->link = NULL; //set the link field of newNode //to NULL if ( first == NULL) //if the list is empty, newNode is //both the first and last node { first = newNode; last = newNode; count++; //increment count } else //the list is not empty, insert newNode after last { last->link = newNode; //insert newNode after last last = newNode; //make last point to the actual //last node in the list count++; //increment count } }//end insertLast template void unorderedLinkedList ::deleteNode(const Type& deleteItem) { nodeType *current; //pointer to traverse the list nodeType *trailCurrent; //pointer just before current bool found; if (first == NULL) //Case 1; the list is empty. cout info == deleteItem) //Case 2 { current = first; first = first->link; count--; if (first == NULL) //the list has only one node last = NULL; delete current; } else //search the list for the node with the given info { found = false; trailCurrent = first; //set trailCurrent to point //to the first node current = first->link; //set current to point to //the second node while (current != NULL && !found) { if (current->info != deleteItem) { trailCurrent = current; current = current-> link; } else found = true; }//end while if (found) //Case 3; if found, delete the node { trailCurrent->link = current->link; this -> count--; if (last == current) //node to be deleted //was the last node last = trailCurrent; //update the value //of last delete current; //delete the node from the list } else cout
主程序如下main.cpp：//This program tests various operation of a linked list //34 62 21 90 66 53 88 24 10 -999 #include#include "unorderedLinkedList.h" using namespace std; int main() { unorderedLinkedList list1, list2; //Line 1 int num; //Line 2 cout > num; //Line 4 while (num != -999) //Line 5 { list1.insertLast(num); //Line 6 cin >> num; //Line 7 } cout > num; //Line 19 cout it; //Line 27 for (it = list1.begin(); it != list1.end(); ++it) //Line 28 cout
编译结果error message 如下：
错误分析： 按照标准看， 上述的错误似乎有点问题。 因为first， last， count 都是父类的成员变量。 存取类型是protected。 我们的子类unorderedLinkedList 类是公开方式（public）继承linkedList。按说子类即unorderedLinkedList 的成员函数（虚函数）当然可以access 父类的protected 成员变量。 但是在这里出错了。 为什么呢？
原因是我们这里是模板类之间的继承。 如果是正常的普通类之间的继承， 结果一定是没有问题的。 当然access会通过， 编译会okay。 但是这里是模本类之间的继承。
在这里， 我们需要使用this 指针， 也可以使用scope resolution解决模板类之间的继承时变量访问的问题。 下面我们修改unorderedLinkedList.h 如下：
将模板成员函数定义count， first， last 分别用this -> count, this -> first, this -> last（第二中解决办法是换为linkedListType
::first, linkedListType ::count,linkedListType ::last）。 不光如此， 当在子类中调用模板父类的成员函数的时候， 也要使用this 指针或者用scope resotion 解决这个问题。
#ifndef H_UnorderedLinkedList #define H_UnorderedLinkedList #include "linkedList.h" using namespace std; templateclass unorderedLinkedList: public linkedListType { public: bool search(const Type& searchItem) const; //Function to determine whether searchItem is in the list. //Postcondition: Returns true if searchItem is in the // list, otherwise the value false is // returned. void insertFirst(const Type& newItem); //Function to insert newItem at the beginning of the list. //Postcondition: first points to the new list, newItem is // inserted at the beginning of the list, // last points to the last node in the // list, and count is incremented by 1. void insertLast(const Type& newItem); //Function to insert newItem at the end of the list. //Postcondition: first points to the new list, newItem // is inserted at the end of the list, // last points to the last node in the // list, and count is incremented by 1. void deleteNode(const Type& deleteItem); //Function to delete deleteItem from the list. //Postcondition: If found, the node containing // deleteItem is deleted from the list. // first points to the first node, last // points to the last node of the updated // list, and count is decremented by 1. }; template bool unorderedLinkedList :: search(const Type& searchItem) const { nodeType *current; //pointer to traverse the list bool found = false; current = this -> first; //set current to point to the first //node in the list while (current != NULL && !found) //search the list if (current->info == searchItem) //searchItem is found found = true; else current = current->link; //make current point to //the next node return found; }//end search template void unorderedLinkedList ::insertFirst(const Type& newItem) { nodeType *newNode; //pointer to create the new node newNode = new nodeType ; //create the new node newNode->info = newItem; //store the new item in the node newNode->link = this -> first; //insert newNode before first this -> first = newNode; //make first point to the //actual first node this -> count++; //increment count if (this -> last == NULL) //if the list was empty, newNode is also //the last node in the list this -> last = newNode; }//end insertFirst template void unorderedLinkedList ::insertLast(const Type& newItem) { nodeType *newNode; //pointer to create the new node newNode = new nodeType ; //create the new node newNode->info = newItem; //store the new item in the node newNode->link = NULL; //set the link field of newNode //to NULL if ( this -> first == NULL) //if the list is empty, newNode is //both the first and last node { this -> first = newNode; this -> last = newNode; this -> count++; //increment count } else //the list is not empty, insert newNode after last { this -> last->link = newNode; //insert newNode after last this -> last = newNode; //make last point to the actual //last node in the list this -> count++; //increment count } }//end insertLast template void unorderedLinkedList ::deleteNode(const Type& deleteItem) { nodeType *current; //pointer to traverse the list nodeType *trailCurrent; //pointer just before current bool found; if (this -> first == NULL) //Case 1; the list is empty. cout first->info == deleteItem) //Case 2 { current = this -> first; this -> first = this -> first->link; this -> count--; if (this -> first == NULL) //the list has only one node this -> last = NULL; delete current; } else //search the list for the node with the given info { found = false; trailCurrent = this -> first; //set trailCurrent to point //to the first node current = this -> first->link; //set current to point to //the second node while (current != NULL && !found) { if (current->info != deleteItem) { trailCurrent = current; current = current-> link; } else found = true; }//end while if (found) //Case 3; if found, delete the node { trailCurrent->link = current->link; this -> count--; if (this -> last == current) //node to be deleted //was the last node this -> last = trailCurrent; //update the value //of last delete current; //delete the node from the list } else cout
编译通过， 运行结果如下：
关于这个模板继承， 子类使用父类的成员是使用this， 或者scope resolution， 解释如下：
//To make the code valid either use this->f(), or Base::f(). Using the -fpermissive flag will also
//let the compiler accept the code, by marking all function calls for which no declaration is visible
//at the time of definition of the template for later lookup at instantiation time, as if it were a
//dependent call. We do not recommend using -fpermissive to work around invalid code, and it will also
//only catch cases where functions in base classes are called, not where variables in base classes are
//used (as in the example above).
//
//Note that some compilers (including G++ versions prior to 3.4) get these examples wrong and accept above
//code without an error. Those compilers do not implement two-stage name lookup correctly.
//
接下来是我在stack overflow 网站上得到的解答：