C++ 聚合的类型不完整，无法使用模板类定义

这是我第一次遇到无法通过简单的谷歌解决的问题。 我在 c++ 中作业分配有问题。作为初创公司，我们不允许更改主要.cpp。 任务是编写双链表并使用模板类。

我收到错误

aggregate Queue<std::__cxx11::basic_string<char> > q1' has incomplete type and cannot be defined Queue<string> q1;

和

variable 'Queue<double> q3' has initializer but incomplete type
Queue<double> q3(q2);

如果我用谷歌搜索这些错误，那么 ansare 是，我可能没有在头文件中正确声明我的类或类似的声明或定义错误。但我找不到我犯的错误。

我已经尝试了构造函数的不同配置(带和不带初始值设定项列表(。我尝试了特殊化。如果我将 friend 运算符<<的特殊化放在头文件中(我认为总是这样做(，我会收到此错误：

expected initializer before '<' token
std::ostream& operator<< <std::string>

我希望你能帮助我。

这是主要的.cpp不应该改变：

#include <iostream>
#include <iomanip>
#include <ctime>
#include <utility>
#include <string>
#include "Queue.hpp"

using namespace std;
int main()
{
cout << boolalpha;
Queue<string> q1;
cout << "Queue q1 ist leer: " << q1.empty() << endl << endl;
q1.push("Bergische");
q1.push("Universitaet");
q1.push("Wuppertal");
cout << "Queue q1:" << endl << q1 << endl;
cout << "Pop erstes Element: " << q1.pop() << endl << endl;
cout << "Queue q1:" << endl << q1 << endl;
Queue<double> q2;
q2.push(3.1415);
q2.push(2.7182);
cout << "Queue q2:" << endl << q2 << endl;
cout << "Groesse von q2: " << q2.size() << endl << endl;
Queue<double> q3(q2);
cout << "Queue q3 aus q2 mit Copy-Konstruktor: " << q3 << endl;
Queue<int> q4;
for(int i=0; i<100000000; ++i)
q4.push(i);
cout << "Groesse von q4: " << q4.size() << endl;
cout << fixed << setprecision(8);
cout << "Beginne Zeitmessung Copy-Konstruktor... " << flush;
clock_t start = clock();
Queue<int> q4copy(q4);
clock_t end = clock();
cout << (end-start)/(double)CLOCKS_PER_SEC << " Sekunden" << endl;
cout << "Groesse von q4:     " << q4.size() << endl;
cout << "Groesse von q4copy: " << q4copy.size() << endl;
cout << "Beginne Zeitmessung Move-Konstruktor... " << flush;
start = clock();
Queue<int> q4move(move(q4));
end = clock();
cout << (end-start)/(double)CLOCKS_PER_SEC << " Sekunden" << endl;
cout << "Groesse von q4:     " << q4.size() << endl;
cout << "Groesse von q4move: " << q4move.size() << endl;
return 0;
}

队列.hpp：

#ifndef QUEUE_HPP_
#define QUEUE_HPP_

#include <iostream>
#include <iomanip>
#include <ctime>
#include <utility>
#include <string>
template<typename T>
class Queue;
template<typename T>
class Queue_el{
private:
Queue_el* pHeadEl;
Queue_el* pTailEl;
T data;
public:
Queue_el(Queue_el* a = nullptr, Queue_el* b = nullptr);
Queue_el(const Queue_el &q);
~Queue_el();
Queue_el& operator=(Queue_el q);
friend class Queue<T>;
template<typename U>
friend std::ostream& operator<<(std::ostream& os, const Queue_el<U> &q);
};
template<typename T>
class Queue{
private:
Queue_el<T>* pHead;
Queue_el<T>* pTail;
public:
Queue(Queue_el<T>* a = nullptr, Queue_el<T>* b = nullptr);
Queue(const Queue &q);
~Queue();
Queue(Queue&& q);
Queue& operator=(const Queue&q);
Queue& operator=(Queue&& q);
void push(T data) const;
T pop() const;
bool empty() const;
int size() const;
friend class Queue_el<T>;
template <typename U>
friend std::ostream& operator<<(std::ostream& os, const Queue<U> &q);

};

template<> class Queue_el<std::string>;
template<> class Queue_el<double>;
template<> class Queue_el<int>;
template<> class Queue<std::string>;
template<> class Queue<double>;
template<> class Queue<int>;

#endif /* QUEUE_HPP_ */

和队列.cpp：

#include "Queue.hpp"

template<typename T>
Queue<T>::Queue(Queue_el<T>* a, Queue_el<T>* b)
:pHead(a), pTail(b)
{
};
template<typename T>
Queue<T>::Queue(const Queue<T> &q) {
Queue_el<T> *buffer = nullptr;
Queue_el<T> *bufferq = q.pHead;
buffer = new Queue_el<T>;
pHead = buffer;
buffer = buffer->pTailEl;
bufferq = bufferq->pTailEl;
while (bufferq->pTailEl != nullptr){
buffer = new Queue_el<T>;
*buffer = *bufferq;
buffer = buffer->pTailEl;
bufferq = bufferq->pTailEl;
}
pTail = buffer;
}
template<typename T>
Queue<T>::~Queue() {
if (pHead != nullptr) {
Queue_el<T> *buffer1 = pHead;
Queue_el<T> *buffer2 = pHead;
while (buffer1->pTailEl != nullptr) {
buffer1 = buffer1->pTailEl;
delete buffer2;
buffer2 = buffer1;
}
delete buffer1;
}
}
template<typename T>
Queue<T>::Queue(Queue<T> &&q){ //move Konstruktor
pHead = q.pHead;
pTail = q.pTail;
q.pHead = nullptr;
q.pTail = nullptr;
}
template<typename T>
Queue<T>& Queue<T>::operator=(const Queue<T> &q) {
if (this != &q) {
if (pHead != nullptr) {     
Queue_el<T> *buffer1 = pHead;
Queue_el<T> *buffer2 = pHead;
while (buffer1->pTailEl != nullptr) {
buffer1 = buffer1->pTailEl;
delete buffer2;
buffer2 = buffer1;
}
delete buffer1;
pHead = nullptr;
pTail = nullptr;
}
if (q.pHead != nullptr) {   
Queue_el<T> *buffer = pHead;
Queue_el<T> *bufferq = q.pHead;
do {
buffer = new Queue_el<T>;
*buffer = *bufferq;
buffer = buffer->pTailEl;
bufferq = bufferq->pTailEl;
} while (bufferq->pTailEl != nullptr);
pTail = buffer;
}
}
return *this;
}
template<typename T>
Queue<T>& Queue<T>::operator=(Queue<T> &&q) { 
if(this != &q){
pHead = q.pHead;
pTail = q.pTail;
q.pHead = nullptr;
q.pTail = nullptr;
}
return *this;
}
template<typename T>
void Queue<T>::push(T data) const {
if (pTail != nullptr) {
pTail->pTailEl = new Queue_el<T>;
pTail->pTailEl->pHeadEl = pTail;
pTail = pTail->pTailEl;
*pTail = data;
} else {                        
pTail = new Queue_el<T>(data);
pHead = pTail;
}
return;
}
template<typename T>
T Queue<T>::pop() const {
if (pHead != nullptr) {
if (pHead->pTailEl != nullptr) {
Queue_el<T> *buffer = pHead;
pHead = pHead->pTailEl;
pHead->pHeadEl = nullptr;
std::cout <<"Pop here: ";
return buffer;
} else {
Queue_el<T> *buffer = pHead;
delete pHead;
pHead = nullptr;
pTail = nullptr;
return *buffer;
}
}
}
template<typename T>
bool Queue<T>::empty() const {
if (pHead == nullptr) {
return true;
} else {
return false;
}
}
template<typename T>
int Queue<T>::size() const {
int i = 0;
if (pHead != nullptr) {
Queue_el<T> *buffer = pHead;
i++;
while (buffer->pTailEl != nullptr) {
buffer = buffer->pTailEl;
i++;
}
}
return i;
}
template<typename U>
std::ostream& operator<<(std::ostream& os, const Queue<U> &q){
if(q.pHead != nullptr){
Queue_el<U>* buffer = q.pHead;
os << buffer << std::endl;          
while(buffer->pTailEl != nullptr){  
buffer = buffer->pTailEl;
os << buffer << std::endl;
};
}
return os;
}
template<> std::ostream& operator<< <std::string>
(std::ostream& os, const Queue<std::string> &q);
template<> std::ostream& operator<< <double>
(std::ostream& os, const Queue<double> &q);
template<> std::ostream& operator<< <int>
(std::ostream& os, const Queue<int> &q);


template<typename T>
Queue_el<T>::Queue_el(Queue_el<T>* a, Queue_el<T>* b)
:pHeadEl(a), pTailEl(b)
{
}
template<typename T>
Queue_el<T>::Queue_el(const Queue_el<T> &q)
{
data = q.data;
pHeadEl = nullptr;
pTailEl = nullptr;
}
template<typename T>
Queue_el<T>::~Queue_el(){
std::cout << "Element zerstört" << std::endl;
}
template<typename T>
Queue_el<T>& Queue_el<T>::operator=(Queue_el<T> q){
data = q.data;
return data;
}
template<typename U>
std::ostream& operator<<(std::ostream& os, const Queue_el<U> &q){
os << q.data;
return os;
}
template<>
std::ostream& operator<< <std::string> (std::ostream& os, const Queue_el<std::string> &q);
template<>
std::ostream& operator<< <double>(std::ostream& os, const Queue_el<double> &q);
template<>
std::ostream& operator<< <int>(std::ostream& os, const Queue_el<int> &q);