Discussion :

[ghani56]

Bonjour tout le monde,

j'ai une bizarrerie dans le programme que je suis en train de coder.
Je m'excuse par avance si le sujet a déjà été abordé mais je ne sais pas trop quels mots-clefs utiliser pour résoudre mon problème.
Les tentatives de recherches que j'ai effectué contiennent les mots-clefs suivant :
c++ cout mémoire operator<<

Alors voilà mon problème :
J'ai une classe avec un certain nombre d'attribut.
Dans mon main je fais :

Code :

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

1
2
 
MaClasse bou = new MaClasse();

ensuite pour initialiser les attributs de ma classe, j'appelle la méthode load qui va lire dans un fichier et au fur et à mesure de la lecture va initialiser les paramètres.

Code :

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

1
2
3
4
5
6
7
8
 
load(ifstream& in){
  string line;
  getline(in, line);
  monAttribut1 = line;
  ...
  in.close();
}

Code :

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

1
2
3
4
 
MaClasse bou = new MaClasse();
ifstream file("File/fileSample.txt", ios::in);
bou.load(file);

Ensuite j'appelle la méthode save pour pouvoir sauvegarder les informations sur les attributs de ma classe dans un autre fichier.

Le problème donc est que lorsque je lance mon programme, il crée bien un nouveau fichier à la sauvegarde mais qui ne contient aucune des informations initialisée ; en revanche, et c'est là qu'est toute la bizarrerie, quand je fait un cout de tous les paramètres que j'initialise dans load miracle le fichier crée dans save est complet avec toutes les infos du réseau.

Alors voilà, si mon problème a déjà été rencontré sur ce forum pourriez vous me rediriger vers le bon topic ?
Sinon, est-ce dû à un problème d'allocation mémoire ? Est ce que quand je fais un cout << il se passe quelque chose en particulier qui fait que les valeurs de mes paramètres sont conservées ? Est ce que c'est une histoire de buffer ?

J'avoue que je suis un peu perdue.

S'il y a plusieurs raisons qui pourraient être à l'origine du problème je vous mettrais mon code mais je préviens il est tout moche et il est plutôt conséquent.

Merci beaucoup d'avance !

[3DArchi]

Salut,
Tu nous montre load, mais il me semble comprendre que ton problème viendrait de 'save'. A quoi ça ressemble et comment c'est appelé ?

[koala01]

Salut, et bienvenue sur le forum.

Ce qui m'étonne déjà, c'est que ce code compile, à moins que tu n'ai fais des erreurs de copie lorsque tu as écrit ton message.

En effet,

Code :

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

MaClasse bou = new MaClasse();

De deux choses l'une:

• Ou bien, bou est un objet et il ne faut pas invoquer new,
• Ou bien, bou est un pointeur sur un objet de type MaClass, et il manque l'étoile pour l'indiquer

Code :

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

1
2
3
MaClasse bou = new MaClasse();
ifstream file("File/fileSample.txt", ios::in);
bou.load(file);

Je viens d'indiquer le problème pour la première ligne, et, à la dernière, si bou est un pointeur, il s'agit d'invoquer la fonction load de bou en utilisant la flèche " -> ".

Accesssoirement:

un ifstream est d'office ouvert en lecture. il n'est donc pas nécessaire de préciser ios::in en deuxième paramètre

Il faut se méfier de l'allocation dynamique en C++ (de l'utilisation de new) car elle te donne l'entière responsabilité du moment auquel l'objet est détruit (par le delete correspondant), et des pointeurs en générale car ils ont la fâcheuse manie, si on n'y prend pas garde, de devenir invalide à peu près quand bon leur semble, ce qui mène très rapidement à des emmerdes sans nom

[ghani56]

Oki alors avant quelques petites explication.
J'utilise un builder pour construire mon systeme.
Mon systeme contient pas mal d'objets ...
Je vais essayer d'epurer le code pour aller à l'essentiel,
j'éspère que vous arriverez à me relire.

alors tout d'abord les objets que je veux construire :

Network.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
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
 
#ifndef NETWORK_H_
#define NETWORK_H_
 
#include "NetworkParameters.h" // ne contient que des #define
#include <iostream>
#include <iomanip>
#include <fstream>
#include <string>
#include <vector>
#include <stdio.h>
#include <stdlib.h>
#include <iterator>
#include "../../Tools/Matrix/Matrix.h"
#include "../../Serializer/ISerializer.h"
 
using namespace std;
 
class NetworkMap {
private:
	Matrix* weights_;
public:
	NetworkMap();
	~NetworkMap();
 
    Matrix getWeights() const
    {
        return *weights_;
    }
 
    void setWeights(Matrix weights)
    {
        *weights_ = weights;
    }
 
    void setWeights(int i, int j, double value){
    	(*weights_)(i,j)=value;
    }
 
};
 
class Node {
protected:
	double output_;
public:
	Node();
	Node(double);
	virtual ~Node();
 
       double getOutput();
       void setOutput(double& output_);
};
 
class Neuron: public Node {
private:
	int number_;
public:
	Neuron();
	Neuron(int);
	Neuron(int, double);
	~Neuron();
 
       int getNumber() const;
       void setNumber(int number_);
};
 
class Layer {
friend class NetworkMap;
private:
	vector<Neuron*> node_;
	int number_;
	NetworkMap* weights;
public:
    Layer();
    Layer(int);
    Layer(vector<Neuron*>, int, NetworkMap*);
    ~Layer();
 
    vector<Neuron*>& getNode();
    int getNumber() const;
    void setNode(vector<Neuron*> node_);
    void addNode(Neuron*);
    void setNumber(int number_);
    Matrix getWeights() const;
    void setWeights(Matrix);
    NetworkMap* getNetworkMap();
};
 
