Discussion :

[mensoif]

Bonjours, un problème se pose à moins, vioci le contexte

j'ai deux struct,

Code :

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

1
2
3
4
5
6
7
8
9
10
 
struct ministruct  {
          int unchamps;
 };
struct STRUCT {
          ministruct data;   
          int fchamp; 
          int schamp;
          int tabchamps[10];
 };

et une class (j'ai mélange corps et déclaration par soucis de place et lisibilité)
avec bien sur les struct initializé correctement

Code :

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

1
2
3
4
5
6
7
class CLASS {
         struct m_Struct;
        public : 
          CLASS () : m_Struct (const STRUCT * monparamstruct)
          {}
          /*......*/
          };

Maintenant mes questions et soucis sont les suivants :

- Est ce que l'initialization de m_Struct est correct ?

- Si je veux accéder au champs fchamps, est ce que je dois tout simplement faire m_Struct.fchamps ou bien, comme c'est un pointeur que je passe en paramètre, utiliser l'opérateur this ce qui donnerait m_Struct->fchamps;

- Et si je veux accéder au champs unchamps dans ministruct, est ce que je peux faire
m_Struct.data.unchamps ?

- Est ce que le const empéche bien toute modification possible du struct "originel" STRUCT ?

- Est ce que l'accés au premier éléments de mon tableau pourrait se faire ainsi, m_Struct.*tabchamps ?

Voila, je sais que cela fait beaucoup de question, mais je n'ai pas finis d'implémenter ma class, et je manque de temps pour tester tout ca à coté (deadline is here :/), je vous remercie d'avance de vos réponses

[Arzar]

Bon, il y a quelques confusions.
il me semble que la lecture d'un code correcte devrais te suffire pour comprendre. (en espérant ne pas me gourer moi-même )

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
 
struct Ministruct
{
   int unchamps;
};
 
struct MyStruct {
   Ministruct data;   
   int fchamp; 
   int schamp;
   int tabchamps[10];
};

Le plus simple c'est de passer par copie. C'est ce que je te conseille fortement si tu es très proche d'une deadline et qu'il faut à tout prix éviter d'introduire de nouveaux bugs. En plus si les stuct ne contiennent réellement qu'une dizaine d'int on ne verra probablement pas de différence.

Code :

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

1
2
3
4
5
6
7
8
 
class MyClass
{
   MyStruct m_Struct; // attention ici. struct m_Struct; ne voulait rien dire dans ton code
public : 
   MyClass(MyStruct aStruct) : m_Struct (aStruct){} // erreur ici dans ton code, le constructeur ne prenait pas de struct en paramètre
  void  DoSomething(){m_Struct.tabchamps[0]++;} // appel avec "." 
};

On peut aussi passer par pointeur. Mais alors la attention ! Il faut impérativement se poser quelques questions lorsqu'on a des pointeurs comme membres de classe. Que se passe il en cas de copie d'un objet MyClass ? Il y a probablement un constructeur par copie et un opérateur d'assignement à écrire. Qui gère la duré de vie du pointeur ? Qui appelle delete ?
Il peut potentiellement y avoir des bugs super vicieux si on ne fait pas attention...

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
 
class MyClass
{
   const MyStruct* m_Struct; 
public : 
   MyClass(const MyStruct* aStruct) : m_Struct (aStruct){} 
   // void DoSomething(){m_Struct->tabchamps[0]++;} Impossible ! m_Struct est constant
 
   /* Il y a probablement le constructeur par copie et l'opérateur d'assignement à écrire maintenant 
   MyClass(const MyClass& aClass);
   const MyClass& operator=(const MyClasse& aClass);
   */
};

La syntaxe est un peu moins lourde par référence je trouve...

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
 
class MyClass
{
   const MyStruct& m_Struct;
public : 
   MyClass(const MyStruct& aStruct) : m_Struct (aStruct){}
   // void DoSomething(){m_Struct.tabchamps[0]++;} // Impossible ! m_Struct est constant 
 
   /* Il y a probablement le constructeur par copie et l'opérateur d'assignement à écrire maintenant 
   MyClass(const MyClass& aClass);
   const MyClass& operator=(const MyClasse& aClass);
   */
};

- Et si je veux accéder au champs unchamps dans ministruct, est ce que je peux faire
m_Struct.data.unchamps ?

Oui.

- Est ce que le const empéche bien toute modification possible du struct "originel" STRUCT ?

Oui.

- Est ce que l'accés au premier éléments de mon tableau pourrait se faire ainsi, m_Struct.*tabchamps ?

Euu, bonne question.
Je ne suis pas sur que le parseur du compilateur réagisse super bien avec l'opérateur . et l'opérateur * collé l'un à l'autre. Vaut mieux s'en tenir à m_Stuct.tabchamps[0].

[mensoif]

tout d'abord merci de t'être pencher sur mon pb,
ensuite, oui j'avous que j'ai fais une bourde pour la représentation de la donné membre dans la class

struct m_Struct;

au réalité, j'avais écris

Code :

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

 struct MyStruct m_Struct;

mais je vais adopter ton écriture qui me semble juste,

Pour ce qui est du constructeur, je vais te faire confiance, et suivre ton exemple, se serra moins compliqué à manipuler par la suite (surtout vus les manips à effectuer :/ )

Ensuite pour ce qui est de l'accés à un élément, la réalité est plus complexe car il s'agit d'un tableau situé dans une struct situé dans une pair situé dans une map et auquel je souhaitais donc accéder comme ceci :

Code :

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

1
2
3
4
 *(bINBT.second)
 *(bINBT.second+1)
//etc...
// avec bINBT une pair <int,int*>

écriture qui, il me semble, n'accepte pas le [ ] .

Donc se serra ma dernière question avant que se poste ne soit totalement résolu, ca n'a pas de réel rapport avec le titre, mais si quelqu'un passe par là, en tous cas merci à toi.

Ah oui j'oubliais, si je ne compte pas utiliser le constructeur par recopie, ni l'affectation (je ne pense pas en avoir besoin ^o) ) je pense que je vais tout simplement en interdire l'utilisation. En éspérant ne pas me tromper *-)

[Arzar]

Hum, ce n'est pas très clair.
Un tableau dans une struct dans une paire dans une map !?
Comme ça ?

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
 
struct MyStruct
{
   int tabchamps[10];
};
std::map<int, std::pair<float, MyStruct> > myMap;
 
std::pair<float, MyStruct> myPair;
myPair.first = 3.14;
 
MyStruct myStruct;
myPair.second = myStruct;
 
myMap[0] = myPair;
myMap[0].second.tabchamps[2] = 3;

Pffiu, c'est complexe...

Bon en tous cas :

Code :

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

1
2
3
4
5
 
std::pair<int, int*> myPair;
myPair.second = new int[5];
bINBT.second[0] = 15; // équivalent à *(bINBT.second) = 15;
bINBT.second[1] = 233; // équivalent à *(bINBT.second+1) = 233;

L'opérateur [] s'applique à ce qu'il trouve à gauche, donc dans ce cas à bINBT.second qui est bien un int*.

[mensoif]

oui ton code réprésente plus ou moins mon idée, (je sais c'est la m***e)

Et pour ce qui concerne l'utilisation de [ ] elle me semblait impossible vus la structure ( au sens large ) et donc je ne l'avais même pas test

Dans tous les cas je te remercie, ce post est désormais résolus !! =)