Discussion :

[lupus5]

Bonjour,
Voici mon problème.
j'aimerai pouvoir écrire ceci avec des classes imbriquées dont une d'elle est un tableau de d'objets.
TBox.Text = StationTravail[nStation].SetNum[ParamNum].StartPosition.ToString();

en c# on fait ca:
fichier Cs de classe:

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
 
public class StationDeTravail
{
	// Déclaration du tableau de station_SETOFPARAM
	public station_SETOFPARAM[] SetNum;
	// Déclaration general properties   
	public general_Properties Properties;  
	 //constructeur
	public StationDeTravail(int NbreParam)                 
    	{// Initialisation du tableau
    	SetNum = new station_SETOFPARAM[NbreParam];
	// Pour chaque élément du tableau
   	for (int inc = 0; inc < NbreParam; inc++)
	{ SetNum[inc] = new station_SETOFPARAM(); }// Initialisation de l'élément
            Properties = new general_Properties();
       }
 
 	public class station_SETOFPARAM
       {//class Station_SETOFPARAM 
       public UInt32 StartPosition;  // position de départ
       public UInt16 EndPosition;    // position de fin
       }
 	public class general_Properties
       {//class general_Properties 
       public bool b_ShowHideStation;//Station visible ou pas
       }
}

Utilisation dans main:

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
 public partial class MainHmi : Form
    {
        private List<StationDeTravail> StationTravail; 
 	 private int nStation = 1;
	 private ParamNum = 1;
        public MainHmi()
        {
            InitializeComponent();
        //prg own objects
        StationTravail = new List<StationDeTravail>(); // Instancie la liste
        for (int inc = 0; inc < 5; inc++) // Pour chaque élément du tableau
        {StationTravail.Add(new StationDeTravail(6));}/*Initialisation des stations*/
//par exemple pour l'exemple
//station 1 param 1
TBox.Text = StationTravail[nStation].SetNum[ParamNum].StartPosition.ToString();
TBox2.Text = StationTravail[nStation].SetNum[ParamNum].EndPosition.ToString();
ParamNum = 2;//station 1 param 2
TBox.Text = StationTravail[nStation].SetNum[ParamNum].StartPosition.ToString();
TBox2.Text = StationTravail[nStation].SetNum[ParamNum].EndPosition.ToString();
nStation = 2;//station 2 param 2
TBox.Text = StationTravail[nStation].SetNum[ParamNum].StartPosition.ToString();
TBox2.Text = StationTravail[nStation].SetNum[ParamNum].EndPosition.ToString();
        }

mais en c++ c'est différent...
dans le fichier .h

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
public class StationDeTravail
{
	virtual ~StationDeTravail(void);//destructeur
	// Déclaration du pointeur tableau de station_SETOFPARAM
	public:
        *station_SETOFPARAM[] ;
	// Déclaration general properties   
	general_Properties Properties;  
	 //constructeur
	StationDeTravail(int NbreParam)  {       };
 
 	class station_SETOFPARAM
       {//class Station_SETOFPARAM 
       public 	:
       uint32_t StartPosition;  // position de départ
       uint16_t EndPosition;    // position de fin
       };
 	class general_Properties
       {//class general_Properties 
       public:
       bool b_ShowHideStation;//Station visible ou pas
       };
}

dans le fichier .cpp

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
StationDeTravail::StationDeTravail(int NbreParam)
{
 // Initialisation du tableau
        *station_SETOFPARAM[NbreParam]	SetNum;
	// Pour chaque élément du tableau
   	for (int inc = 0; inc < NbreParam; inc++)
	{ SetNum[inc] = new station_SETOFPARAM(); }// Initialisation de l'élément //allocation dynamique
            Properties = new general_Properties();
}
StationDeTravail::~StationDeTravail(void)
{
}

Je m'en sors pas...

Merci pour votre aide.

[bacelar]

Commencez par lire un bon bouquin sur le C++.
N'utilisez pas de pointeur mais un std::vector, donc pas de new.
On ne donnes pas la visibilité à chaque membre d'une classe mais avec des "sections", "public : ...." et pas "public ..., public ...".
Regardez du coté de la règle des "Big Five" pour les constructeurs, destructeur et opérateurs d'affectation.
C'est quoi ces virtuals à la pelle ???

[lupus5]

voici à quoi j'arrive avec un petit bouquin. C'est vraiment plus simple en c#... mais je respecte le c++ alors je vais y arriver.
fichier .h

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
 
#include "StdAfx.h"
// include guard
#ifndef station_H
#define station_H
 
class station //: public Parent  // Parent object, so #include "parent.h"
{
public:
	station(void);
	station(int);
	int variablegenerale;
 
	class tableau1
	{
		bool variable1 ;
		int variable2 ;
	};
};
#endif //station_H

fichier cpp

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
#include "StdAfx.h"
#include "station.h"
#include <istream>
#include <vector>
#include <stdint.h>
 
station::station(void)
{
}
station::station(int NumParam)
{
	std::vector<station::tableau1> SetParam(NumParam);
//SetParam est un vector de dimension NumParam et de type station::tableau1
}

fichier mainHMI Form1

Code :

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

1
2
3
4
5
6
7
8
9
10
11
 
		Form1(void)
		{
			InitializeComponent();
 
			std::vector<station> Station(2);
			Station[0].SetParam[0].variable1 = 2;
			textBox1.Text = Station[0].SetParam[0].variable1.ToString();
			//TODO: ajoutez ici le code du constructeur
			//
		}

le compil me dit que setparam n'est pas un membre de Station... je relis... mais ne devrait-il pas avoir construit setparam au travers du constructeur de station quand il est appelé?
On est d'accord avec ca?:: std::vector<station::tableau1> SetParam(NumParam); veut dire SetParam est un vector de dimension NumParam et de type station::tableau1:
Je dois encore voir les différence entre list et vector...

merci

[darkman19320]

le compil me dit que setparam n'est pas un membre de Station... je relis... mais ne devrait-il pas avoir construit setparam au travers du constructeur de station quand il est appelé?
On est d'accord avec ca?:: std::vector<station::tableau1> SetParam(NumParam); veut dire SetParam est un vector de dimension NumParam et de type station::tableau1:

Tu te trompes complètement: dans ton constructeur, tu as instancié une variable locale qui s'appelle SetParam (qui est bien un vecteur de station::tableau1). Une fois l'appel au constructeur terminé, cette variable est désallouée et donc ton compilateur râle. Tu dois donc crée une variable de classe. Je te laisse chercher comment faire.

Je dois encore voir les différence entre list et vector...

Avant de t'atteler à ces différences (qui sont assez minime), je te conseille de faire quelques projets plus simple pour appréhender le code c++.

[lupus5]

Tu te trompes complètement: dans ton constructeur, tu as instancié une variable locale qui s'appelle SetParam (qui est bien un vecteur de station::tableau1). Une fois l'appel au constructeur terminé, cette variable est désallouée et donc ton compilateur râle. Tu dois donc crée une variable de classe. Je te laisse chercher comment faire.



Avant de t'atteler à ces différences (qui sont assez minime), je te conseille de faire quelques projets plus simple pour appréhender le code c++.

j'ai créer une variable de classe mais il me manque une base de compréhension je pense...
fichier h

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
#include <iostream>
#include <vector>
// include guard
#ifndef station_H
#define station_H
 
class station //: public Parent  // Parent object, so #include "parent.h"
{
public:
    std::vector<station> N_Station;
 
	station(int NbrStation, int NbrParam)
	{
	    N_Station.reserve(NbrStation);
	    NumParam.reserve(NbrParam);
	};
	~station(){};
 
    class Tab_Param
	{
	    public:
		bool variable1 ;
		int variable2 ;
		private:
	};
	std::vector<Tab_Param> NumParam;
private:
    bool variableprivee;
};
#endif // __station_H_INCLUDED__

fichier main

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
#include <iostream>
#include "station.h"
 
using namespace std;
 
int main()
{
    station Station(3,5);//Station est un objet de type station avec m(3) station et n(5) parametres
    Station.N_Station[0].NumParam[0].variable2 = 2;
 
    cout << Station.N_Station[0].NumParam[0].variable2;
    return 0;
}

Le code me plante, je pense que j'ai réussi à surbourrer la mémoire mais je sais pas comment, je reserve seulement de l'espace....

Merci par avance

[Bousk]

Parce que std::vector::reserve ne fait que réserver la mémoire mais n'alloue pas les éléments.
Comme on l'a dit plusieurs posts plus haut, ça ça s'appelle std::vector::resize.

[darkman19320]

Tu n'as pas un problème de C++ mais plus un problème de modélisation. Tu devrais poser sur le papier ou autre moyen ce que tu cherches réellement à faire. Une fois que tu auras les idées claires, commence à coder.

Je dis ça pour la simple et bonne raison que dans tes deux exemples, tu ne demandes pas la même chose:

Code :

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

1
2
3
4
 // ton premier exemple:
int main(...)
//...
cout << Station.N_Station[0].NumParam[0].variable2;

Code :

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

1
2
3
4
 // ton second exemple:
int main(...)
//...
cout << Station.NumParam[0].variable2;

Dans ton premier exemple, tu demandes de retourner les paramètres de la station 0 alors que dans l'autre, tu demandes de retourner les paramètres de la station courante.

[Bousk]

C'est vraiment plus simple en c#...

Non.
Ton souci c'est que tu espères avoir la même syntaxe alors qu'elles n'ont rien à voir.
[] pour déclarer un tableau dynamique en C#, on appelle ça un vector. Et un vector, comme un tableau, ça a 1 dimension. Sinon c'est un vector de vector, ou tableau de tableau. Mais c'est le plus souvent n'importe quoi à avoir et manipuler.
Lui allouer X élément(s) c'est vector::resize ou vector::push_back.
Par contre portée et visibilité des variables et méthodes sont strictement identiques, à cela près qu'on les déclare par groupe et non pour chacune, donc te tromper là-dessus c'est..

[lupus5]

Non.
Ton souci c'est que tu espères avoir la même syntaxe alors qu'elles n'ont rien à voir.

--- Je suis d'accord que je suis allé un peu vite dans le post, mais ce que l'ont m'a donné jusqu'ici m'a été utile et je remercie les protagonistes de ce post y ayant répondu.

[] pour déclarer un tableau dynamique en C#, on appelle ça un vector. Et un vector, comme un tableau, ça a 1 dimension. Sinon c'est un vector de vector, ou tableau de tableau.

-- Perso là je pige pas trop....
si j'ai dix personnages avec x armes chacun et une seule vie chacun je fait pas un tableau de tableau vide pour la vie et plein pour les armes non? Je ferai un tableau pour les armes et une variable 'non composée' pour la vie. et mes personnages seronts un tableau de personnage contenant un chacun un tableau d'armes et une variables de vie.... mais il n'y aura un tableau de tableau que dans le cas des armes, pas des vies....

Mais c'est le plus souvent n'importe quoi à avoir et manipuler.

-- Pas pour moi, c'est nécessaire pour avoir une structure complète d'un élément réel et fini à l'instant où je code, mais au moment où quelqu'un veut rajouter une option physique(matériel) c'est pratique de pouvoir classer et structurer l'objet comme on veut pour pouvoir ajouter ce qu'on veut oÙ l'on veut... pour moi en tout cas.

Lui allouer X élément(s) c'est vector::resize ou vector::push_back.


Par contre portée et visibilité des variables et méthodes sont strictement identiques, à cela près qu'on les déclare par groupe et non pour chacune, donc te tromper là-dessus c'est..

-- Je sais désolé, j'étais trop concentré sur le c# et j'ai pas relu bien, même pas du tout. Quand on travail sur 5 languages de programmation en même temps c'est pas forcément facile... mais c'est juste que c'est .

Merci

[Bousk]

si j'ai dix personnages avec x armes chacun et une seule vie chacun je fait pas un tableau de tableau vide pour la vie et plein pour les armes non? Je ferai un tableau pour les armes et une variable 'non composée' pour la vie. et mes personnages seronts un tableau de personnage contenant un chacun un tableau d'armes et une variables de vie.... mais il n'y aura un tableau de tableau que dans le cas des armes, pas des vies....

T'as surtout un tableau de Personnage, et ce que contient chaque Personnage n'a strictement rien à voir avec l'éventuel tableau où tu décides de les stocker.

-- Pas pour moi, c'est nécessaire pour avoir une structure complète d'un élément réel et fini à l'instant où je code, mais au moment où quelqu'un veut rajouter une option physique(matériel) c'est pratique de pouvoir classer et structurer l'objet comme on veut pour pouvoir ajouter ce qu'on veut oÙ l'on veut... pour moi en tout cas.

Je comprends rien à ton charabia.
Un tableau multidimensionnel c'est avant tout un truc souvent moins performant et la foire au cache-miss.

[Médinoc]

Petites équivalences entre C# et C++:

• List<> --> vector<>
• LinkedList<> --> list<>
• .Add() --> .push_back()

Sans oublier, bien sûr, qu'en C++ on utilise vector directement par valeur, alors que System.Collections.Generic.List est un type référence.