class Network: public ISerializer {
protected:
	string name_;
	vector<Layer*> layers_;
public:
	Network();
	Network(string name);
	virtual ~Network();
 
	vector<Layer*>& getLayers();
       string getName() const;
       void setLayers(vector<Layer*>& layers_);
       void addLayers(Layer*);
       void setName(string& name_);
};
 
class CPG: public Network, public CPGSerializer {
private:
	double u0_;
	double beta_;
	vector<double> tcis_;
       vector<double> tcae_;
public:
    CPG();
    CPG(string name);
    ~CPG();
 
    void load(ifstream& in);
    void save(ostream& out);
    double getBeta() const;
    vector<double> getTcae() const;
    vector<double> getTcis() const;
    double get_() const;
    void setBeta(double beta_);
    void setTcae(vector<double> tcae_);
    void setTcis(vector<double> tcis_);
    void set_(double u0_);
};
 
#else
 
class Node;
class Neuron;
class Oscillator;
class Layer;
class Network;
class CPG;
 
#endif /* NETWORK_H_ */

Network.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
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
 
#include "Network.h"
#include "../../Builder.h"
 
Network::Network() {}
 
Network::Network(string name) : name_(name) {}
 
Network::~Network() {
	int n = layers_.size();
	for(int i = 0; i < n ; i++){
		SECUREDFREE(layers_[i]);
	}
}
 
vector<Layer*>& Network::getLayers(){
	return layers_;
}
 
string Network::getName() const {
	return name_;
}
 
void Network::setLayers(vector<Layer*>& layers_) {
	this->layers_ = layers_;
}
 
void Network::addLayers(Layer* l){
	(layers_).push_back(l);
}
 
void Network::setName(string& name_) {
	this->name_ = name_;
}

