Discussion :

[Hello_World]

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
A * tab;
tab = new A[100] ;

Merci

[jblecanard]

Hello

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

[Hello_World]

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 ?

[koala01]

Salut,

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

[jblecanard]

C'est vrai ?? !!

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

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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.

[3DArchi]

Avec C++0x, ce sera possible

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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 !

[jblecanard]

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

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

[3DArchi]

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 :