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

标签 c++ templates queue

这是我第一次遇到无法通过简单的谷歌搜索解决的问题。 我在 C++ 作业中遇到问题。作为 Startup，我们不允许更改 main.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);

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

我尝试了使用构造函数的不同方法(带和不带初始化列表)。我尝试了特化。如果我将友元运算符 << 的特殊化放在头文件中(我认为总是这样做)，我会收到此错误:

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

希望你能帮助我。

这是不应更改的 main.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_ */

和Queue.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);

最佳答案

Queue.hpp结尾，你有:

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>;

所有这些构造都声明相应类模板的模板特化Queue_el和Queue .

您可能想要的是显式模板实例化。语法上的区别在于后者缺少 <>之后template关键字:

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>;

但是，请注意，这只能在模板完全定义的地方完成。因此，您需要将其放在 Queue.cpp 的末尾。 ，而不是 Queue.hpp 的末尾:

关于C++ 聚合类型不完整，无法使用模板类定义，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/59134809/

上一篇：r - glmnet 预测方法抛出神秘错误

下一篇：gitlab - 带有自托管 Gitlab 的 Netlify CMS

相关文章：

c++ - 奇怪的 g++ 编译器在模板函数中对 typeid 的行为

java - 实现一个队列，您可以在特定位置插入元素，同时在恒定时间内入队/出队？

c++ - 了解 double 到 int64_t 的转换

C++、CMake 和 Xcode 符号导航器

c++ - 通用基类合法吗？

wpf - 可重复使用的多边形

java - Amazon SQS 长轮询不返回所有消息

algorithm - 我需要一些帮助来理解使用堆栈实现队列

c++ - 指针和容器

c++ - 静态函数中的非静态参数

©2024 IT工具网  联系我们