CPG.cpp (classe où l'on peut trouver les méthodes load et save)
ps : je ne pense pas que ce soit save le pb mais plutôt load, j'ai remarqué que quand je faisait pas les cout, si j'essayais d'afficher des infos sur ma classe en dehors de la méthode, bizarrement le programme ne se souvenait pas des paramètres alors qu'en mettant les cout dans load, il s'en rappelait en dehors de la méthode et m'affichait ce que je voulais.

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
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
 
#include "Network.h"
 
CPG::CPG() {
	layers_ = vector<Layer*> ();
	tcae_ = vector<double> (12, 0.0);
	tcis_ = vector<double> (12, 0.0);
}
 
CPG::CPG(string name) :
	Network(name) {
 
	beta_ = NPbeta;
	u0_ = NPu0;
 
	tcis_ = vector<double> (12, 0.0);
	(tcis_).at(0) = TCIS1;
	(tcis_).at(1) = TCIS2;
	(tcis_).at(2) = TCIS3;
	(tcis_).at(3) = TCIS4;
	(tcis_).at(4) = TCIS5;
	(tcis_).at(5) = TCIS6;
	(tcis_).at(6) = TCIS7;
	(tcis_).at(7) = TCIS8;
	(tcis_).at(8) = TCIS9;
	(tcis_).at(9) = TCIS10;
	(tcis_).at(10) = TCIS11;
	(tcis_).at(11) = TCIS12;
 
	tcae_ = vector<double> (12, 0.0);
	(tcae_).at(0) = TCAE1;
	(tcae_).at(1) = TCAE2;
	(tcae_).at(2) = TCAE3;
	(tcae_).at(3) = TCAE4;
	(tcae_).at(4) = TCAE5;
	(tcae_).at(5) = TCAE6;
	(tcae_).at(6) = TCAE7;
	(tcae_).at(7) = TCAE8;
	(tcae_).at(8) = TCAE9;
	(tcae_).at(9) = TCAE10;
	(tcae_).at(10) = TCAE11;
	(tcae_).at(11) = TCAE12;
 
}
 
CPG::~CPG() {}
 
void CPG::load(ifstream& in) {
	if (in) {
		string line;
		string function;
		cout << "on est dans load" << endl;
		while (!in.eof()) {
			getline(in, line);
			//cout << "ligne : " << line << endl;
			string out = line;
			function = readFunction(out);
			//cout << function << endl;
			if (function.compare("name") == 0) {
				getline(in, line);
				name_ = line;
				cout << name_ << endl;
				getline(in, line);
			} else if (function.compare("LayersNumber") == 0) {
				getline(in, line);
				int nb = (int) atoi(line.c_str());
				//cout << nb << endl;
				for (int i = 0; i < nb; i++) {
					Layer* lay = new Layer(i);
					addLayers(lay);
				}
				getline(in, line);
			} else if (function.compare("NeuronsNumber") == 0) {
				int neuronNb, layerNb;
				getline(in, line);
				//cout << line << endl;
				string::size_type pos;
				string::size_type debut = line.find_first_not_of("\t");
				while (debut != string::npos) {
					pos = line.find_first_of(":", debut);
					layerNb = (int) (atoi(
							(line.substr(debut, pos - debut)).c_str()));
					//cout << layerNb << endl;
					debut = pos + 1;
					pos = line.find_first_of("\t", debut);
					if (pos != string::npos) {
						neuronNb = (int) (atoi(
								(line.substr(debut, pos - debut)).c_str()));
						//cout << neuronNb << endl;
					} else {
						neuronNb = (int) (atoi((line.substr(debut)).c_str()));
						//cout << neuronNb << endl;
					}
					for (int j = 0; j < neuronNb; j++) {
						Neuron* neuron = new Neuron(j);
						layers_[layerNb - 1]->addNode(neuron);
					}
					debut = line.find_first_not_of("\t", pos);
				}
				getline(in, line);
			} else if (function.compare("uO") == 0) {
				getline(in, line);
				u0_ = (int) atoi(line.c_str());
				//cout << u0_ << endl;
				getline(in, line);
			} else if (function.compare("NeuronOutput") == 0) {
				int neuronNb, layerNb;
				getline(in, line);
				//cout << line << endl;
				string::size_type pos;
				// Looking for the begining of the word :
				string::size_type debut = line.find_first_not_of("\t");
				while (debut != string::npos) {
					pos = line.find_first_of("-", debut);
					layerNb = (int) (atoi(
							(line.substr(debut, pos - debut)).c_str()));
					//cout << layerNb << "-";
					debut = pos + 1;
					pos = line.find_first_of(" ", debut);
					neuronNb = (int) (atoi(
							(line.substr(debut, pos - debut)).c_str()));
					//cout << neuronNb << " ";
					debut = pos + 1;
					pos = line.find_first_of("\t", debut);
					if (pos != string::npos) {
						double output = (double) (atof((line.substr(debut, pos
								- debut)).c_str()));
						layers_[layerNb - 1]->getNode()[neuronNb-1]->setOutput(
								output);
						//cout << output << endl;
					} else {
						double output = (double) (atof(
								(line.substr(debut)).c_str()));
						layers_[layerNb - 1]->getNode()[neuronNb-1]->setOutput(
								output);
						//cout << output << endl;
					}
					debut = line.find_first_not_of("\t", pos);
				}
				getline(in, line);
			} else if (function.compare("frequency") == 0) {
				int tc, nb;
				double value;
				//cout << "dans frequency" << " : " << line << endl;
				for (int i = 0; i < 2; i++) {
					getline(in, line);
					//cout << "ligne nb " << i << " : " << line << endl;
					string::size_type pos;
					string::size_type debut = line.find_first_not_of(" ");
					while (debut != string::npos) {
						pos = line.find_first_of("-", debut);
						tc = (int) (atoi(
								(line.substr(debut, pos - debut)).c_str()));
						//cout << tc << "-";
						debut = pos + 1;
						pos = line.find_first_of("=", debut);
						nb = (int) (atoi(
								(line.substr(debut, pos - debut)).c_str()));
						//cout << nb << "=";
						debut = pos + 1;
						pos = line.find_first_of(" ", debut);
						if (pos != string::npos) {
							value = (double) (atof((line.substr(debut, pos
									- debut)).c_str()));
							if (tc == 1) {
								tcis_[nb - 1] = value;
							} else {
								tcae_[nb - 1] = value;
							}
 
							//cout << value << endl;
						} else {
							value
									= (double) (atof(
											(line.substr(debut)).c_str()));
							if (tc == 1) {
								tcis_[nb - 1] = value;
							} else {
								tcae_[nb - 1] = value;
							}
							//cout << value << endl;
						}
						debut = line.find_first_not_of(" ", pos);
					}
				}
				getline(in, line);
				//cout << "frequence finie ! : " << line << endl;
			} else if (function.compare("beta factor") == 0) {
				getline(in, line);
				beta_ = (int) atoi(line.c_str());
				//cout << beta_ << endl;
				getline(in, line);
			} else if (function.compare("weight") == 0) {
				int input, output;
				getline(in, line);
				//cout << line << endl;
				string::size_type pos;
				// Looking for the begining of the word :
				string::size_type debut = line.find_first_not_of("\t");
				while (debut != string::npos) {
					pos = line.find_first_of("-", debut);
					input = (int) (atoi(
							(line.substr(debut, pos - debut)).c_str()));
					//cout << layerNb << "-";
					debut = pos + 1;
					pos = line.find_first_of(" ", debut);
					output = (int) (atoi(
							(line.substr(debut, pos - debut)).c_str()));
					//cout << neuronNb << " ";
					debut = pos + 1;
					pos = line.find_first_of("\t", debut);
					if (pos != string::npos) {
						double value = (double) (atof((line.substr(debut, pos
								- debut)).c_str()));
						layers_[0]->getNetworkMap()->setWeights(input - 1,
								output - 1, value);
						//cout << output << endl;
					} else {
						double value = (double) (atof(
								(line.substr(debut)).c_str()));
						layers_[0]->getNetworkMap()->setWeights(input - 1,
								output - 1, value);
						//cout << output << endl;
					}
					debut = line.find_first_not_of("\t", pos);
				}
				getline(in, line);
			}
		}
		in.close();
	} else {
		cout << "je fais chier tout le monde dans load" << endl;
		throw "can not open file";
	}
}
 
void CPG::save(ostream& out) {
	if (out) {
		cout << "name : " << name_ << endl;
		out << "#name" << endl;
		out << name_ << endl;
		out << endl;
		cout << "layer number : " << layers_.size() << endl;
		out << "#LayersNumber" << endl;
		out << layers_.size() << endl;
		out << endl;
		cout << "Neuron number : " << layers_[0]->getNode().size() << endl;
		out << "#NeuronsNumber" << endl;
		for (int i = 0; (unsigned) i < layers_.size(); i++) {
			out << i + 1 << ":" << layers_[i]->getNode().size() << endl;
		}
		out << endl;
		cout << "u0 : " << u0_ << endl;
		out << "#u0" << endl;
		out << u0_ << endl;
		out << endl;
		cout << "neuron output : ";
		out << "#NeuronOutput" << endl;
		for (int j = 0; (unsigned) j < layers_.size(); j++) {
			for (int k = 0; (unsigned) k < layers_[j]->getNode().size(); k++) {
				out << j + 1 << "-" << k + 1 << " "
						<< layers_[j]->getNode()[k]->getOutput() << "	";
				cout << layers_[j]->getNode()[k]->getOutput() << " ";
			}
			out << endl;
			cout << endl;
		}
		out << endl;
		cout << "frequency" << endl;
		out << "#frequency" << endl;
		for (int l = 0; (unsigned) l < tcis_.size(); l++) {
			out << "f1" << l + 1 << "=" << tcis_[l] << " ";
		}
		out << endl;
		for (int m = 0; (unsigned) m < tcae_.size(); m++) {
			out << "f2" << m + 1 << "=" << tcae_[m] << "	";
		}
		out << endl;
		out << endl;
		cout << "beta : " << beta_ << endl;
		out << "#beta factor" << endl;
		out << beta_ << endl;
		out << endl;
		cout << "weights : " << endl;
		out << "#weight" << endl;
		Matrix m = layers_[0]->getWeights();
		out << "1-2 " << m(0, 1) << "	";
		out << "2-1 " << m(1, 0) << "	";
		out << "3-4 " << m(2, 3) << "	";
		out << "4-3 " << m(3, 2) << "	";
		out << "5-6 " << m(4, 5) << "	";
		out << "6-5 " << m(5, 4) << "	";
		out << "7-8 " << m(6, 7) << "	";
		out << "8-7 " << m(7, 6) << "	";
		out << "9-10 " << m(8, 9) << "	";
		out << "10-9 " << m(9, 8) << "	";
		out << "11-12 " << m(10, 11) << "	";
		out << "12-11 " << m(11, 10) << "	";
		out << "1-3 " << m(0, 2) << "	";
		out << "3-1 " << m(2, 0) << "	";
		out << "2-4 " << m(1, 3) << "	";
		out << "4-2 " << m(3, 1) << "	";
		out << "6-1 " << m(5, 0) << "	";
		out << "6-2 " << m(5, 1) << "	";
		out << "8-3 " << m(7, 2) << "	";
		out << "8-4 " << m(7, 3) << "	";
		out << "10-1 " << m(9, 0) << "	";
		out << "10-2 " << m(9, 1) << "	";
		out << "12-3 " << m(11, 2) << "	";
		out << "12-4 " << m(11, 3) << "	";
		out << endl;
 
	} else {
		cout << "probleme emmerdant" << endl;
		throw "can not open file";
	}
 
}
 
double CPG::getBeta() const {
	return beta_;
}
 
vector<double> CPG::getTcae() const {
	return tcae_;
}
 
vector<double> CPG::getTcis() const {
	return tcis_;
}
 
double CPG::get_() const {
	return u0_;
}
 
void CPG::setBeta(double beta_) {
	this->beta_ = beta_;
}
 
void CPG::setTcae(vector<double> tcae_) {
	this->tcae_ = tcae_;
}
 
void CPG::setTcis(vector<double> tcis_) {
	this->tcis_ = tcis_;
}
 
void CPG::set_(double u0_) {
	this->u0_ = u0_;
}

Layer.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
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
46
47
48
49
50
51
52
53
 
#include "Network.h"
#include "../../Builder.h"
 
Layer::Layer() {}
 
Layer::Layer(int nbl):number_(nbl) {
	node_ = vector<Neuron*>();
	weights = new NetworkMap();
}
 
Layer::Layer(vector<Neuron*> node, int nbl, NetworkMap* map) :
	node_(node), number_(nbl), weights(map) {}
 
Layer::~Layer() {
	delete weights;
	int n = node_.size();
	for(int i = 0; i < n; i++){
		SECUREDFREE(node_[i]);
	}
}
 
vector<Neuron*>& Layer::getNode(){
	return node_;
}
 
int Layer::getNumber() const {
	return number_;
}
 
void Layer::setNode(vector<Neuron*> node_) {
	this->node_ = node_;
}
 
void Layer::addNode(Neuron* node){
	node_.push_back(node);
}
 
void Layer::setNumber(int number_) {
	this->number_ = number_;
}
 
Matrix Layer::getWeights() const {
	return weights->getWeights();
}
 
void Layer::setWeights(Matrix weight) {
	this->weights->setWeights(weight);
}
 
NetworkMap* Layer::getNetworkMap(){
	return weights;
}

Node.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
15
16
 
#include "Network.h"
 
Node::Node(){}
 
Node::Node(double output):output_(output) {}
 
Node::~Node() {}
 
double Node::getOutput(){
	return output_;
}
 
void Node::setOutput(double& output) {
	output_ = output;
}

Neuron.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
15
16
17
18
 
#include "Network.h"
 
Neuron::Neuron() {}
 
Neuron::Neuron(int nbn) : number_(nbn) {}
 
Neuron::Neuron(int nbn, double output) : Node(output), number_(nbn){}
 
Neuron::~Neuron() {}
 
int Neuron::getNumber() const {
	return number_;
}
 
void Neuron::setNumber(int number_) {
	this->number_ = number_;
}

NetworkMap.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
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
46
47
 
#include "Network.h"
#include "../../Builder.h"
 
NetworkMap::NetworkMap() {
	weights_ = new Matrix (12,12,0.0);
 
	(*weights_)(0,1)=-2.0;
	(*weights_)(0,2)=1.0;
 
	(*weights_)(1,0)= -2.0;
	(*weights_)(1,3)=-1.0;
 
	(*weights_)(2,3)=-2.0;
	(*weights_)(2,0)=-1.0;
 
	(*weights_)(3,2)=-2.0;
	(*weights_)(3,1)=-1.0;
 
	(*weights_)(4,5)=-2.0;
 
	(*weights_)(5,4)=-2.0;
	(*weights_)(5,0)=-1.0;
	(*weights_)(5,1)=1.0;
 
	(*weights_)(6,7)=-2.0;
 
	(*weights_)(7,6)=-2.0;
	(*weights_)(7,2)=-1.0;
	(*weights_)(7,3)=-1.0;
 
	(*weights_)(8,9)=-2.0;
 
	(*weights_)(9,8)=-2.0;
	(*weights_)(9,0)=-1.0;
	(*weights_)(9,1)=1.0;
 
	(*weights_)(10,11)=2.0;
 
	(*weights_)(11,10)=-2.0;
	(*weights_)(11,2)=-1.0;
	(*weights_)(11,3)=-1.0;
}
 
NetworkMap::~NetworkMap() {
	SECUREDFREE(weights_);
}

et voilà le texte qui contient les infos à charger :

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
 
#name
stepping CPG
 
#LayersNumber
1
 
#NeuronsNumber
1:12
 
#uO
0
 
#NeuronOutput
1-1 0	1-2 0	1-3 0	1-4 0	1-5 0	1-6 0	1-7 0	1-8 0	1-9 0	1-10 0	1-11 0	1-12 0
 
#frequency
1-1=0.05 1-2=0.05 1-3=0.05 1-4=0.05 1-5=0.025 1-6=0.025 1-7=0.025 1-8=0.025 1-9=0.025 1-10=0.025 1-11=0.025 1-12=0.025
2-1=0.60 2-2=0.60 2-3=0.60 2-4=0.60 2-5=0.30 2-6=0.30 2-7=0.30 2-8=0.30 2-9=0.30 2-10=0.30 2-11=0.30 2-12=0.30
 
#beta factor
2.5
 
#weight
1-2 -2.0	2-1 -2.0	3-4 -2.0	4-3 -2.0	5-6 -2.0	6-5 -2.0	7-8 -2.0	8-7 -2.0	9-10 -2.0	10-9 -2.0	11-12 -2.0	12-11 -2.0	1-3 -1.0	3-1 -1.0	2-4 -1.0	4-2 -1.0	6-1 -1.0	6-2 -1.0	8-3 -1.0	8-4 -1.0	10-1 -1.0	10-2 -1.0	12-3 -1.0	12-4 -1.0

Voilà pour les objets à construire.
Maintenant voilà comment je construit ces objets :

Builder.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
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
 
#ifndef BUILDER_H_
#define BUILDER_H_
 
#define SECUREDFREE( p ) if( ( p ) != NULL) {\
delete( p ); \
( p ) = NULL;\
}
 
