Hace meses que no uso C::B y hoy lo he vuelto a usar para hacer un programa y practicar C++, lo que ocurre es que al compilar me da error.

-------------- Build: Release in Feather ---------------


[ 25,0%] g++ -Wall  -O2    -I../  /home/kevin1/programacion/code/c++/Feather/tools/SharedPtr.cpp -o obj/Release/tools/SharedPtr.o -c
[ 50,0%] g++ -Wall  -O2    -I../  /home/kevin1/programacion/code/c++/Feather/tools/String.cpp -o obj/Release/tools/String.o -c
[ 75,0%] g++ -Wall  -O2    -I../  /home/kevin1/programacion/code/c++/Feather/tools/Vector.cpp -o obj/Release/tools/Vector.o -c
[100,0%] g++  -o bin/Release/Feather obj/Release/tools/SharedPtr.o obj/Release/tools/String.o obj/Release/tools/Vector.o   -s  
obj/Release/tools/String.o: In function `Tools::String::getNewSharedPtr(unsigned char const*, unsigned int)':
String.cpp.text+0x3f): undefined reference to `Tools::Vector<unsigned char>::Vector(unsigned char const*, unsigned int)'
String.cpp.text+0x5c): undefined reference to `Tools::SharedPtr<Tools::String::Data>::SharedPtr(Tools::String::Data*)'
String.cpp.text+0x70): undefined reference to `Tools::SharedPtr<Tools::String::Data>::addReference()'
collect2: ld returned 1 exit status
Process terminated with status 1 (0 minutes, 0 seconds)
3 errors, 0 warnings

Código fuente de los 6 archivos:

tools/Vector.h:


#ifndef _Feather_tools_Vector_h_
#define _Feather_tools_Vector_h_

#include <algorithm>

namespace Tools {
template <typename _T>
class Vector
{
    public:
        typedef unsigned int Size_t;

        Vector(const Size_t size);
        Vector(const _T value, const Size_t length);
        Vector(const _T *value, const Size_t length);
        Vector(const Vector<_T> &vector);
        Vector(const Vector<_T> &vector, const Size_t length);
        Vector();
        ~Vector();

        inline Size_t getMemorySize() const {return m_size;}

        void allocate(const Size_t size);
        void reAllocate(const Size_t size);
        inline void free();

        inline bool isNull() const {return m_data == NULL || m_size == 0;}

        inline _T &operator[](const Size_t index) {return m_data[index];}
        inline _T operator[](const Size_t index) const {return m_data[index];}
        inline operator bool () const {return isNull();}
        inline operator _T *() {return m_data;}
        inline _T &operator * () {return *m_data;}
    private:
        _T *m_data;
        Size_t m_size;
};
};

#endif // _Feather_tools_Vector_h_

tools/Vector.cpp:

#include "Vector.h"

using namespace Tools;

template <typename _T>
Vector<_T>::Vector(const Size_t size) : m_size(size), m_data(new _T[size])
{
}

template <typename _T>
Vector<_T>::Vector(const _T value, const Size_t length) : m_size(length), m_data(new _T[length])
{
    std::fill(m_data, m_data + length,  value);
}

template <typename _T>
Vector<_T>::Vector(const _T *value, const Size_t length) : m_size(length), m_data(new _T[length])
{
    std::copy(value, value + length, m_data);
}

template <typename _T>
Vector<_T>::Vector(const Vector<_T> &vector) : m_size(vector.m_size), m_data(new _T[m_size])
{
    std::copy(vector.m_data, vector.m_data + vector.m_size, m_data);
}

template <typename _T>
Vector<_T>::Vector(const Vector<_T> &vector, const Size_t length) : m_size(length), m_data(new _T[m_size])
{
    std::copy(vector.m_data, vector.m_data + length, m_data);
}

template <typename _T>
Vector<_T>::Vector() : m_size(0), m_data(NULL)
{
}

template <typename _T>
Vector<_T>::~Vector()
{
    if (!isNull()) {
        delete []m_data;
    }
}

template <typename _T>
void Vector<_T>::allocate(const Size_t size)
{
    m_data = new _T[size];
    m_size = size;
}

template <typename _T>
void Vector<_T>::reAllocate(const Size_t size)
{
    if (!isNull()) {
        _T *tmp = m_data;
        m_data = new _T[size];
        std::copy(tmp, tmp + std::min(size, m_size), m_data);
        m_size = size;
        delete []tmp;
    } else {
        allocate(size);
    }
}

