création d'un tableau de pointeurs d'objet C++

Je veux créer un tableau qui contient des pointeurs vers de nombreux objets, mais je ne sais pas à l'avance le nombre d'objets que je vais la garder, ce qui signifie que j'ai besoin d'allouer dynamiquement de la mémoire pour le tableau. J'ai pensé le code suivant:

ants = new *Ant[num_ants];
for (i=1;i<num_ants+1;i++)
{
    ants[i-1] = new Ant();
}

où ants est défini comme Ant **ants; et Ant est une classe.

Ça va fonctionner?

Avez-vous l'essayer?
Norum;je ne peux pas essayer pour le moment, comme je suis le seul à commencer à écrire le code, et j'ai encore beaucoup de pièces manquantes.
Vous souhaiterez peut-être modifier votre boucle pour parcourir de 0 à num_ants, et de céder à des fourmis[i]. Pas besoin de compenser tout en 1.
Il n'y a aucune raison que vous ne pouvait pas essayer avec un mannequin de classe vide. Il suffit de créer une classe Foo qui n'a rien en elle, et l'utilisation de la même logique.
Êtes-vous sûr que le code ci-dessus fonctionne? Quand j'écris la suite dans Visual Studio, j'obtiens une erreur de compilateur: Ant** fourmis = new *Ant[5];

OriginalL'auteur SIMEL | 2011-05-04

  1. 19

    Ça va fonctionner?

    Oui.

    Toutefois, si possible, vous devriez utiliser un vecteur:

    #include <vector>

std::vector<Ant*> ants;
for (int i = 0; i < num_ants; ++i) {
    ants.push_back(new Ant());
}

    Si vous devez utiliser un tableau alloué dynamiquement puis je préfère cette syntaxe:

    typedef Ant* AntPtr;
AntPtr * ants = new AntPtr[num_ants];
for (int i = 0; i < num_ants; ++i) {
    ants[i] = new Ant();
}

    Mais oubliez tout ça. Le code n'est toujours pas bon, car il nécessite manuel de gestion de la mémoire. Pour corriger cela, vous pourriez modifier votre code:

    std::vector<std::unique_ptr<Ant>> ants;
for (auto i = 0; i != num_ants; ++i) {
    ants.push_back(std::make_unique<Ant>());
}

    Et le meilleur de tous serait simplement ceci:

    std::vector<Ant> ants(num_ants);
    Pouvez-vous vraiment affecter le résultat de new à un tableau?
    B: Bonne prise. Il fixe.
    Donc, fondamentalement, new Ant* [num_ants] est un faux appel, car il n'appelle pas le constructeur à tous les droits? N'alloue le tableau de pointeurs. C'est pourquoi la new semble comme si elle est appelée deux fois.
    Pourquoi "devrait" un std::vector être utilisé?

    OriginalL'auteur StackedCrooked

  2. 4
    std::vector<Ant> ants(num_ants);
ants.resize(new_num_ants);
    Si l'OP veut utiliser des pointeurs vers des Fourmis, de la déclaration: std::vector<Ant *> ant_pointers(num_ants);
    Vous devez également avoir à utiliser std::generate à new tous les éléments respectifs.
    Je baisse voté parce que l'OP directement mentionné qu'il voulait utiliser les pointeurs, qui comme @ThomasMatthews mentionné, a besoin d'un autre déclaration. Votre réponse est bonne pour un autre cas bien.
    Je upvoted parce OP apparemment ne sait pas du tableau-des-objets d'être une meilleure option

    OriginalL'auteur Erik

  3. 3

    Avez-vous vraiment besoin de tenir pointeurs pour les articles? Si vous pouvez utiliser des objets par valeur, une approche plus simple est d'utiliser un vecteur: std::vector<Ant> ants(num_ants);. Alors, non seulement vous n'avez pas à écrire en boucle, mais vous n'avez pas à vous soucier des fuites de mémoire à partir des matières premières les pointeurs et autres éléments de gestion.

    Si vous avez besoin de pointeurs d'objet-à-dire de satisfaire une API, vous pouvez toujours utiliser vector pour le récipient externe et allouer les objets manuellement.

    struct CreateAnt
{
    Ant* operator()() const { return new Ant; }
};

std::vector<Ant*> ants(num_ants);  //Create vector with null pointers.
std::generate(ants.begin(), ants.end(), CreateAnt());

    OriginalL'auteur Mark B

  4. 2
    std::vector<Ant*> ants( num_ants );
for ( int i = 0; i != num_ants; ++ i ) {
    ants[i] = new Ant;
}

    Ou si vous ne savez pas combien à l'avance:

    std::vector<Ant*> ants;
while ( moreAntsNeeded() ) {
    ants.push_back( new Ant );
}

    D'autre part, je pense que vous devez vous demander si
    Ant est un type d'entité ou d'une valeur. Si c'est une valeur, vous aurez
    probablement souhaitez passer les pointeurs et l'allocation dynamique;
    si c'est un type d'entité, vous aurez à prendre en compte la durée de vie de
    l'objet, et quand et où il sera supprimé.

    OriginalL'auteur James Kanze

  5. 2

    Oui c'est l'idée générale. Cependant, il existe des alternatives. Êtes-vous sûr que vous avez besoin d'un tableau de pointeurs? Un tableau d'objets de la classe Ant peut être suffisant. La vous n'aurez qu'à allouer le tableau:

    Ant *ants = new Ant[num_ants];

    En général, vous devriez préférer à l'aide de std::vector à l'aide d'un tableau. Un vecteur peut augmenter si nécessaire, et il prendra en charge la gestion de la mémoire pour vous.

    Dans le code que vous avez posté, vous devez supprimer chaque élément de ants dans une boucle, puis supprimer le tableau lui-même, delete [] ant. Gardez à l'esprit la différence entre delete et delete [].

    Un point de plus, puisque les indices de tableau en C++ est basé sur 0, la convention suivante est utilisée pour effectuer une itération sur les éléments:

    for (i=0; i<num_ants; i++)
{
    ants[i] = new Ant();
}

    Cela rend le code beaucoup plus lisible.

    OriginalL'auteur Dima