Comment déclarer un tableau d'objets dont la classe n'a pas de constructeur par défaut?

Si une classe n'a qu'un seul constructeur avec un paramètre, comment déclarer un tableau? Je sais que le vecteur est recommandé dans ce cas. Par exemple, si j'ai une classe

class Foo{

public:
Foo(int i) {}

}

Comment déclarer une matrice ou d'un vecteur qui contient 10000 Foo objets?

source d'informationauteur skydoor

arrays c++

16

Pour un tableau, vous devez fournir un initialiseur pour chaque élément du tableau à l'endroit où vous définissez le tableau.

Pour un vecteur, vous pouvez fournir une instance de copie à chaque membre du vecteur.

par exemple
```
std::vector<Foo> thousand_foos(1000, Foo(42));
```
12

En fait, vous pouvez le faire aussi longtemps que vous utilisez une liste d'initialisation, comme
```
Foo foos[4] = { Foo(0),Foo(1),Foo(2),Foo(3) };
```
cependant, avec 10000 objets ce n'est absolument pas pratique. Je ne suis même pas sûr si vous avez été assez fou pour essayer si le compilateur accepte aussi une liste d'initialisation de cette grande.
6

sbi a la meilleure réponse pour la plaine de tableaux, mais de ne pas donner un exemple. Alors...

Vous devez utiliser le placement de nouvelles:
```
char *place = new char [sizeof(Foo) * 10000];
Foo *fooArray = reinterpret_cast<Foo *>(place);
for (unsigned int i = 0; i < 10000; ++i) {
    new (fooArray + i) Foo(i); //Call non-default constructor
}
```
Garder à l'esprit que lorsque vous utilisez le placement de nouvelles, vous êtes responsable de l'appel des objets destructeurs -- le compilateur ne pas le faire pour vous:
```
//In some cleanup code somewhere ...
for (unsigned int i = 0; i < 10000; ++i) {
    fooArray[i].~Foo();
}

//Don't forget to delete the "place"
delete [] reinterpret_cast<char *>(fooArray);
```
C'est la seule fois que vous verrez jamais une légitime appel explicite au destructeur.

NOTE: La première version de ce eu un bug subtil lors de la suppression de la "place". Il est important de jeter le "lieu" vers le même type qui a été newed. En d'autres termes, fooArray doivent être rejetés sur char * lors de la suppression. Voir les commentaires ci-dessous pour une explication.

Vous auriez besoin de faire un tableau de pointeurs Foo.

Foo* myArray[10000];
for (int i = 0; i < 10000; ++i)
    myArray[i] = new Foo(i);

2

Lorsque vous déclarez un objet qui n'a pas de constructeur par défaut, vous devez l'initialiser dans la déclaration.
```
Foo a; //not allowed
Foo b(0); //OK
```
Il en va de même pour les tableaux de ces types:
```
Foo c[2]; //not allowed
Foo d[2] = { 0, 1 }; //OK
Foo e[] = { Foo(0), Foo(1), Foo(2) }; //also OK
```
Dans votre cas, vous trouverez probablement qu'il est impossible d'initialiser tous les 10 000 éléments comme ça, alors vous pourriez envisager de repenser si la classe ne devriez vraiment pas avoir un constructeur par défaut.
1

La seule manière de définir un tableau d'une classe sans constructeur par défaut serait d'initialiser tout de suite - pas vraiment une option avec 10000 objets.

Vous pouvez, cependant, d'allouer suffisamment de mémoire brute selon la façon dont vous le souhaitez et de les utiliser de placement new pour créer les objets de la mémoire. Mais si vous voulez faire cela, il est préférable d'utiliser std::vector qui fait exactement cela:
```
#include <iostream>
#include <vector>

struct foo {
    foo(int) {}
};

int main()
{
    std::vector<foo> v;
    v.resize(10000,foo(42));
    std::cout << v.size() '\n';
    return 0;
}
```
1

Vous devez utiliser l'agrégation de l'initialiseur, avec 10000 de inidividual initialiseurs entre les {}
```
Foo array[10000] = { 1, 2, 3, ..., 10000 };
```
Bien sûr, en précisant 10000 initialiseurs est quelque chose du domaine de l'impossible, mais vous l'avez demandé vous-même. Vous avez voulu déclarer un tableau de 10000 objets avec pas de constructeur par défaut.

class single
{
    int data;
public:
    single()
    {
        data = 0;
    }
    single(int i)
    {
        data = i;
    }
};

//in main()
single* obj[10000];
for (unsigned int z = 0; z < 10000; z++) 
{
    obj[z] = new single(10);
}

0

Une autre option pourrait être d'utiliser un tableau de boost::optional<Foo>:
```
boost::optional<Foo> foos[10]; //No construction takes place
                               //(similar to vector::reserve)

foos[i] = Foo(3); //Actual construction
```
Seul inconvénient est que vous aurez accès à des éléments avec le pointeur de la syntaxe:
```
bar(*foos[2]); //"bar" is a function taking a "Foo"

std::cout << foos[3]->baz(); //"baz" is a member of "Foo"
```
Vous devez aussi être prudent de ne pas accéder à un élément non.

Un autre inconvénient est que ce n'est pas une véritable alternative à un tableau de Foocar vous ne serez pas en mesure de les transmettre à une fonction qui attend le dernier.
0

Dans droit en C, en utilisant int foo[10000] = {1}; va initialiser le premier élément de tableau de 1 et le reste de la matrice à zéro. Est-ce que C++ pas d'initialisation automatique non spécifié membres du groupe, ou est-ce à besoin d'un constructeur par défaut?
0

Si elle fait sens pour votre classe, vous pouvez fournir une valeur par défaut pour votre paramètre de constructeur:
```
class Foo
{ 
public: 
  explicit Foo(int i = 0); 
}
```
Vous avez maintenant un constructeur par défaut. (Un "constructeur par défaut" est un constructeur qui peut être appelé sans arguments: FAQ)

Je recommande aussi de faire votre constructeur explicite, comme je l'ai fait ci-dessus. Il va vous empêcher d'obtenir Foos de ints lorsque vous ne voulez pas en faire la demande.

De l'essayer.


Foo **ppInstances=0;
    size_t total_instances = 10000;

    for(int parent=0;parent < total_instances;parent++){
        ppInstances[parent]=new Foo( parent ); 
        ppInstances++;
    }
    for(int parent=0;parent < total_instances;parent++){
        delete *ppInstances;
        ppInstances--;
    }

La bonne façon est d'utiliser à std::aligned_storage. Vous aurez à construire manuellement et de détruire les éléments ainsi que les reintrepret_cast lorsque vous souhaitez accéder à un élément. Je vous recommande d'écrire une petite classe wrapper autour de storage_t pour prendre soin de cela. Quelqu'un a mentionné l'aide de boost::optional qui utilise un booléen et un storage_t sous le capot. Cette méthode vous permet d'économiser un bool.

template<typename T>
using storage_t = typename std::aligned_storage<sizeof(T), alignof(T)>::type;

struct Foo;

size_t i = 55;
storage_t<Foo> items[1000]; //array of suitable storage for 1000 T's
new (reintrepret_cast<Foo*>(items + i)) Foo(42); //construct new Foo using placement new
*reintrepret_cast<Foo*>(items + i) = Foo(27);    //assign Foo
reintrepret_cast<Foo*>(items + i)->~Foo()        //call destructor

Vous devez vous connecter pour publier un commentaire.