Creazione di istanze a livello globale (C ++)

Question

Ottengo il seguente errore con il codice seguente.

expected constructor, destructor, or type conversion before '=' token

-

#include <string>
#include <map>

class Foo {

};

std::map<std::string, Foo> map;
map["bar"] = Foo();

int main()
{

    return 0;
}

Answer 1

map["bar"] = Foo(); // This line is a statement not a declaration.
                    // You have to put it in main, or any execution context

---

Fino a quando C ++ 0x diventa mainstream, suggerirei di usare boost . Riempire la map diventa un gioco da ragazzi. Ecco un esempio:

std::map<std::string, Foo> mymap;
...
int main()
{
  insert(mymap)
   ("First",  Foo(...))
   ("Second", Foo(...))
   ("Third",  Foo(...));
   ...
}

Answer 2

La risposta breve, come hai visto, è: non puoi farlo.

Penso che quello che vuoi davvero sia questo:

std::map<std::string, Foo> map;

int main()
{
    map["bar"] = Foo();

Se veramente è necessario eseguire l'inizializzazione prima di main () vedrai spesso esempi come questo:

namespace {
   struct StaticInitHelper {
       StaticInitHelper() { map["bar"] = Foo(); }
   } _helper_obj;
}

Tuttavia, ora hai un nuovo problema, ovvero che non esiste alcuna garanzia che map venga creato prima di _helper_obj . Un modo per aggirare questo è combinarli:

namespace {
   struct StaticInitHelper : public std::map<std::string, Foo> {
       StaticInitHelper() { (*this)["bar"] = Foo(); }
   } map;
}

Tuttavia, l'ereditarietà dalle classi di contenitori STL non è generalmente consigliata. Si noti che questo esempio nasconde altri costruttori e la classe di base STL non ha un distruttore virtuale. Questo sarebbe considerato un "hack". da molti, e dovrebbe davvero essere evitato.

Un'altra alternativa è definire la classe con un std :: map :

namespace {
   struct StaticInitHelper {
       StaticInitHelper() { map["bar"] = Foo(); }
       std::map<std::string, Foo> map;
   } map_holder;
}

map_holder.map.find(...

Ma ovviamente questo complica qualsiasi uso della mappa.

Aggiornamento:

Ho dimenticato di menzionare un'altra opzione, usando boost :: Assegna :

#include <boost/assign/list_of.hpp>

map<int,int> map = boost::assign::map_list_of(1,2)(2,3)(3,4)(4,5)(5,6);

Tuttavia, non riesco a trovare informazioni sulla sicurezza di un oggetto statico.

Answer 3

Sembra che quello che vuoi sia un inizializzatore statico. Ti suggerisco di leggere questo . Illustra l'uso di inizializzatori statici e anche del loro errore principale, l'ordine di inizializzazione statica.