¿Por qué recibo externos sin resolver?

Question

Estoy escribiendo un árbol de búsqueda binaria inmutable en C ++. Mis nodos de terminación están representadas por un nodo vacío singleton. Mi compilador (Visual C ++) parece estar teniendo problemas para resolver el miembro estático protegida que tiene mi Singleton. Me sale el siguiente error:

error LNK2001: símbolo externo sin resolver "protegido: impulso clase estática :: shared_ptr> nodo :: m_empty"??? (M_empty @ $ nodo @ HH @@ 1V $ shared_ptr @ V $ nodo @ HH @@@ impulso? @@ A)

Estoy asumiendo que esto significa que no puede resolver el miembro m_empty estática para el nodo de tipo. ¿Es esto correcto? Si es así, ¿cómo lo arreglo?

Código de la siguiente manera:

using namespace boost;
template<typename K, typename V>
class node {
protected:
    class empty_node : public node<K,V> {
    public:
        bool is_empty(){ return true; }
        const shared_ptr<K> key() { throw cant_access_key; }
        const shared_ptr<V> value()  { throw cant_access_value; }
        const shared_ptr<node<K,V>> left()  { throw cant_access_child; }
        const shared_ptr<node<K,V>> right()  { throw cant_access_child; }
        const shared_ptr<node<K,V>> add(const shared_ptr<K> &key, const shared_ptr<V> &value){
            return shared_ptr<node<K,V>>();
        }
        const shared_ptr<node<K,V>> remove(const shared_ptr<K> &key) { throw cant_remove; }
        const shared_ptr<node<K,V>> search(const shared_ptr<K> &key) { return shared_ptr<node<K,V>>(this); }
    };

    static shared_ptr<node<K,V>> m_empty;
public:
    virtual bool is_empty() = 0;
    virtual const shared_ptr<K> key() = 0;
    virtual const shared_ptr<V> value() = 0;
    virtual const shared_ptr<node<K,V>> left() = 0;
    virtual const shared_ptr<node<K,V>> right() = 0;
    virtual const shared_ptr<node<K,V>> add(const shared_ptr<K> &key, const shared_ptr<V> &value) = 0;
    virtual const shared_ptr<node<K,V>> remove(const shared_ptr<K> &key) = 0;
    virtual const shared_ptr<node<K,V>> search(const shared_ptr<K> &key) = 0;


    static shared_ptr<node<K,V>> empty() {
        if(m_empty.get() == NULL){
            m_empty.reset(new empty_node());
        }
        return m_empty;
    }
};

la raíz de mi árbol se inicializa como:

shared_ptr<node<int,int>> root = node<int,int>::empty();

Answer 1

m_empty es estática y por lo que tendrá que tener una fuente (.cpp) presentar con algo parecido a lo siguiente:

template <typename K, typename V> shared_ptr<node<K,V> > node<K,V>::m_empty;

Nota: Mi respuesta original era incorrecta y no tuvo en cuenta que se trataba de una plantilla. Esta es la respuesta que dio AndreyT en su respuesta; He actualizado esta respuesta con la respuesta correcta porque esta es la respuesta aceptada y aparece en la parte superior de la página. Por favor, upvote respuesta de AndreyT, no éste.

Answer 2

Como otros han dicho, es necesario proporcionar un punto de definición para el miembro estático. Sin embargo, puesto que es un miembro de una plantilla, la sintaxis va a ser un poco más complejo que lo que se sugirió antes. Si no me falta nada, debe verse de la siguiente manera

template<typename K, typename V> shared_ptr<node<K,V> > node<K,V>::m_empty;

También puede proporcionar un inicializador (o inicializadores) en esta declaración, si es necesario.

Answer 3

Es necesario para inicializar la variable m_empty en su archivo .cpp.