une façon plus agréable de créer des structures dans une boucle

Question

Je n'ai pas codé en C++ depuis longtemps. Et récemment, j'essaie de travailler sur quelque chose impliquant des structures. Puis, en boucle, j'essaie de créer de nouvelles structures et de leur placer des pointeurs dans une liste.

Point* p; 
int i, j; 
while (condition){ 
    // compute values for i and j with some function... 
    p = new Point; 
    p* = {i, j}; //initialize my struct. 
    list.append(p); //append this pointer to my list. 
} 

Maintenant, ma question est-il possible de simplifier cela? Je veux dire, le pointeur variable * p en dehors de la boucle et appelant p = new Point à l'intérieur de la boucle. N'y a-t-il pas une meilleure syntaxe?

Answer 1

Bien sûr:

Point * p = new Point; 

Vous devriez probablement aussi donner votre classe Point un constructeur:

struct Point {  // note no need for typedef 
    int x; 
    int y; 
    Point(int ax, int ay) : x(ax), y(ay) {} 
}; 

afin que vous puissiez dire:

Point * p = new Point(i, j); 

Vous pouvez également faire votre liste une liste de valeurs de point, plutôt que des pointeurs, auquel cas vous pouvez éviter d'utiliser l'allocation dynamique avec ne w - toujours quelque chose à éviter dans la mesure du possible en C++.

Answer 2

Comme struct sont des classes avec des membres du public par défaut, vous pouvez même créer un constructeur dans le struct et initialiser votre objet point dans la boucle comme ceci:

Point* p = new Point(i,j); 

Answer 3

Le struct peut avoir un constructeur comme:

struct Point{ 
    Point(int ax, int ay):x(ax), y(ay){} 
    int x; 
    int y; 
}; 

et la fonction peut ressembler à:

int i, j; 
while (condition) 
{ 
    list.append(new Point(i,j)); 
} 

Answer 4

Je dirais qu'il est extrêmement improbable que vous ayez vraiment besoin d'allouer dynamiquement quelque chose comme un point.

Très probablement, vous voulez ajouter un constructeur et les stocker en valeur:

list<Point> list; 
list.append(Point(x, y)); 

Answer 5

Je recommande l'approche Factory. En supposant que "Point" sera la classe de base de nombreux objets, vous pouvez avoir une "Usine" qui retournerait des pointeurs.

Ex:

struct Point 
{ 
     Point(int mx, int my):x(mx),y(my) {} 
     int x; 
     int y; 
}; 

// Circle, Polygon, etc. 

class Factory 
{ 
public: 
     static Point *getPoint(int mx, int my) { return new Point(mx, my); } 
// Circle, Polygon, etc 
}; 

Puis, dans un endroit de code:

while(cond) 
{ 
list.append(Factory::getPoint(i, j)); 
}