Comment instancier un vecteur statique de l'objet?

J'ai une classe a, qui a été un vecteur statique des objets. Les objets sont de classe B

class A {
  public:
    static void InstantiateVector();
  private:
    static vector<B> vector_of_B;
}

En fonction InstantiateVector()

for (i=0; i < 5; i++) {
  B b = B();
  vector<B>.push_back(b);
}

Mais j'ai des erreur de compilation à l'aide de visual studio 2008: symbole externe non résolu...
Est-il possible d'instancier statique vecteur utilisant la méthode ci-dessus? Pour l'objet b à être créé, certaines données doivent être lues à partir du fichier d'entrée, et stockées en tant que membre des variables de b

Ou il n'est pas possible, et que de simples statique vecteur est possible? J'ai lu quelque part que pour instancier vecteur statique, vous devez d'abord définir un const int a[] = {1,2,3}, puis copiez un[] dans le vecteur

OriginalL'auteur Michael | 2011-09-23

c++instantiation static-members

17

Vous devez fournir la définition de l' vector_of_b comme suit:
```
//A.h
class A {
  public:
    static void InstantiateVector();
  private:
    static vector<B> vector_of_B;
};

//A.cpp
//defining it fixes the unresolved external:
vector<B> A::vector_of_B;
```
Comme une note de côté, votre InstantiateVector() fait beaucoup de copies inutiles qui peuvent (ou ne peuvent pas) être optimisé à l'écart.
```
vector_of_B.reserve(5);  //will prevent the need to reallocate the underlying
                         //buffer if you plan on storing 5 (and only 5) objects
for (i=0; i < 5; i++) {
  vector_of_B.push_back(B());
}
```
En fait, pour cet exemple simple, où vous êtes à la juste valeur par défaut de la construction de B objets, le plus concis façon de le faire est de simplement remplacer la boucle, tous ensemble, avec:
```
//default constructs 5 B objects into the vector
vector_of_B.resize(5);
```
pouvez-vous expliquer plus en détail à propos de votre note de côté? Je suis à dessein de la création d'objets statiques de B, comme je suppose que sa mémoire sera automatiquement libéré à la fin du programme?
Re les copies supplémentaires: qui s'en soucie? Le code ne sera exécuté qu'une fois.
dans ce cas précis, oui. Le code (peuvent) être exécuté qu'une seule fois, mais si son indicatif d'autres parties du code puis sa juste quelque chose à point.
Oui, vous êtes la création d'objets statiques de B et qu'ils seront supprimées à la fin du programme, mais votre fonction comme l'écrit a au moins deux copies de chaque B objet (une pour l'initialisation, et un (ou plus) pour le vecteur d'insertion).
Que diriez-vous simplement vector_of_B.resize(5); pour obtenir 5 par défaut-les éléments construits?

OriginalL'auteur Chad
3

Ajouter le définition du membre statique de l'objet de votre classe à la mise en œuvre de fichier:
```
#include "A.h"

std::vector<B> A::vector_of_B;
```
Ou plutôt, en absorbant et en évitant la routine d'initialisation:
```
std::vector<B> A::vector_of_B(5, B()); //same effect as `A::InstantiateVector()`
```
_{Remarque: En C++98/03, vector_of_B(5) et vector_of_B(5, B()) sont identiques. En C++11, ils ne le sont pas.}

"En C++11, ils ne le sont pas." En C++11, en quoi diffèrent-elles?
En C++11, l'ancienne valeur-initialise les nouveaux éléments, le dernier direct-initialise à une copie de B(). En C++98/03 les deux versions ont la deuxième comportement. C'est un oubli de l'ancienne norme que la valeur d'initialisation n'était pas possible, mais il devrait à l'évidence ont été. En va de même pour resize().

OriginalL'auteur Kerrek SB

Vous pouvez soit utiliser une assistance statique ou utiliser boost::attribuer

1>à l'aide d'un petit helper:

#include <boost\assign.hpp>
class B{};

class A {
 public:
    static bool m_helper;
    static bool InstantiateVector()
    {
        for (int i=0; i < 5; ++i) 
        {
            B b;
            vector_of_B.push_back(b);
        }
        return true;
    }
private:
    static vector<B> vector_of_B;
};

bool A::m_helper = InstantiateVector();//helper help initialize static vector here

2> Utiliser boost::attribuer ce qui est eaiser, une seule ligne suffit:

vector<B> A::vector_of_B = boost::assign::list_of(B())(B())(B())(B())(B());

OriginalL'auteur Gob00st

Vous devez vous connecter pour publier un commentaire.