C++ C++；初始化堆上的模板类时出错

我有一个队列类具有以下定义：

    template <typename T>
    class SharedQueue
    {
    public:
        SharedQueue();
        ~SharedQueue();
    };

模板
类共享队列
{
公众：
SharedQueue（）；
~SharedQueue（）；
};

在test.h中，我将以下变量作为类中的一个变量：

SharedQueue<int>* sharedQueue;

SharedQueue*SharedQueue；

在test.cpp中，我尝试执行以下操作：

sharedQueue = new SharedQueue<int>;

sharedQueue=新的sharedQueue；

但是，出于某种原因，它给了我错误。我没有正确初始化模板类吗

我看了看，注意到了这一点：但很难看出这对我有多重要

更新： 错误是

Error   LNK2001 unresolved external symbol "public: __cdecl SharedQueue<int>::SharedQueue<int>(void)" (??0?$SharedQueue@H@@QEAA@XZ) Demo    C:\test\foo.obj 1       

1 unresolved externals

错误LNK2001未解析的外部符号“public:\u cdecl SharedQueue:：SharedQueue（void）”（？0$SharedQueue@H@@QEAA@XZ)演示C:\test\foo.obj 1
1未解决的外部问题

更新二：

SharedQueue.h：

#pragma once

#include <queue>
#include <mutex>
#include <condition_variable>

template <typename T>
class SharedQueue
{
public:
    SharedQueue();
    ~SharedQueue();
    T& front();
    void pop_front();
    void push_back(const T& item);
    void push_back(T&& item);
    int size();
    bool empty();

private:
    std::deque<T> queue_;
    std::mutex mutex_;
    std::condition_variable cond_;
};

#pragma一次
#包括
#包括
#包括
模板
类共享队列
{
公众：
SharedQueue（）；
~SharedQueue（）；
T&front（）；
void pop_front（）；
无效推回（常数和项目）；
无效推回（T和项目）；
int size（）；
bool empty（）；
私人：
std：：deque queue_u2;；
std:：mutex mutex；
std：：条件变量cond；
};

SharedQueue.cpp：

#include "SharedQueue.h"

template <typename T>
SharedQueue<T>::SharedQueue()
{

}

template <typename T>
SharedQueue<T>::~SharedQueue()
{

}

template <typename T>
T& SharedQueue<T>::front()
{
    std::unique_lock <std::mutex> mlock(mutex_);
    while (queue_.empty())
    {
        cond_.wait(mlock);
    }
    return queue_.front();
}

template <typename T>
void SharedQueue<T>::pop_front()
{
    std::unique_lock<std::mutex> mlock(mutex_);
    while (queue_.empty())
    {
        cond_.wait(mlock);
    }
    queue_.pop_front();
}

template <typename T>
void SharedQueue<T>::push_back(const T& item)
{
    std::unique_lock<std::mutex> mlock(mutex_);
    queue_.push_back(item);
    mlock.unlock();
    cond_.notify_one();
}

template <typename T>
void SharedQueue<T>::push_back(T&& item)
{
    std::unique_lock<std::mutex> mlock(mutex_);
    queue_.push_back(std::move(item));
    mlock.unlock();
    cond_.notify_one();
}

template <typename T>
int SharedQueue<T>::size()
{
    std::unique_lock<std::mutex> mlock(mutex_);
    int size = queue_.size();
    mlock.unlock();
    return size;
}

#包括“SharedQueue.h”
模板
SharedQueue:：SharedQueue（）
{
}
模板
SharedQueue:：~SharedQueue（）
{
}
模板
T&SharedQueue:：front（）
{
std:：unique_lock mlock（互斥锁）；
while（queue_u.empty（））
{
条件等待（mlock）；
}
返回队列前（）；
}
模板
void SharedQueue:：pop_front（）
{
std:：unique_lock mlock（互斥锁）；
while（queue_u.empty（））
{
条件等待（mlock）；
}
队列u.pop_front（）；
}
模板
void SharedQueue:：push_back（常量和项目）
{
std:：unique_lock mlock（互斥锁）；
排队、推回（项目）；
mlock.unlock（）；
条件通知一个（）；
}
模板
void SharedQueue:：推回（T&&item）
{
std:：unique_lock mlock（互斥锁）；
队列向后推（标准：：移动（项目））；
mlock.unlock（）；
条件通知一个（）；
}
模板
int SharedQueue:：size（）
{
std:：unique_lock mlock（互斥锁）；
int size=队列大小（）；
mlock.unlock（）；
返回大小；
}

考虑到（编辑后）显示的错误，似乎确实是相关的。您在哪里定义（实现）了

SharedQueue

构造函数？我猜它在一个单独的源文件中，而不是头文件中。“我在

SharedQueue.cpp

中实现构造函数”-它应该在

SharedQueue.h

中实现。是的。它们不能在

.cpp

中实现，正如您在文章中提到的问题所解释的。这是有效的，因为现在编译器可以看到定义，而不仅仅是声明。但是我们通常使用

.cpp

文件。如果您想将实现放在一个单独的文件中，然后将其包括在内，请执行该操作，但不要对该文件使用

.cpp

扩展名。使用

.h

或类似

.i

或

.inc

的东西

#include

只执行文本替换，这是有意义的。@Evg得到了，这很有意义。非常感谢你