Initialisation d'un vecteur avant main() en C++

Question

Je veux pouvoir initialiser un vecteur de taille 'SIZE' avant main. Normalement, je ne

static vector<int> myVector(4,100); 

int main() { 

    // Here I have a vector of size 4 with all the entries equal to 100 

} 

Mais le problème est que je voudrais initialiser le premier élément du vecteur d'être d'une certaine valeur, et l'autre à une autre valeur.

Y at-il un moyen facile de faire cela?

Answer 1

est ici solution de rechange :

#include <vector>     
static std::vector<int> myVector(4,100); 

bool init() 
{ 
    myVector[0] = 42;  
    return true; 
} 

bool initresult = init(); 

int main()     
{ 
    ; 
} 

Answer 2

Essayez ceci:

static int init[] = { 1, 2, 3 }; 
static vector<int> vi(init, init + sizeof init/sizeof init[ 0 ]); 

Aussi, voir std::generate (si vous voulez initialiser dans une fonction).

Answer 3

Un peu hackish, mais vous pouvez le faire:

struct MyInitializer { 
    MyInitializer() { 
     myVector[0]=100; 
     //... 
    } 
} myInitializer; // This object gets constructed before main() 

Answer 4

Vous pouvez utiliser Boost's comma-separated list.

Answer 5

Ou tout simplement créer une fonction et appeler:

std::vector<int> init() 
{ 
    ... 
} 

static std::vector<int> myvec = init() 

Un peu inefficace peut-être, mais cela pourrait ne pas d'importance pour vous, et avec C++ 0x et le déplacer sera très rapide.

Si vous voulez éviter la copie (pour 03 C++ et plus tôt), utiliser un pointeur intelligent:

std::vector<int>* init() { 
    return new std::vector<int>(42); 
} 

static boost::scoped_ptr<std::vector<int>> myvec(init()); 

Answer 6

l'envelopper par une classe:

class SpecialVector 
{ 
    public: 
    SpecialVector() 
    { 
     myVector[0] = 1; 
     myVector[1] = 4; 
     // etc. 
    } 
    const vector<int> & GetVector() const 
    { 
     return myVector; 
    } 
    private: 
    vector<int> myVector; 
}; 
static SpecialVector SpVec; 

int main() { 
} 

Answer 7

C++ 0x permettra listes initialiseur pour conteneurs standard, tout comme les agrégats:

std::vector<int> bottles_of_beer_on_the_wall = {100, 99, 98, 97}; 

De toute évidence pas encore standard, mais il est supposé être pris en charge par GCC 4.4. Je ne peux pas trouver de documentation à ce sujet dans MSVC, mais Herb Sutter a dit que leur support C++ 0x est devant le comité ...

Answer 8

Plutôt que d'utiliser un global, je dirais qu'il est préférable d'utiliser un statique locale. Comme l'initialisation de votre vecteur a lieu avant que le principal ne soit entré, aucune exception ne sera interceptée par main. Disons, par exemple, vous avez un type qui, lorsqu'il est construit peut jeter une exception:

class A { 
public: 
    A() { 
    // ... code that might throw an exception 
    } 
}; 

Pour l'initialisation suivante, le try/catch dans le corps principal ne sera pas attraper l'exception lancée par le constructeur, et ainsi votre Le programme va simplement mourir immédiatement et vous ne pourrez probablement même pas utiliser un débogueur pour trouver la cause!

std::Vector<A> v(5, A()); // May throw an exception here not caught by main 

int main() { 
    try { 
    // Exception for 'v' not handled here. 
    } 
    catch (...) { 
    } 
} 

Une autre approche qui va attraper une exception du constructeur est d'utiliser une statique locale - qui est initialisé en utilisant la technique proposée par ce answer.

std::Vector<A> init(); // Returns a vector appropriately initialized 

std::vector<A> & getV() { 
    static std::vector<A> cache = init(); 
    return cache; 
} 

int main() { 
    try { 
    getV().at[0]; // First call to getV - so initialization occurs here! 
    } 
    catch (...) { 
    } 
}