C ++：预期的构造函数，析构函数或类型转换

Question

试着学习C ++。 想知道是否有人可以指出我在这个错误的正确方向（双关语意图）。

该类是LinkedList（下面全部复制）。 此行发生错误：

LinkedList<T>::ListNode LinkedList::find(int pos) const {

并说：

'LinkedList'之前的预期构造函数，析构函数或类型转换

任何提示将非常感谢。

#ifndef LINKEDLIST_HPP
#define LINKEDLIST_HPP


#include <iostream>

using namespace std;

template <class T>
class LinkedList {

    private:
        // a ListNode consists of the item and a pointer to the next ListNode
        struct ListNode {
            T data;
            ListNode *next;
        };
        int size; //Size of the list
        ListNode *head; //the beginning of the list

    public:
        LinkedList(); // default oonstructor
        ~LinkedList(); // destructor
        virtual bool isEmpty ();
        virtual int  getLength ();
        virtual void insert (int pos, T item);
        virtual T    remove (int pos);
        virtual T    retrieve (int pos);

        //helper methods
        LinkedList(LinkedList &copyList); //copy constructor
        ListNode *find (int pos) const; // internal find function
};

//default constructor
template <class T>
LinkedList<T>::LinkedList() {
    size = 0;
    head = NULL;
}

//destructor
template <class T>
LinkedList<T>::~LinkedList() {
    //loop through each node, and delete it
    ListNode* current = head;
    while (current != NULL) {
        ListNode* next = current->next;
        delete current;
        current = next;
    }
    head = NULL; // set head node to back to null
}

//copy constructor
template <class T>
LinkedList<T>::LinkedList(LinkedList& copyList) {
    size = copyList.size;

    // if copyList is empty
    if (copyList.head == NULL)
        head = NULL;

    else {
        //create a new head
        head = new ListNode;
        head->data = copyList.head->data;

        //create a new list
        ListNode *newPtr = head; // start at the head
        // iterate through rest of list to be copied
        for (ListNode *copyPtr = copyList.head->next; copyPtr != NULL; copyPtr = copyPtr->next) {
            newPtr->next = new ListNode;
            newPtr->data = copyPtr->data;
        }
        //make last ListNode's next point to NULL
        newPtr->next = NULL;
    }
}

template <class T>
bool LinkedList<T>::isEmpty() {
    if (size == 0)
        return true;
    return false;
}

template <class T>
int LinkedList<T>::getLength() {
    return size;
}

// used in other methods to find a given index
template <class T>
LinkedList<T>::ListNode LinkedList::find(int pos) const {

    // check that pos is in bound of LinkedList
    if ((pos < 1) || pos > getLength()) {
        cout << "Find position of out bounds" << endl;
        return NULL;
    } else { //search through ListNodes
        ListNode *temp = head; // start at the head
        for (int i = 1; i < pos; ++i)
            temp = temp->next;
        return temp;
    }
}


template <class T>
T LinkedList<T>::retrieve(int pos) {
    T tempData; // to hold retrieved data
    try {
        if ((pos < 1) || (pos > getLength())) {
            cout << "Retrieve request outside LinkedList's bounds" << endl;
            return NULL;
        }
        else { //traverse list
            ListNode *temp = find(pos);
            tempData = temp->data;
            return tempData;
        }
    } catch (int e) {
        cout << "Could not retrieve position " << pos << endl;
    }
}

template <class T>
void LinkedList<T>::insert(int pos, T item) {

    //check bounds
    if ((pos < 1) || (pos > getLength() +1))
        cout << "Must insert at a position between 1 and getLength() + 1" << endl;

    else {
        try {
            //create new ListNode
            ListNode *temp = new ListNode;
            temp->data = item;

            //if the new item is at the first position
            if (pos == 1) {
                temp->next = head;
                head = temp;
            }
            else {
                ListNode *prev = find(pos - 1);
                temp->next = prev->next;
                prev->next = temp;
            }
            //increment size
            ++size;

        } catch (int e) {
            cout << "Error inserting " << item << " at position " << pos << endl;
        }
    }
}

template <class T>
T LinkedList<T>::remove(int pos) {

    //check bounds
    if ((pos < 1) || (pos > getLength()))
        cout << "Must remove a position between 1 and getLength()" << endl;

    else {
        try {

            ListNode *temp; //to hold shifted node

            //if node to be deleted is first node
            if (pos == 1) {
                temp = head;
                head = head->next;
            }
            //for anything but the head
            //write over the node before the pos'th index
            else {
                ListNode *prev = find(pos - 1);
                temp = prev->next;
                prev->next = temp->next;
            }

            //destroy temp, to free up memory
            temp->next = NULL;
            delete temp;

            //decrement size
            --size;

        } catch (int e) {
            cout << "Error removing item from position " << pos << endl;
        }
    }


}

#endif  /* LINKEDLIST_HPP */

Answer 1

使用typename限定依赖类型并添加<T> （我不确定这是否有必要，不妨这样做）：

typename LinkedList<T>::ListNode* LinkedList<T>::find(int pos) const {

请参阅： 我必须在何处以及为何要使用“模板”和“typename”关键字？

此外，您的定义不匹配。 它在类中返回一个指针，但在它之外返回一个值。

Answer 2

ListNode是一个依赖类型，因此需要使用typename进行限定。 此外，您的find函数被声明为返回指向ListNode的指针，但该定义按值返回ListNode 。 这似乎是一个简单的错字：

template <class T>
typename LinkedList<T>::ListNode* LinkedList<T>::find(int pos) const {

Answer 3

应该

LinkedList<T>::ListNode LinkedList<T>::find(int pos) const {