#include "Manager.h"
#include "ManagerFactory.h"
 
#include "Serializer/ISerializer.h"
#include "Serializer/SerializerFactory.h"
 
#include "Body/Body.h"
#include "Body/BodyFactory.h"
 
#include "Body/Network/Network.h"
#include "Body/Network/NetworkFactory.h"
#include "Body/Network/LayerFactory.h"
#include "Body/Network/NodeFactory.h"
#include "Body/Network/MapFactory.h"
 
class Builder {
protected:
	Manager* manager;
public:
	Builder();
	virtual ~Builder();
	Manager* getManager() const;
 
	void buildAll(SerializerFactory::SerializerType, BodyFactory::BodyType,
			NetworkFactory::NetworkType);
 
};
 
class SerializerBuilder {
private:
	ISerializer* serial;
public:
	SerializerBuilder(SerializerFactory::SerializerType);
	~SerializerBuilder();
	ISerializer* getSerializer() const;
};
 
class BodyBuilder {
protected:
	IBody* body;
public:
	BodyBuilder(BodyFactory::BodyType);
	~BodyBuilder();
	IBody* getBody();
 
	void buildNetwork(NetworkFactory::NetworkType);
};
 
class NetworkBuilder {
protected:
	Network* net;
public:
	NetworkBuilder(NetworkFactory::NetworkType);
	~NetworkBuilder();
	Network* getNetwork();
 