template <typename _T>
inline void Vector<_T>::free()
{
    delete []m_data;
    m_size = 0;
}

tools/SharedPtr.h:

#ifndef _Feather_tools_SharedPtr_h_
#define _Feather_tools_SharedPtr_h_

namespace Tools {
template<typename _T>
class SharedPtr
{
    private:
        ~SharedPtr();

    public:
        SharedPtr(_T *ptr);
        SharedPtr<_T> &addReference();
        void removeReference();

        inline _T *data() {return m_data;}
        inline const _T *data() const {return m_data;}

        inline bool operator ==(SharedPtr<_T> &ptr) const {return m_data == ptr.m_data;}
    private:
        _T *m_data;
        int m_refs;
};
};

#endif //  _Feather_tools_SharedPtr_h_

tools/SharedPtr.cpp:

#include "SharedPtr.h"

using namespace Tools;

template<typename _T>
SharedPtr<_T>::~SharedPtr()
{
    delete m_data;
}

template<typename _T>
SharedPtr<_T>::SharedPtr(_T *ptr) : m_data(ptr), m_refs(0)
{
}

template<typename _T>
SharedPtr<_T> &SharedPtr<_T>::addReference()
{
    m_refs++;
    return (*this);
}

template<typename _T>
void SharedPtr<_T>::removeReference()
{
    m_refs--;
    if (m_refs <= 0) {
        delete this;
    }
}

tools/String.h:

#ifndef _Feather_tools_String_h_
#define _Feather_tools_String_h_

#include <tools/SharedPtr.h>
#include <tools/Vector.h>

namespace Tools {

class String
{
    public:
        typedef unsigned char Char;
        typedef Vector<Char>::Size_t Size_t;

        static const Size_t Maximum = -1;

        String(const Char *str, const Size_t length);
        String(const Char *str);
        String(const String &str);
        String();

        ~String();

        inline bool isNull() const {return m_ptr.data()->vector.isNull();}

        String &append(const Char *str, const Size_t length);
        String &append(const Char *str);
        String &append(const String &str);

        String &erase(const Size_t start, const Size_t end = Maximum);

        String &remove(const Char *str, const Size_t length, const Size_t count = Maximum);
        String &remove(const Char *str, const Size_t count = Maximum);
        String &remove(const String &str, const Size_t count = Maximum);

        String &asUpper() const;
        String &asLower() const;

        String &toUpper();
        String &toLower();

        Char *find(const Char car, const Size_t start = 0, const Size_t end = 0);
        Char *find(const Char *str, const Size_t length, const Size_t start = 0, const Size_t end = 0);
        Char *find(const Char *str, const Size_t start = 0, const Size_t end = 0);
        Char *find(const String &str, const Size_t start = 0, const Size_t end = 0);

        bool exists(const Char car, const Size_t start = 0, const Size_t end = 0) const;
        bool exists(const Char *str, const Size_t length, const Size_t start = 0, const Size_t end = 0) const;
        bool exists(const Char *str, const Size_t start = 0, const Size_t end = 0) const;
        bool exists(const String &str, const Size_t start = 0, const Size_t end = 0) const;

        String &replace(const Char *query, const Size_t qlen, const Char *value, const Size_t vlen);
        String &replace(const String &query, const Char *value, const Size_t vlen);
        String &replace(const Char *query, const Size_t qlen, const String &value);
        String &replace(const String &query, const String &value);

    private:
        struct Data {
            Data(Char *str, const Size_t length) : vector(str, length), length(length)
            {}
            Vector<Char> vector;
            Size_t length;
        };

        static SharedPtr<Data> &getNewSharedPtr(const Char *str, const Size_t length);

        SharedPtr<Data> &m_ptr;

};
};

#endif // _Feather_tools_String_h_

tools/String.cpp:

#include "String.h"

using namespace Tools;

SharedPtr<String::Data> &String::getNewSharedPtr(const Char *str, const Size_t length)
{
    SharedPtr<Data> *ptr = new SharedPtr<Data>(new Data(const_cast<Char *>(str), length));
    return ptr->addReference();
}

// TODO: Implement the rest of the routines
String::String(const Char *str, const Size_t length) : m_ptr(getNewSharedPtr(str, length))
{
}

int main()
{
}

¿Alguien que sepa usar Code::Blocks ve el problema? Cuando compilo con g++ desde la terminal funciona perfectamente, pero desde Code::Blocks me saltan esos errores.