online - joodle compiler c++

Referencia no definida-Error del enlazador C++

Question

Recibo un mensaje de error de referencia indefinido en esta declaración:

GlobalClass *GlobalClass::s_instance = 0;

¿Algunas ideas? El código se muestra a continuación:

=============================================

#ifndef GLOBALCLASS_H_
#define GLOBALCLASS_H_

#include <string>
class GlobalClass {

public:

    std::string get_value();

    void set_value(std::string);

    static GlobalClass *instance();

    static GlobalClass *s_instance;

private:

    std::string m_value;
};

#endif /* GLOBALCLASS_H_ */

============================================

#include <string>
#include "GlobalClass.h"



/*
 GlobalClass(int v = 0)
 {
 m_value = v;
 }
 */

    static GlobalClass *s_instance;

    std::string GlobalClass::get_value()
    {
        return m_value;
    }

    void GlobalClass::set_value(std::string v)
    {
        m_value = v;
    }

    static GlobalClass *instance() {
        if (!s_instance)
            s_instance = new GlobalClass;
        return s_instance;
    }

=============================================== =========

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

using namespace std;

int main() {

    GlobalClass::s_instance = 0;


    std::string myAddress = "abc";
    GlobalClass::instance()->set_value(myAddress);  // <=== compiler error
    std::cout << "====>address is is " << GlobalClass::instance()->get_value()
            << std::endl;
    return 0;
}

Answer 1

¿Estás tratando de implementar una clase de Singleton? Es decir. Solo desea una instancia única de la clase y desea que esa instancia esté disponible para cualquier persona que incluya la clase. Creo que es comúnmente conocido como Singleton, el siguiente ejemplo funciona como se esperaba:

Singleton.h:

#include <string>
class Singleton
{
public:
    static Singleton* instance()
    {
        if ( p_theInstance == 0 )
            p_theInstance = new Singleton;
        return p_theInstance;
    }
    void setMember( const std::string& some_string )
    {
        some_member = some_string;
    }
    const std::string& get_member() const
    {
        return some_member;
    }

private:
    Singleton() {}
    static Singleton* p_theInstance;
    std::string some_member;
};

Singleton.cpp:

Singleton* Singleton::p_theInstance = 0;

main.cpp:

#include <string>
#include <iostream>
#include "Singleton.h"

int main()
{
    std::string some_string = "Singleton class";
    Singleton::instance()->setMember(some_string);
    std::cout << Singleton::instance()->get_member() << "/n";
}

Tenga en cuenta que el constructor es privado, no queremos que nadie cree instancias de nuestro singleton, a menos que sea a través del operador ''instance ()''.

Answer 2

Cuando declara una s_instance campo s_instance en su archivo .h, solo le dice al compilador que este campo existe en alguna parte. Esto permite que su función main referencia. Sin embargo, no define el campo en ninguna parte, es decir, no hay memoria reservada para él, y no se le asigna ningún valor inicial. Esto es análogo a la diferencia entre un prototipo de función (generalmente en un archivo .h) y la definición de función (en un archivo .cpp).

Para definir realmente el campo, debe agregar la siguiente línea a su archivo .cpp en el alcance global (no dentro de ninguna función):

GlobalClass* GlobalClass::s_instance = 0;

Es importante que no agregue el modificador static a esta definición (aunque aún debe tener el modificador static en la declaración dentro de la clase en el archivo .h). Cuando una definición fuera de una clase se marca static , esa definición solo se puede usar dentro del mismo archivo .cpp. El enlazador actuará como si no existiera si se usa en otros archivos .cpp. Este significado de static es diferente de static dentro de una clase y de static dentro de una función. No estoy seguro de por qué los diseñadores de idiomas usaron la misma palabra clave para tres cosas diferentes, pero así es como es.

Answer 3

Si entiendo lo que quieres hacer solo es cuestión de usar esto:

GlobalClass::s_instance = 0;