C++ main.obj：错误LNK2019

可能重复：

我一直在

错误LNK2019:未解析的外部符号“public:void\u thiscall DynamicArray:：put（double）”（？put@$DynamicArray@N@@QAEXN@Z)在函数_main中引用

唯一一次出现此错误是在从DynamicArray类调用“put”函数时

卡雷酒店

#ifndef DYNAMICARRAY_H
#define DYNAMICARRAY_H
#include <new>
#include <cstdlib>
using namespace std;

template <class T>
class DynamicArray
{
    private:
        T *origin;
        T *allocator;
        int size;
        int current;


    public:
        DynamicArray();
        DynamicArray(int);
        DynamicArray(const DynamicArray&);
       ~DynamicArray();
        void add(int);
        void erase(int);
        void empty();
        void put(T);
        void remove();
        int getSize();
        T &operator[](const int&);
        const T operator=(const DynamicArray&);
        void put(T&);
};
template <class T>
DynamicArray<T>::DynamicArray()
{
    origin = new T[5];
    allocator = NULL;
    size = 5;
    current = 0;
}

template <class T>
DynamicArray<T>::DynamicArray(int s)
{
    size = s;

    try
    {
        origin = new T[s];
        allocator = NULL;
    }
    catch(bad_alloc)
    {
        cout << "Error: Bad memery allocation\n";
        exit(EXIT_FAILURE);
    }
}

template <class T>
DynamicArray<T>::DynamicArray(const DynamicArray& obj)
{
    empty();
    for(int counter = 0; counter < obj.size - 1; counter++)
    {
         origin[counter] = obj.origin[counter];
    }
}

template <class T>
DynamicArray<T>::~DynamicArray()
{
    delete [] origin;
    delete [] allocator;
    size = NULL;
}

template <class T>
void DynamicArray<T>::add(int size)
{
    allocator = new T[size];
    for(int counter = 0; counter < this-> size - 1; counter++)
    {
        allocator[counter] = origin[counter];
    }
    origin = NULL;
    origin = new T[size];
    this->size = this->size + size;

    for(int counter = 0; counter < size - 1; counter++)
    {
         origin[counter] = allocator[counter];
    }
    allocator = NULL;
}

template <class T>
void DynamicArray<T>::erase(int ammount)
{
    if(ammount - size > size)
        throw "\nnegetive memory location error\n";

    allocator = new T[size - ammount];

    for(int counter = 0; counter < this-> size - ammount - 1; counter++)
    {
        allocator[counter] = origin[counter];
    }

    origin = NULL;
    size = size - ammount;
    origin = new T[size];

    for(int counter = 0; counter < size - 1; counter++)
    {
        origin[counter] = allocator[counter];
    }
    allocator = NULL;
}

template <class T>
void DynamicArray<T>::empty()
{
    if(size >= 0)
        delete [] origin;
}


template <class T>
void DynamicArray<T>::remove()
{
     erase(1);
}


template <class T>
int DynamicArray<T>::getSize()
{
     return size;
}

template <class T>
T &DynamicArray<T>::operator[](const int &index)
{
    return origin[index];
}


template <class T>
const T DynamicArray<T>::operator=(const DynamicArray &obj)
{
    size = obj.size;
    delete [] origin;

    origin = new T[size];

    for(int counter = 0; counter < size; counter++)
        *(origin + counter) = *(obj.origin + counter);

    return *origin;
}

template <class T>
void DynamicArray<T>::put(T &obj)
{
    if(current == size - 1)
    {

        add(1);
        origin[size - 1] = obj;
        ++current; 
    }
    else
    {
        origin[current] = obj;
        ++current;
    }
}

#endif // !DYNAMICARRAY_H

\ifndef dynamiccarray\u H
#定义动态carray_H
#包括
#包括
使用名称空间std；
模板
卡雷级
{
私人：
T*起源；
T*分配器；
整数大小；
电流；
公众：
动态卡雷（）；
动态卡雷（国际）；
动态卡雷（恒动态卡雷&）；
~z~卡雷（）；
无效添加（int）；
无效擦除（int）；
void empty（）；
无效看跌期权（T）；
无效删除（）；
int getSize（）；
T&运算符[]（常量int&）；
常量T运算符=（常量动态数组&）；
无效看跌期权（T&）；
};
模板
DynamicArray:：DynamicArray（）
{
原点=新T[5]；
分配器=NULL；
尺寸=5；
电流=0；
}
模板
DynamicArray:：DynamicArray（int-s）
{
尺寸=s；
尝试
{
原点=新的T[s]；
分配器=NULL；
}
捕获（错误分配）
{
cout size-1；计数器++）
{
分配器[计数器]=源[计数器]；
}
原点=空；
原点=新T[尺寸]；
此->尺寸=此->尺寸+尺寸；
用于（int计数器=0；计数器<大小-1；计数器++）
{
原点[计数器]=分配器[计数器]；
}
分配器=NULL；
}
模板
void DynamicArray:：擦除（int amount）
{
如果（数量-大小>大小）
抛出“\n获取内存位置错误\n”；
分配器=新的T[size-amount]；
对于（int counter=0；countersize-amount-1；counter++）
{
分配器[计数器]=源[计数器]；
}
原点=空；
大小=大小-数量；
原点=新T[尺寸]；
用于（int计数器=0；计数器<大小-1；计数器++）
{
原点[计数器]=分配器[计数器]；
}
分配器=NULL；
}
模板
void DynamicArray:：empty（）
{
如果（大小>=0）
删除[]来源；
}
模板
void DynamicArray:：remove（）
{
擦除（1）；
}
模板
int DynamicArray:：getSize（）
{
返回大小；
}
模板
T&DynamicArray:：运算符[]（常量int和索引）
{
返回原点[索引]；
}
模板
常量T DynamicArray:：运算符=（常量DynamicArray&obj）
{
尺寸=对象尺寸；
删除[]来源；
原点=新T[尺寸]；
用于（int计数器=0；计数器<大小；计数器++）
*（原点+计数器）=*（对象原点+计数器）；
返回*原点；
}
模板
无效动态卡雷：：投入（T&obj）
{
如果（当前==大小-1）
{
增加（1）；
原点[尺寸-1]=obj；
++电流；
}
其他的
{
原点[当前]=obj；
++电流；
}
}
#endif/！DYNAMICARRAY_H

main.cpp

#include <iostream>
#include "DynamicArray.h"

using namespace std;

int main()
{
    DynamicArray<double> a(5);

    a.put(1);

    system("pause");
    return 0;
}

#包括
#包括“DynamicArray.h”
使用名称空间std；
int main（）
{
动态卡雷a（5）；
a、 put（1）；
系统（“暂停”）；
返回0；
}

你的头文件上写着

void-put（T）；

但是从来没有定义过这样的函数。（有一个类似的

void-put（T&）；

但是close不计入链接器。）

应该是

void-put（T&）

在您编写所有原型的.h文件中？可能重复，案例4：下次尝试制作SSCE帖子。例如，简短、自包含。例如，尝试删除所有未调用的函数。