	void buildLayers(int);
};
 
class LayerBuilder {
protected:
	Layer* l;
public:
	LayerBuilder(int);
	~LayerBuilder();
	Layer* getLayer();
 
	void buildNodes(int);
	void buildMap();
};
 
class NodeBuilder {
protected:
	Node* node;
public:
	NodeBuilder(int);
	~NodeBuilder();
	Node* getNode();
};
 
class MapBuilder {
protected:
	NetworkMap* netmap;
public:
	MapBuilder();
	~MapBuilder();
	NetworkMap* getNetworkMap();
};
#endif /* BUILDER_H_ */

Builder.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
15
16
17
18
19
20
21
22
23
 
Builder::Builder() {
	this->manager = managerFactory::buildManager();
}
 
Builder::~Builder() {
	SECUREDFREE(this->manager);
}
 
Manager* Builder::getManager() const {
	return this->manager;
}
 
void Builder::buildAll(SerializerFactory::SerializerType st, BodyFactory::BodyType bt,
		NetworkFactory::NetworkType nt) {
 
	SerializerBuilder sb(st);
	this->manager->setSerializer(sb.getSerializer());
 
	BodyBuilder bb(bt);
	bb.buildNetwork(nt);
	this->manager->setBody(bb.getBody());
}

Manager.h, ManagerFactory.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
 
#ifndef MANAGER_H_
#define MANAGER_H_
 
#include "Body/Body.h"
#include "Serializer/ISerializer.h"
 
class Manager {
private:
	IBody* body;
	ISerializer* serializer;
public:
	Manager();
	~Manager();
 
	IBody* getBody() const;
	ISerializer* getSerializer() const;
 
	void setBody(IBody* body);
	void setSerializer(ISerializer* serializer);
};
#endif /* MANAGER_H_ */
 
#ifndef MANAGERFACTORY_H_
#define MANAGERFACTORY_H_
 
#include "Manager.h"
 
class managerFactory {
public:
	static Manager* buildManager(){
		return new Manager();
	}
};
 
#endif /* MANAGERFACTORY_H_ */

Manager.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
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
 
#include "Manager.h"
#include "Builder.h"
 
Manager::Manager(){
 
}
 
Manager::~Manager(){
	SECUREDFREE(body);
	SECUREDFREE(serializer);
}
 
 
IBody* Manager::getBody() const {
	return body;
}
 
ISerializer* Manager::getSerializer() const {
	return serializer;
}
 
void Manager::setBody(IBody* body) {
	this->body = body;
}
 
