cout << bizarrerie

Version imprimable

01/10/2009, 03h49
ghani56

cout << bizarrerie
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:

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:

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

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 !
01/10/2009, 10h17
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é ?
01/10/2009, 11h57
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:

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:

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 ;)

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:

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:

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:

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:

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:

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:

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:

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:

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:

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:

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:

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:

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:

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:

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:

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:

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:

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:

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:

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:

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 :oops:
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 :arf: 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.

01/10/2009, 14h09
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.
01/10/2009, 14h30
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 :boulet:
Merci pour la remarque, c'est corrigé chez moi ^^"""
01/10/2009, 14h51
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 :aie:

<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 :question:

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 :question:

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 :question: 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 :D...

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 :question:

Ce ne sont là que quelques réflexions dans leur versions courtes, n'hésite pas à demander des précisions en cas de besoin ;)
01/10/2009, 15h47
ghani56

Citation:

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 :oops: mes excuses :oops:

Citation:

<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

Citation:

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 :fessee:
(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++)

Citation:

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.

Citation:

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é !

Citation:

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 ? :sleep:

Citation:

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 ... :roll:
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 :?

Citation:

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 :roll: 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 :hola: pour cette réponse complète, ça m'aide à me remettre les idées en place. :mouarf:
01/10/2009, 16h39
3DArchi

Citation:

Envoyé par ghani56

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 :?

Salut,
En fait, beaucoup d'éléments donnés par Koala sont dans la F.A.Q. ;) et en particulier celui-ci : Les amis brisent-ils l'encapsulation ? qui si j'ai bien compris (quoique j'avoue avoir lu un peu en diagonal) devrait répondre plus ou moins à ta question et ton problème de getter/setter.
01/10/2009, 16h59
ghani56

j'avoue que j'y ai pensé très sérieusement mais que comme je maitrise pas du tout cet aspect là j'ai préféré pas prendre de risque, à tort apparemment.
Je vais tenter, on verra bien ce que ça donne.
Et j'ai relu et rerelu cette partie de la faq !
En fait j'ai peur d'en abuser si je commence à utiliser, c'est bête n'est ce pas ?

Merci pour la piste, je n'osait pas la prendre mais tu m'as convaincu de faire le pas ^^
01/10/2009, 17h13
3DArchi

Après il faut toujours prendre le temps d'un peu de recul sur ta conception. Si tout le monde commence à être ami avec tout le monde, c'est pas que le monde est devenu peacefull, c'est que tu n'as probablement pas le bon niveau d'abstraction.
L'amitié, c'est pas pour faire à la place de getter/setter. C'est à utiliser en cohérence avec une bonne conception.
01/10/2009, 17h42
koala01

Citation:

Envoyé par ghani56

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.

Pose toi la question de savoir s'il est sémantiquement correct de dire qu'un CPG est un CPGSerializer...

Personnellement, je dirais que non: un CPG agit, pour partie du moins, comme un CPGSerializer, mais ce n'en est pas un: c'est un network.

L'idée est donc:
Soit de dire qu'il y a un composant (un membre) CPGSerializer dans CPG auquel on accede *éventuellement* au départ d'une fonction membre de CPG nommée serialize (par exemple)
soit de dire qu'il est "implémenté en termes de" CPGSerializer, et, dans ce cas là, on déclare l'héritage privé, et on crée, là aussi, une (des) fonction(s) membre(s) qui permet(tent) d'en invoquer les comportements qui nous intéressent réellement.

Citation:

ahem ... qui a dis flemmingite aigu ? :sleep:

On en reparle dans trois ou six mois, quand tu auras eu le temps d'oublier ce que fait ton code :question:

Je peux dores et déjà prédire que tu perdra beaucoup plus de temps et d'énergie tel que tes fichiers se présentent que de temps et d'énergie à les scinder aujourd'hui, alors que le projet est bien clair dans ta tête...

Maintenant, ce ne sont que des conseils :D

Citation:

Alors, je ne sais pas si tu te rappels de mes questions sur le pattern visiteur ... :roll:

J'y ai sans doute participé, mais, là, c'est moi qui ai la flegme de faire la recherche :D

Citation:

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.

Non, justement pas...

Ce qu'il faut, c'est que tu réfléchisse aux comportements, nommés et "auto-commentés" que tu attend de tes différentes classes et qu'il est intéressant d'exposer de manière publique.

Si tu construit une voiture, tu n'a pas besoin de passer par le réservoir pour connaitre le niveau d'essence...

Tout le monde sait bien que le réservoir fait bel et bien partie intégrante de toute voiture en état de marche, mais tous ceux qui ne sont pas mécaniciens s'en foutent royalement: pour eux, c'est la jauge d'essence, et son comportement qui importe.

Quand ils veulent savoir s'il est temps d'aller faire le plein, il regardent le niveau "au travers de la jauge".

Le raisonnement est identique ici: tu ne renvoie pas ta "Matrix" ici et tu n'en crées pas une pour dire après "au fait, cette matrice, elle doit appartenir à tel objet", tu crées des comportements qui permettent de récupérer les différents éléments de la Matrix ou d'en rajouter, d'en supprimer et d'en modifier, selon les besoins.

Citation:

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 ?

C'est à peu près le principe... Si ce n'est qu'il faut penser en terme de comportement et qu'il faut garder en mémoire la loi demeter et ses implications:

En OO, cela se traduit par

Citation:

Si une classe A fait appel à une classe B, et que la classe B fait elle-même appel à une classe C, la classe A n'a absolument pas avoir connaissance de la classe C pour travailler avec la classe B

On pourrait résumer les choses en parlant du principe de "connaissance minimale" ;)

Citation:

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 :?

Tu lui donne accès aux comportements publiques de l'objet qu'il doit manipuler, point-barre.

Eventuellement, si ton visiteur doit pouvoir faire certaines choses qui n'ont aucun sens d'être exposées de manière publique (parce qu'il n'y aurait aucun sens à permettre autre chose que ton visiteur d'invoquer un comportement particulier), tu déclares ton visiteur ami de ton objet visité ;)

Fais toute fois attention à la chose marante de l'amitié : elle ne te dispense pas forcément d'invoquer des comportements défini dans l'objet visité (mais déclarés comme protégés ou privés), plutôt que d'en manipuler directement les membres ;)
11/10/2009, 09h01
ghani56

Coucou,

Désolée d'avoir mis du temps à répondre, j'ai eu pas mal de boulot ces deux dernières semaines avec la reprise des cours. Et aussi car encore une fois j'ai pas mal cogité ton post pour être sûre de comprendre.

Citation:

On en reparle dans trois ou six mois, quand tu auras eu le temps d'oublier ce que fait ton code

ahem, je sais, mais bon c'était prévu de reformater les entêtes dans ce sens, c'est juste qu'il me fallait quelque chose à montrer rapidement et comme maintenant c'est fait je vais pouvoir m'y mettre et faire les modifications nécessaires pour que ce soit plus propre.

Pour le reste je pense avoir compris. Mon corps (classe body) est en quelque sorte l'interface/la façade que les gens peuvent voir mais ils ne savent pas comment je suis faites à l'intérieur en précision (il leur faudrait etre chirurgien et m'ouvrir) en revanche ils peuvent me poser des questions et en fonctions de si je pense que c'est nécessaire ou pas je leur réponds.

Encore une fois merci pour votre aide, vous m'avez sauvé la vie en quelque sorte.

Bonne continuation à vous tous ^^ :ccool: