LNK 2019 problem

[pcej]

I'm trying to implement Vector with templates but, I've got a problem with linker. What did I wrong ? Does anybody can see some mistakes?
I enclose all of my important files.

compilation communicate:

1>  vector.cpp
1>  main.cpp
1>  Generating Code...
1>  Compiling...
1>  city.cpp
1>  Generating Code...
1>  Skipping... (no relevant changes detected)
1>  path.cpp
1>  operators.cpp
1>  list.cpp
1>main.obj : error LNK2019: unresolved external symbol "public: __thiscall vector<struct dat>::~vector<struct dat>(void)" (??1?$vector@Udat@@@@QAE@XZ) referenced in function _main
1>main.obj : error LNK2019: unresolved external symbol "public: struct dat & __thiscall vector<struct dat>::operator[](unsigned int)" (??A?$vector@Udat@@@@QAEAAUdat@@I@Z) referenced in function _main
1>main.obj : error LNK2019: unresolved external symbol "public: void __thiscall vector<struct dat>::push_back(struct dat const &)" (?push_back@?$vector@Udat@@@@QAEXABUdat@@@Z) referenced in function _main
1>main.obj : error LNK2019: unresolved external symbol "public: __thiscall vector<struct dat>::vector<struct dat>(int)" (??0?$vector@Udat@@@@QAE@H@Z) referenced in function _main
1>C:\Users\USER\documents\visual studio 2010\Projects\mapa\Debug\mapa.exe : fatal error LNK1120: 4 unresolved externals

main.cpp:

#include <iostream>
#include <stdlib.h>

#include "structs.h"
#include "vector.h"
#include "list.h"
#include "city.h"
#include "operators.h"

int main(){
	position rozmiar;
	char **mapa;
	dat data;
	vector<dat> miasta = vector<dat>( 10 );
	std::cin >> rozmiar.w >> rozmiar.h;
	mapa = new char*[rozmiar.h];
	for( int i = 0; i < rozmiar.h; i++ ){
		mapa[i] = new char[rozmiar.w];
		for( int j = 0; j < rozmiar.w; j++){
			std::cin >> mapa[i][j];
			if( mapa[i][j] == '*' ){
				data.p.h = i;
				data.p.w = j;
				miasta.push_back( data );
			};
		};
	};
	for( int i = 0; i < miasta.size; i++ ){
		miasta[i].c = findName( miasta[i].p, mapa );
	};
	miasta.~vector();
	for( int i = 0; i < rozmiar.h; i++ ){
		delete mapa[i];
	};
	delete mapa;
	return 0;
};

vector.h

#ifndef VECTOR_GUARD
#define VECTOR_GUARD
template <class T>
class vector{
public:
	T* buffer;
	int size;
	int capacity;
	vector(void);
	vector(int size);
	~vector(void);
	void push_back(const T & data);
	void pop_back(void);  
	void reserve(int capacity);   
	void resize(int size);   
	T & operator[](unsigned int index);
	vector<T> & operator= (const vector<T> & v);
};
#endif 

vector.cpp

#include <stdlib.h>
#include "vector.h"

template <class T>
vector<T>::vector(void){
	capacity = 10;
	size = 0;
	buffer = new T[capacity];
}

template <class T>
vector<T>::vector(int size){
	capacity = size;
	size = size;
	buffer = new T[size];
}

template <class T>
vector<T> & vector<T>::operator= (const vector<T> & v){
	delete[ ] buffer;
	size = v.size;
	capacity = v.capacity;
	buffer = new dat[size];
	for (int i = 0; i < size; i++)
		buffer[i] = v.buffer[i];
	return *this;
}

template <class T>
void vector<T>::push_back(const T & data){
	if (size >= capacity)
		reserve(capacity +5);
	buffer [ size++ ] = data;
}

template <class T>
void vector<T>::pop_back(void){
	size--;
}

template <class T>
void vector<T>::reserve( int new_capacity){
    if(buffer == NULL){
		size = 0;
		capacity = 0;
	}    
    T* tmp = new T[capacity];
	for( int i = 0; i < size; i++ ){
		tmp[i] = buffer[i];
	};
	capacity = new_capacity;
	delete[] buffer;
	buffer = tmp;
}

template <class T> 
T & vector<T>::operator[](unsigned int index){
	return buffer[index];
}

template <class T>
vector<T>::~vector(void){
	delete[] buffer;
}

structs.h

#ifndef STRUCTS_GUARD
#define STRUCTS_GUARD
#define NAMESIZE 32

template <class T> class list;
struct cityName{
	char n[NAMESIZE];
	int length;
};
struct position{
	int h;
	int w;
};
struct neighbour{
	cityName c;
	int distance;
	int index;
};
struct opp{
	position* tab;
	int size;
};
struct dat{
	position p;
	cityName c;
	list <neighbour>* l;
};
#endif 

[Bourgond Aries]

I believe templates must have most (if not, all) methods inlined.

[pcej]

I have never used "inline". Where should I add it ?

I've edited vector.cpp, but it's still not working

#include <stdlib.h>
#include "vector.h"

template <class T> inline
vector<T>::vector(void){
	capacity = 10;
	size = 0;
	buffer = new T[capacity];
}

template <class T> inline
vector<T>::vector(int size){
	capacity = size;
	size = size;
	buffer = new T[size];
}

template <class T> inline
vector<T> & vector<T>::operator= (const vector<T> & v){
	delete[ ] buffer;
	size = v.size;
	capacity = v.capacity;
	buffer = new dat[size];
	for (int i = 0; i < size; i++)
		buffer[i] = v.buffer[i];
	return *this;
}

template <class T> inline
void vector<T>::push_back(const T & data){
	if (size >= capacity)
		reserve(capacity +5);
	buffer [ size++ ] = data;
}

template <class T> inline
void vector<T>::pop_back(void){
	size--;
}

template <class T> inline
void vector<T>::reserve( int new_capacity){
    if(buffer == NULL){
		size = 0;
		capacity = 0;
	}    
    T* tmp = new T[capacity];
	for( int i = 0; i < size; i++ ){
		tmp[i] = buffer[i];
	};
	capacity = new_capacity;
	delete[] buffer;
	buffer = tmp;
}

template <class T> inline
T & vector<T>::operator[](unsigned int index){
	return buffer[index];
}

template <class T> inline
vector<T>::~vector(void){
	delete[] buffer;
}

[Bourgond Aries]

Sorry for being so unclear. What I meant was to put the definitions inside the declarations:

// .hpp
template <typename T>
class Something
{
public:
    void func(); // declaration
};

// .cpp
template <typename T>
void Something::func()
{ // definition
    // your code
}

Becomes:

// .hpp
template <typename T>
class Something
{
public:
    void func()
    {
        // Your code.
    } 
};

And you have no .cpp file. The compiler, I believe, needs the definition to deduce the template arguments inside the function.