void Manager::setSerializer(ISerializer* serializer) {
	this->serializer = serializer;
}

Body.h, BodyBuilderFactory.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
38
39
40
41
42
43
44
45
46
47
48
49
50
 
#ifndef IBODY_H_
#define IBODY_H_
 
#include "Network/Network.h"
 
class IBody {
protected:
	Network* net;
public:
	virtual Network* getNet()=0;
	virtual void setNet(Network* net)=0;
};
 
class NaoBody: public IBody {
public:
	NaoBody();
	~NaoBody();
 
	Network* getNet();
	void setNet(Network* net);
};
 
#else
class IBody;
class NaoBody;
#endif /* IBODY_H_ */
 
#ifndef BODYFACTORY_H_
#define BODYFACTORY_H_
 
#include "Body.h"
 
class BodyFactory {
public:
	enum BodyType {
		Nao
	};
 
	static IBody* buildBody(BodyType bodyType){
		switch(bodyType) {
		case Nao:
			return new NaoBody();
		default:
			return NULL;
		}
	}
};
 
#endif /* BODYFACTORY_H_ */

BodyBuilder.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
15
16
17
18
19
20
21
22
 
#include "../Builder.h"
 
BodyBuilder::BodyBuilder(BodyFactory::BodyType bt) {
	this->body = BodyFactory::buildBody(bt);
}
 
BodyBuilder::~BodyBuilder() {}
 
IBody* BodyBuilder::getBody() {
	return this->body;
}
 
void BodyBuilder::buildNetwork(NetworkFactory::NetworkType nt) {
	NetworkBuilder nb(nt);
	this->body->setNet(nb.getNetwork());
}
 
void BodyBuilder::buildSystem() {
	SystemBuilder sb;
	this->body->setSys(sb.getSystem());
}

NetworkFactory.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
 
#ifndef NETWORKFACTORY_H_
#define NETWORKFACTORY_H_
 
#include "Network.h"
 
using namespace std;
 
class NetworkFactory {
public:
	enum NetworkType {
		CPGNet, CPGNetF
	};
 
	static Network* buildNetwork(NetworkType networkType) {
		switch (networkType) {
		case CPGNet:
			return new CPG("walkingCPG");
		case CPGNetF: {
			CPG* cpg = new CPG();
			//execlp("pwd","pwd",NULL);
			ifstream file("File/fileSample.txt", ios::in);
			if (file.fail())
				cout << "pb lors de l'ouverture du fichier" << endl;
			cpg->load(file);
			return cpg;
		}
		default:
			return NULL;
		}
	}
};
 
#endif /* NETWORKFACTORY_H_ */

NetworkBuilder.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
 
#include "../../Builder.h"
 
NetworkBuilder::NetworkBuilder(NetworkFactory::NetworkType nt){
	this->net = NetworkFactory::buildNetwork(nt);
}
 
NetworkBuilder::~NetworkBuilder(){}
 
Network* NetworkBuilder::getNetwork(){
	return this->net;
}
 
void NetworkBuilder::buildLayers(int nbl){
	for (int i = 0; i < nbl; i++){
		LayerBuilder lb(nbl);
		lb.buildNodes(12);
		lb.buildMap();
		this->net->addLayers(lb.getLayer());
	}
}

ISerializer.h et SerializerFactory.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
38
39
40
41
42
43
44
45
46
47
48
 
#ifndef ISERIALIZE_H_
#define ISERIALIZE_H_
 
#include <iostream>
#include <string>
 
using namespace std;
 
class ISerializer {
public:
	virtual void load(ifstream& in) = 0;
	virtual void save(ostream& out) = 0;
};
 
class CPGSerializer : public ISerializer {
public:
	CPGSerializer();
	~CPGSerializer();
	void load(ifstream& in);
	void save(ostream& out);
	string readFunction(string s);
};
 
#endif /* ISERIALIZER_H_ */
 
#ifndef SERIALIZERFACTORY_H_
#define SERIALIZERFACTORY_H_
 
#include "ISerializer.h"
 
class SerializerFactory {
public:
	enum SerializerType {
		cpgSerializer
	};
 
	static ISerializer* buildSerializer(SerializerType serialType){
		switch (serialType) {
			case cpgSerializer:
				return new CPGSerializer();
			default:
				return NULL;
		}
	}
};
 
#endif /* SERIALIZERFACTORY_H_ */

CPGSerializer.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
15
16
17
 
#include "ISerializer.h"
 
CPGSerializer::CPGSerializer() {}
 
CPGSerializer::~CPGSerializer() {}
 
void CPGSerializer::load(ifstream& in) {}
 
void CPGSerializer::save(ostream& out) {}
 
string CPGSerializer::readFunction(string s) {
	string function;
	string::size_type debut = s.find_first_not_of("#");
	function = s.substr(debut);
	return function;
}

SerializerBuilder.cpp

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
 
#include "../Builder.h"
 
SerializerBuilder::SerializerBuilder(SerializerFactory::SerializerType st) {
	this->serial = SerializerFactory::buildSerializer(st);
}
 
SerializerBuilder::~SerializerBuilder() {}
 
ISerializer* SerializerBuilder::getSerializer() const {
	return this->serial;
}

et enfin voilà le 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
 
#include "Builder.h"
#include "Tools/RungeKutta/RungeKutta.h"
 
int main(int argc, char **argv) {
 
	Builder bb;
	bb.buildAll(SerializerFactory::cpgSerializer, 
			BodyFactory::Nao, NetworkFactory::CPGNetF);
 
	ofstream out("File/test.txt", ios::out | ios::trunc);
	if(out.fail()) cout << "probleme lors de l'ouverture du fichier" << endl;
	((CPG*)bb.getManager()->getBody()->getNet())->save(out);
	out.close();
}

