Question

我对C ++有点新鲜。我使用双链接的PriorityQueue进行分配，但它给了我一个奇怪的错误。

基本上，我有一个函数，我想返回一个指向struct（Node）的指针。由于结构是在类中定义的，我认为我应该使用范围运算符，因此函数头看起来像这样：

template <typename T>
PriorityQueue<T>::Node * PriorityQueue<T>::getNode(int index)

但是我收到了这一行的编译错误，其中写道：

错误：在＆＃39; *＆＃39;
之前的预期构造函数，析构函数或类型转换

为了返回指向此结构的指针，我必须做什么？我是否错误地使用了范围运算符？

任何建议都将不胜感激。

以下是完整的代码，如果有用的话：

#include <iostream>
#include <string>

template <typename T>
class PriorityQueue{
    public:
        struct Node{
            T data;
            int priority;
            Node * next;
            Node * prev;
        };

    PriorityQueue();
    PriorityQueue & operator=(const PriorityQueue &rhs);
    bool isEmpty();         //Returns true if queue is empty
    int getLength();        //Returns length of queue
    void enqueue(T data, int p);    //Enqueues data T with priority p
    void enqueue(T data);           //Enqueues data T with priority 1
    T dequeue();                    //Dequeues and returns data at head of queue
    void clearQueue();              //Empties queue
    T peek();                       //Returns data at head of queue without dequeing it
    T peekAt(int n);                //Returns data element n without dequeuing it
    int getPriority(int n);         //Returns priority of item at position n
    void display();                 //Prints list of data elements to screen
    void revDisplay();
  //  void swap(Node * n1, Node *n2);
    void swapUp(Node * target);     //Swaps target node with it's neighbor next in line
    bool contains(T data);          //Returns true if data exists as an element anywhere on the queue
    ~PriorityQueue();

    private:
        int size;
        Node * head, *tail;

        int getPos(Node * thisNode);
        Node * getNode(int index);
};

template <typename T>
PriorityQueue<T>::PriorityQueue(){
    size = 0;
    head = 0;
    tail = 0;
}

template <typename T>
PriorityQueue<T> & PriorityQueue<T>::operator=(const PriorityQueue &rhs){
    clearQueue();
    for(int n = 0; n < rhs.size(); n++)
        enqueue(rhs.peekAt(n));
    return *this;
}

template <typename T>
int PriorityQueue<T>::getLength(){
    return size;
}

template <typename T>
PriorityQueue<T>::Node * PriorityQueue<T>::getNode(int index){
    Node * result;
    if(size == 0){
        std::cout << "\nERROR: get node called on empty PriorityQueue\n";
        throw 3;
    } else {
        result = head;
        for(int n = 0; n < index; n++)
            result = result->prev;
    }
    return result;

}

在函数头中使用范围运算符（：:)作为返回值

0 个答案: