c++ - C++ のテンプレート化されたコードでコンストラクターが見つかりません

Question

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

以前に多くの複数ソースファイルプログラムを実行したことがあり、コンストラクターが見つからないというこのエラーが発生したことがないため、理解できません。コンパイラがテンプレート コードをテンプレートのインスタンス化に動的にバインドできないようです。また、.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

    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&);
};

main.cpp

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