Instanciation au niveau global (C ++)

Question

J'obtiens l'erreur suivante avec le code ci-dessous.

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

Jusqu'à ce que C ++ 0x devienne la norme, je suggérerais d'utiliser boost . Remplir la map devient un jeu d'enfant. Voici un exemple:

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

Answer 2

La réponse courte, comme vous l'avez vu, est: vous ne pouvez pas faire cela.

Je pense que ce que vous voulez vraiment, c'est ceci:

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

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

Si vous avez vraiment besoin de l'initialisation avant main () , vous verrez souvent des exemples comme celui-ci:

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

Cependant, vous avez maintenant un nouveau problème: rien ne garantit que map est créé avant _helper_obj . Une solution consiste à les combiner:

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

Cependant, l'héritage des classes de conteneur STL n'est généralement pas recommandé. Notez que cet exemple masque tous les autres constructeurs et que la classe de base STL n'a pas de destructeur virtuel. Cela serait considéré comme un "hack". par beaucoup, et devrait vraiment être évité.

Une autre alternative consiste à définir la classe avec un std :: map :

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

map_holder.map.find(...

Mais bien sûr, cela complique toute utilisation de la carte.

Mise à jour:

J'ai oublié de mentionner une autre option en utilisant boost :: assign :

#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);

Je ne trouve pas d'informations sur la sécurité d'un objet statique.

Answer 3

Cela ressemble à ce que vous voulez, c'est un initialiseur statique. Je vous suggère de lire ceci . Il illustre l’utilisation des initialiseurs statiques ainsi que leur piège principal, leur ordre d’initialisation statique.