C'est pas du beau code, c'est pas optimisé, et les patterns ne sont pas forcément utilisé correctement, mais je ne pense pas que le problème soit là (en tout cas j'espère).

Merci beaucoup pour votre aide !

edit :
koala je viens de voir ton post, effectivement c'est une grosse erreur de frappe
et c'était juste un exemple pour illustrer mon problème.
Il y a surement trop de pointeurs mais ceux que j'ai utilisé me paraissaient judicieux.
Si c'est un problème de pointeur je suis pas dans la merde et je sens que je vais encore passer des heures à trouver d'où ça vient :S
Bon je garde courage et je vérifie mon code ligne par ligne.
Encore merci pour votre aide !

edit2:
Suite à la relecture de mon code, j'ai enlevé quelques const aux fonctions get et leur ait fait renvoyé des refs, de même pour mes set où j'ai fait le changement en passant mes objets en references.
J'ai testé un bout et "miracle" ça à l'aire de marcher, je continu mes tests pour vérifier.

mais si c'est ça c'est effectivement de grosses erreurs de débutant !

L'idée c'est que j'essaie de travailler avec des objets qui n'existent plus alors ça le fait moyen, et c'est pour ça que ça pète un peu n'importe où et que les cout ne font retarder le moment où ça pète.

Vous pourriez confirmer ou infirmer ?

En tout cas merci pour votre aide et le temps que vous avez consacré à mon problème.
Merci koala, sans ton rappel sur le fait qu'avec les pointeurs ça pouvait péter à tout moment, je n'aurai pas pensé tout de suite à faire des passages par référence systématique.

[GefiehlteFish]

Salut ghani56,

Je vais juste préciser un truc concernant ta méthode load: le constructeur de ifstream réussit même s'il n'a pas pu ouvrir le fichier. Ton test "if (in)" au début de load ne sert pas à vérifier que le fichier s'est bien ouvert.
Pour ça, il faut utiliser la méthode fail de ifstream.

C'était juste pour préciser.

[ghani56]

Arf c'est pas faux.
Le in.fail() et le out.fail() que j'ai utilisé avant d'appeler les méthodes load et save ne servent strictement à rien si je rentre quand même dans load et save malgré que le constructeur n'ait pas réussi à ouvrir les fichiers XD !
je suis un
Merci pour la remarque, c'est corrigé chez moi ^^"""

[koala01]

Et voici d'autres piqures de rappel:

JAMAIS de directive using namespace dans un fichier d'en-tête: elles ont la sale manie d'envahir tout le code au gré des inclusions en cascade, et cela casse tout le système mis en place par l'utilisation des espaces de noms

<stdio.h> et <stdlib.h> sont des fichiers d'en-tête issus du C.

Si tu as besoin de quelque chose qui est déclaré dedans(et je n'ai pas vu en lisant en diagonale le code de raisons qui feraient que tu en aies besoin), il est préférable d'utiliser la version "C++" de ces fichiers: <cstdio> et <cstdlib>...

Cependant, ces fichiers d'en-tête sont typiquement du genre de ceux que l'on préfère ajouter dans le fichier d'implémentation (*.cpp) .

C'est d'ailleurs aussi le cas pour <iomanip>,<iostream> et <fstream>, au sujet desquels ne n'ai rien vu qui justifie qu'ils soient inclus dans le fichier d'en-tête (dans network.h, tu n'utilise strictement rien qui soit déclaré dans ces fichiers )

Retiens toujours que les fichiers inclus dans un fichier d'en-tête doivent fournir le stricte minimum pour qu'il passe la vérification syntaxique...

les déclarations anticipées sont bien souvent tes amies
Fais attention à la sémantique de l'héritage public, et entre autres à respecter le LSP (Liskov Substitution Principle)...

Peut être est-il respecté lorsque CPG hérite publiquement de Network et de CPGSerializer, mais il me semble opportun de remettre cette réflection à l'honneur (surtout concernant CPGSerializer...

CPG ne serait il pas beaucoup mieux en étant "implémenté sous la forme d'un" CPGSerializer qu'en étant un CPGSerializer

Fais attention également à déclarer au minium le destructeur virtuel si tes classes dérivées sont à manipuler de manière polymorphe...

Je sais que la norme admet que le mot clé virtual soit omis pour les classes dérivées, mais il me semble toujours opportun de rappeler au lecteur du code que c'est effectivement le cas

Peut être serait-il intéressant de "scinder" les fichier network.* en autant de paires de fichier d'en-tête / implémentation qu'il n'y a de classe...

un principe qu'il est bon de mettre en oeuvre est:

1. de passer par référence tout ce qui peut l'être
2. de ne pas renvoyer de référence non constante vers le membre d'une classe

afin d'éviter les risque de copies inutiles, tout en évitant que quelqu'un n'aille modifier le membre de la classe à l'insu de l'objet... Peut être devrais tu, effectivement, décider de renvoyer une référence constante avec tes getters, et veiller à passer les arguments de tes setters sous la forme de référence constante

Interroge toi peut être sur l'utilité de déclarer tes membres privés, si c'est pour fournir un acces complet (du fait des getters et setters) à ces membres...

Peut être pourrais tu trouver des comportements plus opportuns que simplement get et set car, telles qu'elles se présentent actuellement, tes classes ne cachent absolument pas les détails d'implémentation, et, du coup, tu te faciliterait presque la tache à créer des structures, dont tous les membres serait publiques, et à créer des fonctions libres ...

La programmation orientée objet consiste à réfléchir aux services qu'une classe peut rendre, de manière à cacher un maximum les données qu'elle utilise pour ce faire

Pourquoi manipuler un pointeur de Matrix dans NetworkMap, alors que tu pourrais très bien manipuler une Matrix, tout simplement

Ce ne sont là que quelques réflexions dans leur versions courtes, n'hésite pas à demander des précisions en cas de besoin

[ghani56]

JAMAIS de directive using namespace dans un fichier d'en-tête: elles ont la sale manie d'envahir tout le code au gré des inclusions en cascade, et cela casse tout le système mis en place par l'utilisation des espaces de noms

C'est noté, c'est un passage que j'ai du rater dans les tutos mes excuses

<stdio.h> et <stdlib.h> sont des fichiers d'en-tête issus du C.

Si tu as besoin de quelque chose qui est déclaré dedans(et je n'ai pas vu en lisant en diagonale le code de raisons qui feraient que tu en aies besoin), il est préférable d'utiliser la version "C++" de ces fichiers: <cstdio> et <cstdlib>...

vivi ça je m'en rappel (librairie C), et je me rappelle maintenant pourquoi je les ai utilisées.
"<cstdio> et <cstdlib>" c'est parce que j'ai pas su bien les orthographier (j'avais pas mis les c, résultat quand je voulais utiliser atoi et atof le compilo m'insultait).
erreur corrigée

Cependant, ces fichiers d'en-tête sont typiquement du genre de ceux que l'on préfère ajouter dans le fichier d'implémentation (*.cpp) .

C'est vrai que c'est bien mieux, c'est quelque chose que j'avais oublié. Ralala ça fait mal les piqures de rappel
(Pour la petite histoire j'ai appris un peu de c++ l'été dernier pendant 3 mois, j'avais fait un peu de c et de java avant, et depuis cet été là je n'ai utilisé que du java donc forcément en un an j'ai très vite oublié le c et le c++)

Peut être est-il respecté lorsque CPG hérite publiquement de Network et de CPGSerializer, mais il me semble opportun de remettre cette réflection à l'honneur (surtout concernant CPGSerializer...

CPG ne serait il pas beaucoup mieux en étant "implémenté sous la forme d'un" CPGSerializer qu'en étant un CPGSerializer

désolé moi pas comprendre.
J'ai encore du mal avec la notion de serializer. En fait normallement je crois que le serializer dans le cas de la mise en place des parametres du reseau devrait en fait être un builder mais je n'arrive pas à visualiser la chose.
Pour CPG qui hérite publiquement de network le LSP est verifié. Un CPG est un type de reseau de neurone avec ses propres particularité. Pour ce qui est de CPG qui hérite de CPGSerializer je suis pas trop sûre. Comme je l'ai dit plus haut, peut-être que dans le cas de load il faudrait qu'il soit assimilé à un builder qui au fur et à mesure de la lecture du fichiers créer les objets avec une factory ou quelque chose du genre.

Fais attention également à déclarer au minium le destructeur virtuel si tes classes dérivées sont à manipuler de manière polymorphe...

Je sais que la norme admet que le mot clé virtual soit omis pour les classes dérivées, mais il me semble toujours opportun de rappeler au lecteur du code que c'est effectivement le cas

Compris, et corrigé !

Peut être serait-il intéressant de "scinder" les fichier network.* en autant de paires de fichier d'en-tête / implémentation qu'il n'y a de classe...

ahem ... qui a dis flemmingite aigu ?

un principe qu'il est bon de mettre en oeuvre est:

1. de passer par référence tout ce qui peut l'être
2. de ne pas renvoyer de référence non constante vers le membre d'une classe

afin d'éviter les risque de copies inutiles, tout en évitant que quelqu'un n'aille modifier le membre de la classe à l'insu de l'objet... Peut être devrais tu, effectivement, décider de renvoyer une référence constante avec tes getters, et veiller à passer les arguments de tes setters sous la forme de référence constante.
Interroge toi peut être sur l'utilité de déclarer tes membres privés, si c'est pour fournir un acces complet (du fait des getters et setters) à ces membres...

Peut être pourrais tu trouver des comportements plus opportuns que simplement get et set car, telles qu'elles se présentent actuellement, tes classes ne cachent absolument pas les détails d'implémentation, et, du coup, tu te faciliterait presque la tache à créer des structures, dont tous les membres serait publiques, et à créer des fonctions libres ...

Alors, je ne sais pas si tu te rappels de mes questions sur le pattern visiteur ...
L'idée c'est que dans mon réseau de neurone à chaque fois que je lui donne une nouvelle entrée (qui est calculée par le visiteur), il faut que je puisse mettre à jour les valeurs d'une partie de mes attributs (depuis le visiteur), en fait, il faut mettre à jour la sortie (output) dans le cas du cpg, et pour d'autres types de réseau il faut pouvoir mettre aussi à jour les poids (weights).
Et pour pour ça il faut que je puisse accéder aux attributs en "mode modification", ce qui veut dire non const il me semble.
Donc il faudrait en fait que dans network et CPG je fasse un certain nombre de fonctions publiques pour accéder aux parties intimes du réseau (les couches "layer" et les neurones "neuron") sans que l'on puisse accéder directement à celles-ci directement si j'ai bien compris.
Genre je veux récupérer une sortie d'un neurone, alors dans network je fais un getNeuron qui appellera un getLayer privé de la classe qui lui même appellera un getNeuron privé de la classe layer et ainsi de suite ? Je fais pareil pour les set ?
Et mon visiteur alors ? je lui donne juste accès au network ?
J'avoue que de ce côté là je suis un peu perdu

Pourquoi manipuler un pointeur de Matrix dans NetworkMap, alors que tu pourrais très bien manipuler une Matrix, tout simplement

Ma fois c'est un oubli, au début je voulais mettre des pointeurs partout, j'avais oublié les réferences Puis je m'en suis souvenue et j'ai corrigé partout sauf ici je crois et comme il ne me posait pas plus de problème que ça j'avoue ne pas y avoir touché par flemmardise. mais bon j'arrête d'être flemmarde, et je corrige ça de suite !

Merci Koala sama pour cette réponse complète, ça m'aide à me remettre les idées en place.