Initialisation de tableau dynamique

Question

Je souhaite créer un tableau dynamique de foo, le nombre d'éléments étant x. Les arguments y et z doivent être passés au constructeur de l'objet foo. J'espérais faire quelque chose de similaire à:

Foo* bar = new Foo(y, z)[x]; 

Cependant qui a produit l'erreur du compilateur suivant:

error: expected `;' before '[' token 

Alors après avoir parlé avec un ami expérimenté, il m'a donné ce qu'il a admis était un paresseux manière de le faire, mais cela fonctionne. Je me demandais, y a-t-il une meilleure/bonne façon?

Foo* bar = (Foo*) new int[x]; 
for (int i = 0; i < x; i++) { 
    bar[i] = Foo(y, z); 
} 

Answer 1

« Je veux faire un tableau dynamique » Donc, utiliser un std::vector, il existe pour une raison.

std::vector<foo> bar(x, foo(y, z)); 

Cela crée un tableau dynamique avec x éléments initialisés à foo(y, z).

---

fait ci-dessus Le copies du second paramètre, x fois. Si vous voulez générer valeurs pour le vector, utilisez generate_n:

std::vector<double> weights; 
std::generate_n(std::back_inserter(weights), x, ...); 

Vous remplacez ... avec une fonction ou foncteur appeler, qui retourne une valeur. En général, vous faites un foncteur:

struct generate_weight 
{ 
    double operator()() const 
    { 
     return random(1e-3); 
    } 
}; 

Donner:

std::generate_n(std::back_inserter(weights), x, generate_weight()); 

Si votre compilateur prend en charge C++ 0x, vous pouvez profiter de lambda de. Ceux-ci font la même chose, sauf qu'ils gardent le code concis et localisé:

std::generate_n(std::back_inserter(weights), x, 
       [](){ return random(1e-3); }); 

Answer 2

Si vous souhaitez initialiser chaque élément à la même valeur, alors faites comme GMan suggéré ci-dessus:

std::vector<foo> bar(x, foo(y, z)); 

Vous allez avoir un vecteur d'éléments X, chacun avec le même foo (y, z);

Si vous voulez une valeur unique pour chacun des foos, vous devrez l'initialiser en boucle. un exemple simple de comment est:

std::vector<foo> bar; 

    for (int i = 0; i < x; ++i) 
    { 
     // initialize X foos with different values for each foo. 
     bar.push_back(foo(i, random(i))); 
    } 

Answer 3

Si vous insistez pour ne pas utiliser std au moins le faire correctement. Ce n'est pas sûr et a de gros problèmes d'alignement.

size_t x = 10; 
foo * bar= static_cast<foo*> (::operator new (sizeof(foo)* x)); 
for (size_t i=0; i<x; ++i) 
{ 
    new (&bar[i]) foo (1,1); 
} 

::operator delete (bar); 

Answer 4

Tout d'abord, le seul initialiseur vous pouvez utiliser dans le tableau new-expressions est (). Donc, ce sont vous seules options si vous voulez utiliser la nouvelle expression

foo *bar = new foo[x]; // 1. no initializer 
foo *bar = new foo[x](); // 2. `()` initializer 

Selon la façon dont foo est défini, ces deux pourraient se comporter de façon identique ou différente.Deuxièmement, puisque vous ne pouvez pas passer les arguments du constructeur (y,z) dans new-expression, vous devez construire votre tableau par défaut (comme indiqué ci-dessus), puis utiliser l'affectation pour donner à vos éléments de tableau des valeurs spécifiques. Pour cela, votre foo doit être configurable par défaut et peut être affecté à la copie. Le code ressemble beaucoup à ce que votre «ami expérimenté» a suggéré, mais avec les types appropriés (au lieu de int). Ce que vous avez maintenant est inutile (d'où vient ce int?). Vous avez probablement mal compris votre ami expérimenté. Voici comment il est censé regarder

foo *bar = new foo[x]; 
for (int i = 0; i < x; i++) 
    bar[i] = foo(y,z); 

En troisième lieu, dans votre cas particulier std::vector fera la même chose d'une manière beaucoup plus élégante.