C++ 在C+中找不到构造函数+；模板代码

我在使用g++main.cpp-Vec.cpp-Wall-o main-I编译它时遇到此错误

/tmp/cciqbEQJ.o: In function `main':
main.cpp:(.text+0x8b): undefined reference to `Vec<double>::Vec()'
main.cpp:(.text+0x9b): undefined reference to `Vec<double>::~Vec()'
collect2: ld returned 1 exit status
make: *** [all] Error 1

/tmp/cciqbEQJ.o:在函数'main'中：
main.cpp:（.text+0x8b）：对“Vec:：Vec（）”的未定义引用
main.cpp:（.text+0x9b）：对“Vec:：~Vec（）”的未定义引用
collect2:ld返回了1个退出状态
make:**[all]错误1

我不明白，因为我以前做过很多源文件程序，在找不到构造函数的地方，我从来没有遇到过这个错误。编译器似乎无法将模板代码动态绑定到模板的实例化。此外，我在.h文件上设置了一个宏保护，但下面没有显示

源代码如下：

Vec.cpp

#include "Vec.h"

using namespace std;

template<class T>
Vec<T>::Vec() {
   create();
}


template<class T>
Vec<T>::Vec( size_type n, const value_type& t ){
        create(n,t);
}
template<class T>
Vec<T>::Vec(const Vec& v)
{
        create(v.begin(), v.end());
}

template<class T>
Vec<T>::~Vec(){
    uncreate();
}

   template<class T>
   void Vec<T>::create()
{
 data = avail = limit = 0;
}

   template<class T>
   void Vec<T>::create(size_type n, const T& val)
{
  data = alloc.allocate(n);
  limit = avail = data + n;
  uninitialized_fill(data,limit, val);
}

template<class T>
void Vec<T>::create(const_iterator i, const_iterator j) {

    data = alloc.allocate(j-i);
    limit = avail = uninitialized_copy(i, j, data);
}
    template<class T> 
    void Vec<T>::uncreate() {

            if (data) {

                    iterator it = avail;
                    while (it != data)
                            alloc.destroy(--it);

                    alloc.deallocate(data,limit-data);
            }
            data = limit = avail =0;
    }

    template<class T> void Vec<T>::grow() {
            size_type new_size = max ( 2 * (limit-data), ptrdiff_t(1));

            iterator new_data = alloc.allocate(new_size);
            iterator new_avail = unitialized_copy(data, avail, new_data);

            uncreate();
            data = new_data;
            avail = new_avail;
            limit = data + new_size;

    }


    template<class T> void Vec<T>::unchecked_append(const T& val) {
            alloc.construct(avail++, val);
    }

    template<class T>
    void Vec<T>::push_back(const T& t){
                    if ( avail == limit )
                            grow();

                    unchecked_append(t);
    }

#包括“Vec.h”
使用名称空间std；
模板
Vec:：Vec（）{
创建（）；
}
模板
Vec:：Vec（大小\类型n、常量值\类型t）{
创建（n，t）；
}
模板
向量：向量（const-Vec&v）
{
创建（v.begin（），v.end（））；
}
模板
Vec:：~Vec（）{
取消创建（）；
}
模板
void Vec:：create（）
{
数据=avail=limit=0；
}
模板
void Vec:：create（大小\类型n，常数T&val）
{
数据=分配分配（n）；
极限=有效=数据+n；
未初始化的填充（数据、限制、val）；
}
模板
void Vec:：create（常量迭代器i，常量迭代器j）{
数据=分配分配（j-i）；
限制=可用=未初始化的拷贝（i，j，数据）；
}
模板
void Vec:：uncreate（）{
如果（数据）{
迭代器it=avail；
while（it！=数据）
alloc.destroy（--it）；
分配解除分配（数据、限额数据）；
}
数据=限值=有效值=0；
}
模板void Vec:：grow（）{
尺寸类型新尺寸=最大值（2*（极限数据），ptrdiff_t（1））；
迭代器new_data=alloc.allocate（新_大小）；
迭代器new_avail=单元化的_拷贝（数据，avail，new_数据）；
取消创建（）；
数据=新数据；
avail=新的_avail；
限制=数据+新尺寸；
}
模板无效向量：：未选中的附加（常量T&val）{
alloc.construct（avail++，val）；
}
模板
无效向量：：推回（常量T&T）{
如果（可用==限制）
增长（）；
未检查的_追加（t）；
}

向量h

    template<class T> class Vec{
    public:
            typedef T* iterator;
            typedef const T* const_iterator;
            typedef size_t size_type;
            typedef T value_type;

            Vec();
            Vec( size_type n, const T& t=T() );

            Vec(const Vec& v);
            Vec& operator=(const Vec& v);

            ~Vec();
            void push_back(const T& t);

            inline size_type size() const { return limit - data; }

            inline iterator begin() {return data;}
            inline const_iterator begin() const { return data; }

            inline iterator end() { return limit; }
            inline const_iterator end() const { return limit; }

            inline T& operator[](size_type i){
                    return data[i];
            }
            const T& operator[](size_type i) const { return data[i]; }


    private:
            iterator data;
            iterator limit;
            iterator avail;

            //facilities for memory allocation
            allocator<T> alloc;

            //allocate and initialize the underlying array
            void create();
            void create(size_type, const T&);
            void create(const_iterator, const_iterator);

            //destroy the elements in the array and free the memory
            void uncreate();

            //support functions for push_back
        void grow();
        void unchecked_append(const T&);
};

模板类Vec{
公众：
typedef T*迭代器；
typedef常量T*常量迭代器；
typedef size_t size_type；
类型定义T值_类型；
Vec（）；
Vec（大小类型n，常数T&T=T（））；
Vec（const-Vec&v）；
向量和运算符=（常量向量和向量）；
~Vec（）；
无效推回（施工T&T）；
内联大小\类型大小（）常量{返回限制-数据；}
内联迭代器begin（）{return data；}
内联常量迭代器begin（）常量{返回数据；}
内联迭代器end（）{return limit；}
内联常量迭代器end（）常量{return limit；}
内联T&运算符[]（i型尺寸）{
返回数据[i]；
}
常量T&运算符[]（size_type i）常量{返回数据[i]；}
私人：
迭代器数据；
迭代器极限；
迭代器效用；
//内存分配设施
分配程序alloc；
//分配并初始化基础数组
void create（）；
创建空心（尺寸类型、常数和）；
void create（常量迭代器，常量迭代器）；
//销毁阵列中的元素并释放内存
void uncreate（）；
//支持推回功能
空洞生长（）；
void unchecked_append（const T&）；
};

main.cpp

 int main(void) {
   Vec<double> test;
 }             

int main（无效）{
Vec试验；
}             

为了让编译器生成代码，它必须同时看到模板定义和用于生成模板的特定类型

因此，在

main.cpp

中添加行，只需在顶部添加“Vec.cpp”

使用编译

---

g++main.cpp-Wall-o main-I.

不能在cpp文件中放置这样的模板不要在

*.cpp

中使用模板。否则，在.cpp中如何定义任何内容？没有模板，编译器抛出“T未定义”