用户定义的"队列"类的向量
vector of user defined "queue" class
我正在尝试定义一个向量<队列>。 此向量应包含每个队列对象的起始地址。我在 List.h 中创建了一个复制构造函数和一个赋值运算符(队列有私有:列表)。但是,即使在我的程序运行之前,它也会引发错误:List.h:156:1:错误:在没有参数列表的情况下无效使用模板名称"List"队列>
这是代码(箭头出相关位)
#ifndef LIST_H
#define LIST_H
#include "ListNode.h"
using namespace std;
template <typename NODETYPE>
class List {
public:
List(const List&); <-----------copy constructor
List();
~List();
void insertAtFront(const NODETYPE& );
void insertAtBack (const NODETYPE& );
bool removeFromFront(NODETYPE& );
bool removeFromBack (NODETYPE& );
bool isEmpty() const;
void print() const;
int length() const;
List<NODETYPE>& operator=(const List&); <----- assignment operator overload (see end)
private:
ListNode<NODETYPE> *firstPtr;
ListNode<NODETYPE> *lastPtr;
ListNode<NODETYPE> *getNewNode (const NODETYPE& );
};
template <typename NODETYPE> <------------code for copy constructor
List<NODETYPE>::List(const List& source){
firstPtr = source.firstPtr;
lastPtr = source.lastPtr;}
template <typename NODETYPE>
List<NODETYPE>::List():firstPtr(0),lastPtr(0){}
template <typename NODETYPE>
List<NODETYPE>::~List(){
if (!isEmpty()){
cout<<"nDestroying node ... n";
ListNode<NODETYPE> *currentPtr = firstPtr;
ListNode<NODETYPE> *tmpPtr;
while (currentPtr != 0){
tmpPtr = currentPtr;
cout<<tmpPtr->value<<endl;
currentPtr = currentPtr->nextPtr;
delete tmpPtr;
}
}
cout<<"nAll node destroyedn";
}
template <typename NODETYPE>
void List<NODETYPE>::insertAtFront(const NODETYPE &val){
ListNode<NODETYPE>*newPtr = getNewNode(val);
if (isEmpty()){
firstPtr = lastPtr = newPtr;}
else {
newPtr ->nextPtr = firstPtr;
firstPtr = newPtr; // do not understand this frag
}}
template <typename NODETYPE>
void List<NODETYPE>::insertAtBack(const NODETYPE& val){
ListNode<NODETYPE>*newPtr = getNewNode(val);
if (isEmpty()){
firstPtr = lastPtr = newPtr;}
else {
lastPtr ->nextPtr =newPtr;
lastPtr = newPtr; // do not understand this frag
}
}
template <typename NODETYPE>
bool List<NODETYPE>::removeFromFront(NODETYPE& data)
{
if (isEmpty()){
return false;}
else
{
ListNode<NODETYPE> *tempPtr = firstPtr;
if (firstPtr == lastPtr)
firstPtr = lastPtr = 0;
else
firstPtr = firstPtr->nextPtr; // must look at detail inside DDD, what happens to the current ListNode object pointed to byfirstPtr
data = tempPtr->value;
delete tempPtr;
return true;
}
}
template <typename NODETYPE>
bool List<NODETYPE>::removeFromBack (NODETYPE& data) {
if (isEmpty){
return false;}
else
{
ListNode<NODETYPE> *tempPtr = firstPtr;
if (firstPtr == lastPtr)
firstPtr = lastPtr = 0;
else
{
ListNode<NODETYPE> *currentPtr = firstPtr;
while (currentPtr->nextPtr !=lastPtr){
currentPtr = currentPtr->nextPtr; }
lastPtr = currentPtr;
currentPtr ->nextPtr = 0;
}
data= tempPtr->value;
delete tempPtr;
return true;
}
}
template <typename NODETYPE>
bool List<NODETYPE>::isEmpty() const{ // CONSTANT MEMBER FUNCTION
return firstPtr==0;
}
// different from textbook (see p 755)
template <typename NODETYPE>
ListNode<NODETYPE>* List<NODETYPE>::getNewNode(const NODETYPE&value) {
return new ListNode <NODETYPE>(value); }
template<typename NODETYPE>
void List<NODETYPE>::print() const {
if (isEmpty()) {
cout<<" This list is emptyn";
return ;}
ListNode<NODETYPE> *currentPtr = firstPtr;
while (currentPtr !=0)
{
cout << currentPtr->value <<' ';
currentPtr = currentPtr->nextPtr;
}
cout<< "nn";
}
template <typename NODETYPE>
int List<NODETYPE>::length() const {
if (this->isEmpty()){
cout<< "n Return size of what ? .. this list is empty ";
return 0; }
int size = 1;
ListNode<NODETYPE>* currentPtr = firstPtr;
while (currentPtr != lastPtr) {
currentPtr = currentPtr->nextPtr;
size +=1;
}
return size;
}
template<typename NODETYPE>
List<NODETYPE>& List<NODETYPE>::operator=(List& rhs) <---- line of error
{
if (this !=&rhs){
this->firstPtr = rhs.firstPtr;
this->lastPtr = rhs.lastPtr;
return &firstPtr;
}
#endif
调用程序如下:
#include <iostream>List& operator=(const List&);
#include <vector>
#include "Queue.h"
#include <algorithm>
using namespace std;
int main () {
vector < Queue <int> > dodo;
for (int init = 0; init<4;init++ ){
dodo.push_back(init);
vector <Queue <int> >::const_iterator iterator;
for (iterator = dodo.begin();iterator !=dodo.end();iterator ++){
cout<<"Address of each queue item "<<dodo[]<<'t'<<&dodo[];}
int dequeueInteger;
Queue <int> intQueue;
cout <<"n Size is .. " <<intQueue.howbig();
cout << "nProcessing integer Queuen";
for (int i=0;i<3;++i) {
intQueue.enqueue(i);
intQueue.printQueue(); }
Queue<int> photo;
photo = intQueue;
cout <<"nn Here is mr. photo";
photo.printQueue();
cout<<endl<<"nSize of this queue is .. " <<intQueue.howbig();
cout<<endl;
while (!intQueue.isQueueEmpty()){
intQueue.dequeue(dequeueInteger);
cout<<dequeueInteger<<" dequeuedn";
intQueue.printQueue();
}
}
文件 Queue.h
#ifndef QUEUE_H
#define QUEUE_H
#include "List.h"
template <typename QUEUETYPE>
class Queue : private List< QUEUETYPE >
{
public:
void enqueue (const QUEUETYPE &data) {
insertAtBack(data);}
bool dequeue (QUEUETYPE &data) {
return removeFromFront(data); }
bool isQueueEmpty ()const {
return this->isEmpty(); }
void printQueue() const {
this ->print(); }
int howbig() const {
return this->length();
}
};
#endif
缺少返回值的模板参数
template<typename NODETYPE>
List<NODETYPE>& List<NODTETYPE>::operator=(List& rhs)
^^^^^^^^^^
你需要它,因为编译器不知道他正在解析List
成员,其中List
表示当前模板实例化,直到List<NODETYPE>::
之后。
相关文章:
- 向量成员在管理类指针C++队列时丢失
- C++ Poco - 如何创建通知队列的向量?
- 为什么我们需要在优先级队列声明中添加一个向量作为参数?
- C++:自定义数据类型向量错误的队列
- C++ 如何将unique_ptr队列添加到向量
- 为什么优先级队列是使用堆实现的,而我们可以更有效地使用向量来实现它
- 我有一个问题,创建了C 中阻塞队列的向量
- 在C++中使用队列和堆栈对 2 个向量进行加减
- 如何以相反的顺序将整个向量复制到队列中
- 如何获得向量队列的前部或顶部元素
- 使用优先级队列初始化向量
- 在队列中插入向量元素
- 使用更大值和向量声明优先级队列
- 如何构造队列向量
- 创建固定大小队列的向量(提升循环队列)
- 将向量、队列和指向函数的指针传递给函数
- 从队列中弹出向量
- 向量和队列C++
- 用户定义的"队列"类的向量
- 使用向量C++的双精度的优先级队列