Tableau d'objets où le constructeur de la classe correspondante posséde des parametres

Version imprimable

26/05/2011, 18h39
Hello_World

Tableau d'objets où le constructeur de la classe correspondante posséde des parametres
Bonjour,

Supposant qu'on a une classe A avec un seul construicteur : A(int a , int b).

Comment peut-on declarer un tableau d'objets de type A ?
Le code suivant ne compile pas !
Code:

1 2 A * tab; tab = new A[100] ;
Merci
26/05/2011, 19h08
jblecanard

Hello

C'est bien simple : on ne peut pas. Par contre, tu peux utiliser un std::vector et le remplir avec une boucle :).
26/05/2011, 19h12
Hello_World

Citation:

Envoyé par jblecanard

Hello

C'est bien simple : on ne peut pas. Par contre, tu peux utiliser un std::vector et le remplir avec une boucle :).

C'est vrai ?? !! Ok, Je connais vector ! mais c'est bizarre de ne pas avoir tel fonctionnalité non ?
27/05/2011, 07h24
koala01

Salut,

Citation:

Envoyé par Hello_World

C'est vrai ?? !! Ok, Je connais vector ! mais c'est bizarre de ne pas avoir tel fonctionnalité non ?

Pas du tout, et pour une raison bien simple:

Réfléchis, tout simplement, au but poursuivi lorsque tu décide de déclarer des arguments pour une fonction... :

Typiquement, les arguments servent à fournir à la fonction des informations qu'elle n'est pas en mesure de récupérer par elle-même et qui risquent, de plus, de varier d'une exécution à l'autre.

Lorsque tu souhaites allouer dynamiquement la mémoire pour plusieurs éléments d'un seul coup, il faudrait être en mesure de créer autant d'éléments que tu le souhaites, en appelant le constructeur et donc... en passant des valeurs correctes pour les différents arguments.

Or, si tu avais été en mesure de déterminer une valeur correcte pour chacun d'eux, tu n'aurais sans doute pas été face à l'obligation de prévoir l'argument correspondant, et donc décidé de créer un constructeur qui s'en passe, ou de donner une valeur par défaut à l'argument correspondant ;)

Pour rappel, une fonction pour laquelle tous les arguments présentent une valeur par défaut revient strictement à une fonction ne prenant pas d'argument, et il en va de même au niveau du constructeur ;)

Citation:

Envoyé par Hello_World

C'est vrai ?? !!

Pas tout à fait... tu peux utiliser la syntaxe suivante :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 class Roger { int marcel; int robert; public: Roger(int iMarcel, int iRobert) : marcel(iMarcel), robert(iRobert) {} }; int main(int argc, char* argv[]) { Roger tableauDeRogers[3] = { Roger(1,2), Roger(3,7), Roger(5,0) }; return 0; }
Mais c'est très vite limité puisqu'il faut initialiser chaque objet à la main. Et puis c'est moche. Et la STL c'est le bien.

Avec C++0x, ce sera possible

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
#include <string>
#include <vector>
#include <iostream>
#include <iterator>
#include <algorithm>
 
struct my_struct
{
   my_struct(){}
   my_struct(std::string s_):i{0},s(s_){}
   my_struct(int i_):i{i_}{}
   my_struct(int i_, std::string s_):i{i_},s(s_){}
 
   int i;
   std::string s;
};
 
std::ostream&operator<<(std::ostream&out_, my_struct const &ms_)
{
 
    return out_<<"i ="<<ms_.i<<" - s = "<<ms_.s<<"\n";
}
 
int main()
{
 
   my_struct *dynamic = new my_struct[4]{
      1, // appel de my_struct(int)
      std::string("tutu"), // appel de my_struct(std::string)
      {1,std::string("1")}, // appel de my_struct(int, std::string)
      {} // appel de my_struct()
   };
   std::copy(
        dynamic
        ,dynamic+4
        ,std::ostream_iterator<my_struct>(std::cout,"\n")
    );
 
   return 0;
}

C++0x, c'est bon, mangez-en ! :D

27/05/2011, 16h18
jblecanard

Citation:

Envoyé par 3DArchi

C++0x, c'est bon, mangez-en ! :D

C'est clair il va falloir un peu de patience le temps que les compilos et les outils (IDEs et autres) le supporte correctement...
27/05/2011, 17h58
3DArchi

Citation:

Envoyé par jblecanard

C'est clair il va falloir un peu de patience le temps que les compilos et les outils (IDEs et autres) le supporte correctement...

Quand tu es sur PC (windows/linux) avec des outils assez 'mainstream' ça peut venir assez vite. Mais quand tu bosses sur des plateformes un peu exotiques avec des outils au rythme de mise à jour plus aléatoire, ben : :cry: