Question

Possible Duplicate:
What is an undefined reference/unresolved external symbol error and how do I fix it?

I keep getting

error LNK2019: unresolved external symbol “public: void __thiscall DynamicArray::put(double)” (?put@?$DynamicArray@N@@QAEXN@Z) referenced in function _main.

The only time I get this error is when I call the “put” function from the DynamicArray class

DynamicArray.h

#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

main.cpp

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

using namespace std;

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

    a.put(1);

    system("pause");
    return 0;
}

Answer 1

Your header file says void put(T); but no such function was ever defined. (There is a similar one void put(T&); but close doesn’t count to the linker.)