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++.

[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

[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.

[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.

[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.

[lupus5]

J'ai essayé avant même combat.....:

Et ca ca marche.

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

fichier main

Code :

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

1
2
3
4
5
6
7
8
int main()
{
    station Station(3,5);//Station est un objet de type station avec m station et n parametres
    Station.NumParam[0].variable2 = 52;
 
    cout << Station.NumParam[0].variable2;
    return 0;
}

donc sans utiliser un resize sur la station même (NbrStation enlevé)

[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 normal d'avoir un vector de station dans une station ?
Sinon, montrer les vrais messages d'erreurs et utiliser le debugger sera sûrement plus rapide.

Code :

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

Station.N_Station[0].NumParam[0].variable2 = 2;

Tu accèdes à la station 0 dans ta station (cette seule phrase n'a pas grand sens amha et montre un problème de modélisation au moins), où tu espères accéder au param 0 qui n'existe pas.

[lupus5]

Ce que j'aimerai faire je l'ai dit depuis le début:
TBox.Text = StationTravail[nStation].SetNum[ParamNum].StartPosition.ToString();

on a dix station de travail sur une machine,
chaque station de travail à un set de paramètres complet qui comprend également des variables pour envoyer des signaux 0: carré , 1WM, 2:sinus, 3 triangle, etc... mais pas que.
Chaque station de travail à également des paramètres propres
d'où une classe imbriquée.

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
41
42
43
44
45
 
    public class Station
    {
        public:
              station_SETOFPARAM[] SetNum;                 // Déclaration du tableau de station_SETOFPARAM
              general_Properties Properties;               // Déclaration general properties                     
              general_Parameters Param_Gen;
 
         Station (int NbreParam)                  //constructeur
        {
          en c#::  SetNum = new station_SETOFPARAM[NbreParam];     // Initialisation du tableau
            for (int inc = 0; inc < NbreParam; inc++)       // Pour chaque élément du tableau
            { SetNum[inc] = new station_SETOFPARAM(); }     // Initialisation de l'élément
            Properties = new general_Properties();
            Param_Gen = new general_Parameters(); ::fin c#
        }
 
         class station_SETOFPARAM
        {//class  SETOFPARAM
public: 
             int du_StartPosition;                 // départ [µm]
             int u_EndPosition;                    // fin [µm]
            int u_SigType;                        //Signal choice : 0:square ; 1:sine
            float f_SigSqUHigh;                      // [V]
            float f_SigSqULow;                       // [V]
            int du_SigSqTON;                      // [ms]
            int du_SigSqTOFF;                     // [ms]
            float f_SigSineAmp;
            float f_SigSineOffset;
            float u_SigSineFreq;
        }
        class general_Properties
        {//class general_Properties 
public:
            bool b_ShowHideStation;
        }
        class general_Parameters
        {//class general_Parameters 
public:
            bool b_StartDrilling;                  
            int u_Depth;                          //Profondeur [µm] 
            int u_WarmUpTime;                     // [s]
            int u_StabilisationTime;              // [s]
        }
    }

Si on veut utiliser le set de paramètres 3 (génération triangle) de la station 4 et changer l'amplitude du triangle alors on écrit:
StationTravail[4].SetNum[3].AmpTriangle := 5;
Si on veut ajouter un signal rampe à la station 6 alors on peut, le nouveau signal sera implenté dans la classe paramètre par exemple.
A noter que le set de paramètres n'a pas que les formes de signaux mais aussi des variables classiques.
Voilà.... en c# ca marche bien...

Merci quand même!

Mais bien sûr on pourrait aussi partir autrement:
Dire qu'avec un signal type on crée les variables dépendant de ce type, exemple:
Station[0].SetNum[2].SignalType[0]. --crée un objet de type signal carré avec 3 variables: Frequence, Voltage Haut, Voltage Bas.
Station[0].SetNum[2].SignalType[0].Frequence_Square = 200;
Station[0].SetNum[2].SignalType[0].VoltageHaut_Square= 4;
Station[0].SetNum[2].SignalType[0].VoltageBas_Square= 1;

et si on change le type du signal:
Station[0].SetNum[2].SignalType[1]. --crée un objet de type signal sinus avec 2 variables: Frequence, Amplitude.
Station[0].SetNum[2].SignalType[1].Frequence_Sinus = 200;
Station[0].SetNum[2].SignalType[1].Amplitude_Sinus= 4;

les variables du carré, sinus, etc... devrait être implémentées dans des structures faisant partie de la classe.

On devrait donc avoir une connexion entre le numéro signalType et la structure à prendre en compte.... mais ca devient compliqué non?... mais c'est plus propre à mon avis...
Donc je sais ce que je veux faire mais le problème c'est que j'y vais à petit à petit parce que c'est quand même complexe pour moi.... vu que justement la structure je l'ai mais j'ai des choix difficile pour l'implémenter en POO proprement.... d'où l'aide demandée...

Et merci toujours de vos aides!

[darkman19320]

on a dix station de travail sur une machine

Tu parles de machine ici mais pas dans ton code.

Comme le dit Bousk, avoir des stations qui contiennent des stations est très bizarre.

Je pense que tu voulais plutôt créer une classe Machine qui contient une liste (vector ou tout autre conteneur qui te fait plaisir) de Station.
La classe Station contient une liste de paramètre. Enfin, la classe Parametre (Tab_Param) contient tes deux variables.
L'utilisation de la classe imbriqué n'est pas forcément nécessaire ici vu que tu souhaite accéder à tes paramètres en lecture et écriture.

[foetus]

Donc je sais ce que je veux faire mais le problème c'est que j'y vais à petit à petit parce que c'est quand même complexe pour moi.... vu que justement la structure je l'ai mais j'ai des choix difficile pour l'implémenter en POO proprement.... d'où l'aide demandée...

Bof tu colles une base de données style sqlite et c'est torché ... même si ce n'est pas trop canonique

Avec une table station
id_computer, id_station, number_station_computer, param_01, ..., param_n

Et une table properties
id_station, property_01, ..., property_n


Édit: Avec une base de données c'est assez coton parce que chaque paramètre doit être un id, et chaque type de paramètre avoir sa propre table.

Plus une table d'association id_type_param
id_param, type_param

[Bousk]

Question subsidiaire : pourquoi vouloir le faire en C++ si tu sais le faire qu'en C# ?
Parce que tu te braques en plus pas mal contre le langage alors qu'au fur et à mesure on comprend que c'est plus l'architecture du truc qui est mal pensée ou pas maitrisée, en tous ca dès que tu rajoutes "en C++" dans ta phrase/pensée.

Dans tous les cas, C#, ou C++, ta classe station n'a aucune raison d'avoir un tableau de stations. Ce tableau sera dans le programme principal. Ou éventuellement global quelque part au pire.

Et le coup de la classe imbriquée pour les paramètres, à vraie dire ça n'a absolument aucune incidence qu'elle soit imbriquée ou non.

[lupus5]

Bof tu colles une base de données style sqlite et c'est torché ... même si ce n'est pas trop canonique

Avec une table station
id_computer, id_station, number_station_computer, param_01, ..., param_n

Et une table properties
id_station, property_01, ..., property_n

ouais... le truc c'est que je veux pas implémenter une base de donnée vu que je transmet ensuite toutes ces données à une PLC qui à une mémoire flash et qui peut guarder ces données. De plus ces données doivent être accessible beaucoup plus rapidement que avec un HMI Windows super lent, donc y nous faut les données direct sur la PLC et on travail direct en cycle. Mais ca ca marche bien! ya vraiment que le hmi qui pose problème avec c++ et c'est moi qui veut un truc propre avec ce language.

Merci!!

[dalfab]

Bonjour,

La syntaxe diffère un peu, mail il n'y a aucune complexité à accéder à des éléments de tableaux, et le code est plus simple en C++.
Exemple equivalent de StationDeTravail

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
class StationDeTravail                          // C# public class StationDeTravail
{
public: // en C++ commencer par public: ou declarer une struct si tout est public
   // en C++ la chronologie est importante, déclarer les types avant leur utilisation
   struct station_SETOFPARAM                    // C# public class station_SETOFPARAM
   {  //class Station_SETOFPARAM 
       unsigned StartPosition = 0;              // C# public UInt32 StartPosition;
       unsigned short EndPosition = 0;          // C# public UInt16 EndPosition;
   }; // en C++ attention au ';' pour terminer une définition
 
   struct general_Properties                    // C# public class general_Properties
   {  //class general_Properties 
      bool b_ShowHideStation = false;           // C# public bool b_ShowHideStation;
   }; // en C++ attention au ';' pour terminer une définition
 
   // Déclaration du tableau de station_SETOFPARAM
   std::vector<station_SETOFPARAM> SetNum;      // C# public station_SETOFPARAM[] SetNum;
 
   // Déclaration general properties   
   general_Properties Properties;               // C# public general_Properties Properties;  
 
   //constructeur
   StationDeTravail( int NbreParam )            // C# public StationDeTravail(int NbreParam)                 
   {  // Initialisation du tableau
      SetNum.resize( NbreParam );               // C# SetNum = new station_SETOFPARAM[NbreParam];
      // Pour chaque élément du tableau
      // rien for ( int inc = 0; inc < NbreParam; inc++)
      // rien car init faite au resize()        // C# { SetNum[inc] = new station_SETOFPARAM(); }
      // rien car init faite dès la construction// C# Properties = new general_Properties();
   }
}; // en C++ attention au ';' pour terminer une définition

[lupus5]

Bien, voilà le code... toujours une erreur

||=== Build: Debug in test_Console (compiler: Borland C++ Compiler (5.5, 5.82)) ===|
C:\Borland\BCC55\include\vector.h|204|Error E2285 : Could not find a match for 'ClassStation::ClassStation()' in function vector<ClassStation,allocator<ClassStation> >::vector(unsigned int)|
C:\Borland\BCC55\include\vector.cc|60|Error E2285 : Could not find a match for 'ClassStation::ClassStation()' in function vector<ClassStation,allocator<ClassStation> >::resize(unsigned int)|
||=== Build failed: 2 error(s), 0 warning(s) (0 minute(s), 0 second(s)) ===|

code 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
31
32
33
34
35
36
37
 
#include <iostream>
#include <vector.h>
 
#ifndef ClassStation_H
#define ClassStation_H
 
class ClassStation
{
    public:
        bool Show_Hide;
 
        class ParametersSet
        {
        public:
            int StartPosition ;
            struct TypeSquare
            {
                int Amplitude;
                int Frequency;
            };
            struct TypeSine
            {
                int Amplitude;
                int Frequency;
            };
        TypeSquare SignalSquare;
        TypeSine   SignalSine;
        };
        std::vector<ParametersSet> ParaSet;
        ClassStation(int);
        ~ClassStation();
    protected:
 
    private:
};
#endif // ClassStation_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 <iostream>
#include <vector.h>
#include "ClassStation.h"
 
ClassStation::ClassStation(int NbreParam)
{
    ParaSet.resize(NbreParam);
}
 
ClassStation::~ClassStation()
{
    delete ClassStation;
}

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
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
#include <iostream>
#include <vector.h>
#include <ClassStation.h>
 
using namespace std;
 
int main()
{
    vector<ClassStation> ListOfStation(2);
    ListOfStation.resize(10);
 
    ListOfStation[0].Show_Hide = true;
    ListOfStation[0].ParaSet[0].StartPosition = 24;
    ListOfStation[0].ParaSet[0].SignalSquare.Amplitude = 23;
    ListOfStation[0].ParaSet[1].SignalSine.Amplitude = 66;
    int result1 = ListOfStation[0].ParaSet[0].StartPosition;
    int result2 = ListOfStation[0].ParaSet[0].SignalSquare.Amplitude;
    int result3 = ListOfStation[0].ParaSet[1].SignalSine.Amplitude;
 
    cout << ListOfStation[0].Show_Hide;
    cout << "\n";
    cout << result1;
    cout << "\n";
    cout << result2;
    cout << "\n";
    cout << result3;
    cout << "\n";
    return 0;
}

Je cherche toujours... par contre je me demande si ya pas un problème avec le debug... sur codeblocks, parce que des fois il me met des erreurs pis une deuxième fois que je compile ya plus d'erreur...

Merci par avance!