tab[0][0], segmentation fault et constructeur de copie

Version imprimable

bonjour,

tab[0][0] me donne segmentation fault

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
grille::grille(grille &copieGrille){
	lieu **grilleNew;
	grilleNew=new lieu*[9];
	for(int y = 0; y < 9; y++){
		grilleNew[y]=new lieu[9];
	}
	for(int ligne(0);ligne<9;ligne++)
		for(int colonne(0);colonne<9;colonne++){
			copieGrille.setChiffreGrille(ligne,colonne,
																				this->getChiffreGrille(ligne,colonne));
			for(int i(1);i<=9;i++)
				if(getPossiblesGrille(ligne,colonne,i))
					copieGrille.setPossiblesGrille(ligne,colonne,i);
		}
	for(int y = 0; y < 9; y++){
   	delete [] tab[y]; 
	}
	delete [] tab;
	tab=grilleNew;
	for(int y = 0; y < 9; y++){
   	delete [] grilleNew[y]; 
	}
	delete [] grilleNew;
}

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
grille::grille(){
	tab=new lieu*[9];
	for(int y = 0; y < 9; y++){
    tab[y] = new lieu[9];
	}
}
 
grille::~grille(){
	for(int y = 0; y < 9; y++){
		delete [] tab[y]; 
	}
	delete [] tab;
}

Le segmentation fault est ci-dessous avec ligne=0 et colonne=0

Code:

1
2
3
int grille::getChiffreGrille(int ligne,int colonne){
	return tab[ligne][colonne].getChiffre();
}

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
#ifndef LIEU_HPP_
#define LIEU_HPP_
#include <vector>
class lieu{
private:
	int chiffre;
	std::vector<int> possibles;
public:
	lieu operator=(lieu copieLieu);
	int getChiffre();
	bool getPossibles(int indice);
	void setChiffre(int indice);
	void setPossibles(int i);
	void unsetPossibles(int indice);
	bool possibleUnique();
	int quelUnique();
	void lieuZero();
//	int dernierPossible();
};
#endif

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 GRILLE_HPP
#define GRILLE_HPP
#include "lieu.hpp"
class grille{
private:
	lieu **tab;
public:
	grille();
	~grille();
	grille(grille &copieGrille);
	bool absentLigne(int ligne,int chiffre);
	bool absentColonne(int colonne,int chiffre);
	bool absentBloc(int bloc,int chiffre);
	bool grilleIncomplete();
	int getChiffreGrille(int ligne,int colonne);
	void setChiffreGrille(int ligne,int colonne,int chiffre);
	bool getPossiblesGrille(int ligne,int colonne,int indice);
	void setPossiblesGrille(int ligne,int colonne,int indice);
	void zeroGrille();
	void init();
	void indicer();
	void resoudre();
	void afficher();
	void afficherIndices();
	bool alignementVerticalBloc(int bloc,int colonne,int indice);
	bool alignementHorizontalBloc(int bloc,int ligne,int indice);
	void supprimerChiffreLigne(int bloc,int ligne,int occurence);
	void supprimerChiffreColonne(int bloc,int colonne,int occurence);
	bool uniqueLigne(int ligne,int chiffre);
	bool uniqueColonne(int colonne,int chiffre);
	bool uniqueBloc(int bloc,int chiffre);
};
 
#endif

quelqu'un a une idée?

14/03/2016, 12h43
Bousk

Salut,

tu te serais pas un peu tout mélangé ?
Ca ressemble vaguement à un constructeur par copie, sauf que ton argument est loin d'être const, et tu le modifies alors que tab de ton nouvel objet n'est absolument jamais géré, ni initialisé. Tu travailles sur un grilleNew qui n'a rien à voir. :calim2:
Tu l'initialises uniquement dans le constructeur par défaut, mais il n'est pas appelé si le constructeur par copie est appelé.

merci Bousk, j'avais pas réalisé que l'objet à copier était celui en argument:

j'ai donc réécrit le constructeur comme ceci (messages d'erreur):

Code:

1
2
3
4
5
6
7
8
9
grille::grille(grille const& copieGrille){
	for(int ligne(0);ligne<9;ligne++)
		for(int colonne(0);colonne<9;colonne++){
			this->setChiffreGrille(ligne,colonne,copieGrille.getChiffreGrille(ligne,colonne));
			for(int i(1);i<=9;i++)
				if(copieGrille.getPossiblesGrille(ligne,colonne,i))
					this->setPossiblesGrille(ligne,colonne,i);
		}
}

g++ me donne:

Code:

1
2
3
4
5
6
7
grille.cpp: In copy constructor ‘grille::grille(const grille&)’:
grille.cpp:33:59: error: passing ‘const grille’ as ‘this’ argument of ‘int grille::getChiffreGrille(int, int)’ discards qualifiers [-fpermissive]
                 copieGrille.getChiffreGrille(ligne,colonne));
                                                           ^
grille.cpp:35:54: error: passing ‘const grille’ as ‘this’ argument of ‘bool grille::getPossiblesGrille(int, int, int)’ discards qualifiers [-fpermissive]
     if(copieGrille.getPossiblesGrille(ligne,colonne,i))
                                                      ^

Code:

1
2
3
bool grille::getPossiblesGrille(int ligne,int colonne,int indice){
	return tab[ligne][colonne].getPossibles(indice);
}

Code:

1
2
3
void grille::setPossiblesGrille(int ligne,int colonne,int indice){
	tab[ligne][colonne].setPossibles(indice);
}

je ne comprends pas très bien ces messages d'ereur

14/03/2016, 13h37
emmesse

en fait, la grille est la même dans les deux objet.
il faudrait qu'un nouveau tableau de lieu soit créé dans l'objet cible.

j'ai fait comme ceci,mais j'ai toujours des messages d'erreur:

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
grille::grille(grille const& copieGrille){
	int x;
	lieu **grilleNew;
	grilleNew=new lieu*[9];
	for(int y = 0; y < 9; y++){
		grilleNew[y]=new lieu[9];
	}
	for(int ligne(0);ligne<9;ligne++)
		for(int colonne(0);colonne<9;colonne++){
			x=copieGrille.getChiffreGrille(ligne,colonne);
			grilleNew[ligne][colonne].setChiffre(x);
			for(int i=1;i<=9;i++)
				if(copieGrille.getPossiblesGrille(ligne,colonne,i))
					setPossiblesGrille(ligne,colonne,i);
		}
	for(int y = 0; y < 9; y++){
   	delete [] tab[y]; 
	}
	delete [] tab;
	tab=grilleNew;
	for(int y = 0; y < 9; y++){
   	delete [] grilleNew[y]; 
	}
	delete [] grilleNew;
}

g++ me donne:

Code:

1
2
3
4
5
6
7
grille.cpp: In copy constructor ‘grille::grille(const grille&)’:
grille.cpp:33:48: error: passing ‘const grille’ as ‘this’ argument of ‘int grille::getChiffreGrille(int, int)’ discards qualifiers [-fpermissive]
    x=copieGrille.getChiffreGrille(ligne,colonne);
                                                ^
grille.cpp:36:54: error: passing ‘const grille’ as ‘this’ argument of ‘bool grille::getPossiblesGrille(int, int, int)’ discards qualifiers [-fpermissive]
     if(copieGrille.getPossiblesGrille(ligne,colonne,i))
                                                      ^

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
class lieu{
private:
	int chiffre;
	std::vector<int> possibles;
public:
	//lieu operator=(lieu copieLieu);
	int getChiffre();
	bool getPossibles(int indice);
	void setChiffre(int indice);
	void setPossibles(int i);
	void unsetPossibles(int indice);
	bool possibleUnique();
	int quelUnique();
	void lieuZero();
//	int dernierPossible();
};

quelqu'un a une idée?

14/03/2016, 14h22
ternel

Dans "passing const bidule as truc discards qualifier", le qualifieur est const.
Le problème est que le pointeur ou la référence truc désigne une variable modifiable, mais que tu essaie de l'initialiser vers une constante.
La solution est de rendre le pointeur ou la référence constante.

Quand il s'agit de this, c'est qu'il faut définir la fonction comme portant sur une constante. C'est fait en ajoutant le mot clé const après les arguments.

Par exemple, il faut que getChiffreGrille soit défini ainsi int grille::getChiffreGrille(int, int) const.
Au passage, comme c'est une fonction membre de grille, il est inutile de préciser à nouveau grille dans son nom.

Citation:

Au passage, comme c'est une fonction membre de grille, il est inutile de préciser à nouveau grille dans son nom.

en fait, les méthodes de grille et lieu ont des noms similaire. C'est pour ça que je précise "grille" pour les méthodes de grille, sans "grille" pour les méthodes de lieu

en modifiant comme ceci:
Code:

1 2 3 int grille::getChiffreGrille(int ligne,int colonne)const{ return tab[ligne][colonne].getChiffre(); }
réponse du compilateur:
Code:

1 2 3 4 grille.cpp: In copy constructor ‘grille::grille(const grille&)’: grille.cpp:36:54: error: passing ‘const grille’ as ‘this’ argument of ‘bool grille::getPossiblesGrille(int, int, int)’ discards qualifiers [-fpermissive] if(copieGrille.getPossiblesGrille(ligne,colonne,i)) ^
cela vous dit quelque chose?

14/03/2016, 14h54
ternel

Qu'as-tu compris de ma réponse précédente?
14/03/2016, 17h56
emmesse

je ne comprenais pas mais j'ai finalement compris:

Code:

bool grille::getPossiblesGrille(int ligne,int colonne,int indice)const{

Code:

bool getPossiblesGrille(int ligne,int colonne,int indice)const;

mais ça me refait segmentation fault à l'execution

quelqu'un a une idée?(je reposterais plus tard, après avoir utilisé ddd)
14/03/2016, 18h15
Bousk

Dans mon premier message, je te dis que ton tab n'est pas initialisé.. et tu l'utilises via setPossiblesGrille (entre autre - relis ton code de manière calme et posée), tu m'étonnes que tu fasses des segfault à l'exécution.. :roll:

c'est ici que maintenant ça coince,dès l'occurence y à zéro (j'ai trouvé ce bout de code je ne sais plus où, sur internet)

Code:

1
2
3
	for(int y = 0; y < 9; y++){
   	delete [] tab[y]; 
	}

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
grille::grille(grille const& copieGrille){
	int x;
	lieu **grilleNew;
	grilleNew=new lieu*[9];
	for(int y = 0; y < 9; y++){
		grilleNew[y]=new lieu[9];
	}
	for(int ligne(0);ligne<9;ligne++)
		for(int colonne(0);colonne<9;colonne++){
			x=copieGrille.getChiffreGrille(ligne,colonne);
			grilleNew[ligne][colonne].setChiffre(x);
			for(int i=1;i<=9;i++)
				if(copieGrille.getPossiblesGrille(ligne,colonne,i))
					setPossiblesGrille(ligne,colonne,i);
		}
	for(int y = 0; y < 9; y++){
   	delete [] tab[y]; 
	}
	delete [] tab;
	tab=grilleNew;
	for(int y = 0; y < 9; y++){
   	delete [] grilleNew[y]; 
	}
	delete [] grilleNew;
}

c'est vrais, je ne vous avais pas montré ce code:la grille est initialisée dans main()

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
int main(){
	int ligne,colonne;
	int exemple[9][9]={
		{0,0,0,0,0,0,0,0,0},
		{0,0,4,0,0,8,9,0,0},
		{8,5,7,0,0,6,2,0,0},
		{7,0,9,0,0,0,0,0,0},
		{0,0,0,6,2,7,0,3,0},
		{0,3,6,0,0,0,0,0,4},
		{0,0,0,0,0,0,3,0,5},
		{6,4,0,0,8,0,0,0,0},
		{0,0,8,0,0,3,0,7,0}
	};
 
	grille G;
	for(ligne=0;ligne<9;ligne++)
		for(colonne=0;colonne<9;colonne++)
			G.setChiffreGrille(ligne,colonne,exemple[ligne][colonne]);
	grille G2(G);
	G2.setChiffreGrille(0,0,8);
	G.afficher();
	cout<<endl;
	G2.afficher();
}

Bon je sais pas trop en quelle langue te le dire là..

Ton problème c'est pas G, mais G2.
Ton G.tab est initialisé via son constructeur par défaut, G2 est initialisé par le constructeur de copie dans lequel tab est indéfini! Parce que, relis ton cours de C++, le constructeur par défaut n'est en aucun cas appelé! Vu qu'on appelle le constructeur par copie..
Parce que si tu lisais un peu ton code, au lieu de bêtement copier d'internet
Code:

1 2 3 4 5 6 7 8 9 10 11 for(int ligne(0);ligne<9;ligne++) for(int colonne(0);colonne<9;colonne++){ x=copieGrille.getChiffreGrille(ligne,colonne); grilleNew[ligne][colonne].setChiffre(x); for(int i=1;i<=9;i++) if(copieGrille.getPossiblesGrille(ligne,colonne,i)) setPossiblesGrille(ligne,colonne,i); } void grille::setPossiblesGrille(int ligne,int colonne,int indice){ tab[ligne][colonne].setPossibles(indice); }
Au passage, d'où sort cette seconde boucle qui itère sur [1,9] ? Y'aurait-il pas un problème d'indice ?!
Et puis quitte à faire des tableaux à tailles fixes, autant les faire vraiment à taille fixe, définie à la compilation.
Parce que en l'état, à chaque fois que tu vas corriger un problème, vu l'état du code, tu as une segfault quelques lignes plus tard prête à t'exploser pleine figure. :calim2:

si je n'utilise pas new, les deux objets se partagerons le même tableau non?

la valeur de 1 à >=9 ne sont pas des indices de tableaux, mais de valeurs dans un vector<int> de la classe lieu (vector<int> possibles)

j'ai fait autrement, avec une surcharge d'opérateur d'affectation
ça a marché un moment mais c'était pas tout à fait ça et suite à des modification, l'affectation tab=grilleNew ne se fait plus

mainn.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
#include <iostream>
#include "grille.hpp"
#include "lieu.hpp"
using namespace std;
 
int main(){
	int ligne,colonne;
	int exemple[9][9]={
		{0,0,0,0,0,0,0,0,0},
		{0,0,4,0,0,8,9,0,0},
		{8,5,7,0,0,6,2,0,0},
		{7,0,9,0,0,0,0,0,0},
		{0,0,0,6,2,7,0,3,0},
		{0,3,6,0,0,0,0,0,4},
		{0,0,0,0,0,0,3,0,5},
		{6,4,0,0,8,0,0,0,0},
		{0,0,8,0,0,3,0,7,0}
	};
 
	grille G1,G2;
		for(ligne=0;ligne<9;ligne++)
		for(colonne=0;colonne<9;colonne++)
			G1.setChiffreGrille(ligne,colonne,exemple[ligne][colonne]);
	G2=G1;
	G2.setChiffreGrille(0,0,8);
	G1.afficher();
	cout<<endl;
	G2.afficher();
	G.afficher();
}

lieu.hpp

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
#ifndef LIEU_HPP_
#define LIEU_HPP_
#include <vector>
class lieu{
private:
	int chiffre;
	std::vector<int> possibles;
public:
	int getChiffre();
	bool getPossibles(int indice);
	void setChiffre(int indice);
	void setPossibles(int i);
};
#endif

lieu.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
#include "lieu.hpp"
#include <vector>
using namespace std;
 
int lieu::getChiffre(){
	return chiffre;
}
 
bool lieu::getPossibles(int indice){
	int i;
	for(i=0;i<possibles.size()&&possibles[i]!=indice;i++)
		;
	if(i<possibles.size())
		return true;
	return false;
}
 
void lieu::setChiffre(int i){
	chiffre=i;
}
 
void lieu::setPossibles(int i){
	possibles.push_back(i);
}

grille.hpp

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
#ifndef GRILLE_HPP
#define GRILLE_HPP
#include "lieu.hpp"
class grille{
private:
	lieu **tab;
public:
	grille();
	~grille();
	grille operator=(grille aCopier);
	int getChiffreGrille(int ligne,int colonne)const;
	void setChiffreGrille(int ligne,int colonne,int chiffre);
	bool getPossiblesGrille(int ligne,int colonne,int indice)const;
	void setPossiblesGrille(int ligne,int colonne,int indice);
};
 
#endif

grille.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
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
#include <iostream>
#include <vector>
#include "grille.hpp"
using namespace std;
 
grille::grille(){
	tab=new lieu*[9];
	for(int y = 0; y < 9; y++){
    tab[y] = new lieu[9];
	}
}
 
grille::~grille(){
	for(int y = 0; y < 9; y++){
		delete [] tab[y]; 
	}
	delete [] tab;
}
 
grille grille::operator=(grille aCopier){
	int x;
	lieu **grilleNew;
	grilleNew=new lieu*[9];
	for(int y = 0; y < 9; y++){
		grilleNew[y]=new lieu[9];
	}
	for(int ligne(0);ligne<9;ligne++)
		for(int colonne(0);colonne<9;colonne++){
			x=aCopier.getChiffreGrille(ligne,colonne);
			grilleNew[ligne][colonne].setChiffre(x);
			for(int i=1;i<=9;i++)
				if(aCopier.getPossiblesGrille(ligne,colonne,i))
					setPossiblesGrille(ligne,colonne,i);
		}
	for(int y = 0; y < 9; y++){
   	delete [] tab[y]; 
	}
	delete [] tab;
	tab=grilleNew;
	return *this;
}
 
void grille::afficher(){
	int ligne,colonne,chiffre;
	for(ligne=0;ligne<9;ligne++)
		for(colonne=0;colonne<9;colonne++)
			if(colonne<8)
				cout<<tab[ligne][colonne].getChiffre()<<" ";
			else
				cout<<tab[ligne][colonne].getChiffre()<<endl;
}
 
 
 
void grille::setChiffreGrille(int ligne,int colonne,int chiffre){
	tab[ligne][colonne].setChiffre(chiffre);
}
 
void grille::setPossiblesGrille(int ligne,int colonne,int indice){
	tab[ligne][colonne].setPossibles(indice);
}
 
int grille::getChiffreGrille(int ligne,int colonne)const{
	return tab[ligne][colonne].getChiffre();
}
 
bool grille::getPossiblesGrille(int ligne,int colonne,int indice)const{
	return tab[ligne][colonne].getPossibles(indice);
}

pourquoi l'affectation tab=grilleNew ne se fait pas?

enfin ça marche:
c'est bizard, je croyais que les deux objets se seraient partagé le même tableau, mais en fait non...
main.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
#include <iostream>
#include "grille.hpp"
#include "lieu.hpp"
using namespace std;
 
int main(){
	int ligne,colonne;
	int exemple[9][9]={
		{0,0,0,0,0,0,0,0,0},
		{0,0,4,0,0,8,9,0,0},
		{8,5,7,0,0,6,2,0,0},
		{7,0,9,0,0,0,0,0,0},
		{0,0,0,6,2,7,0,3,0},
		{0,3,6,0,0,0,0,0,4},
		{0,0,0,0,0,0,3,0,5},
		{6,4,0,0,8,0,0,0,0},
		{0,0,8,0,0,3,0,7,0}
	};
	grille G1,G2;
for(ligne=0;ligne<9;ligne++)
		for(colonne=0;colonne<9;colonne++)
			G1.setChiffreGrille(ligne,colonne,exemple[ligne][colonne]);
	cout<<"grille 1"<<endl;
	G1.afficher();
	cout<<endl;
	G2=G1;
	G2.setChiffreGrille(0,0,8);
	cout<<"grille 1"<<endl;	
	G1.afficher();
	cout<<endl;
	cout<<"grille 2"<<endl;
	G2.afficher();
}

lieu.hpp

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
#ifndef LIEU_HPP_
#define LIEU_HPP_
#include <vector>
class lieu{
private:
	int chiffre;
	std::vector<int> possibles;
public:
	int getChiffre()const;
	bool getPossibles(int indice);
	void setChiffre(int indice);
};
#endif

lieu.cpp

Code:

1
2
3
4
5
6
7
8
9
10
11
#include "lieu.hpp"
#include <vector>
using namespace std;
 
int lieu::getChiffre()const{
	return chiffre;
}
 
void lieu::setChiffre(int i){
	chiffre=i;
}

grille.hpp

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
#ifndef GRILLE_HPP
#define GRILLE_HPP
#include "lieu.hpp"
class grille{
private:
	lieu tab[9][9];
public:
	grille operator=(grille aCopier);
	int getChiffreGrille(int ligne,int colonne)const;
	void setChiffreGrille(int ligne,int colonne,int chiffre);
	void afficher();
};
 
#endif

grille.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
#include <iostream>
#include <vector>
#include "grille.hpp"
using namespace std;
 
char getch();
 
grille grille::operator=(grille aCopier){
	for(int ligne(0);ligne<9;ligne++)
		for(int colonne(0);colonne<9;colonne++)
			this->tab[ligne][colonne].setChiffre(aCopier.getChiffreGrille(ligne,colonne));
	return *this;
}
 
void grille::afficher(){
	int ligne,colonne,chiffre;
	for(ligne=0;ligne<9;ligne++)
		for(colonne=0;colonne<9;colonne++)
			if(colonne<8)
				cout<<tab[ligne][colonne].getChiffre()<<" ";
			else
				cout<<tab[ligne][colonne].getChiffre()<<endl;
}
 
void grille::setChiffreGrille(int ligne,int colonne,int chiffre){
	tab[ligne][colonne].setChiffre(chiffre);
}
 
int grille::getChiffreGrille(int ligne,int colonne)const{
	return tab[ligne][colonne].getChiffre();
}

15/03/2016, 09h28
Bousk

Citation:

Envoyé par matser

si je n'utilise pas new, les deux objets se partagerons le même tableau non?

Oh si ils vont le partager. Ils vont totalement le partager même. Tellement qu'ils utiliseront exactement le même en fait. Autrement dit, t'en détruis un, tu fuck l'autre qui le référence toujours. Et inversement.
Enfin si tu le leur indiques bien sûr. Parce que dans ton code.. où crois-tu indiquer qu'ils partagent un même tableau ? Et quel tableau ? Tu le libères quand d'ailleurs ?

Citation:

Envoyé par matser

pourquoi l'affectation tab=grilleNew ne se fait pas?

Elle se fait, mais je doute que tu saches ce qu'elle fait réellement. Tu ne sembles pas savoir manipuler des pointeurs. C'est pas difficile mais pas anodin. Donc ta solution finale de ne plus en manipuler est de loin la meilleure.
La manipulation de pointeurs ne se fait pas n'importe comment. Et une classe qui en manipule ainsi, si on veut la rendre copiable etc, se doit d'implémenter les constructeur de copie et opérateur d'affectation. Ce qu'on appelle la forme canonique de Coplien.
Btw, le paramètre est un const& et non une copie en général. On utilisera le paramètre en copie pour faire un copy&swap par contre.

Je commence à lire un papier de 40 pages qui parle de la forme canonique de Coplien et j'ai modifié la surcharge de l'affectation de la classe grille:
Code:

1 2 3 4 5 6 grille& grille::operator=(const grille &aCopier){ for(int ligne(0);ligne<9;ligne++) for(int colonne(0);colonne<9;colonne++) this->tab[ligne][colonne].setChiffre(aCopier.getChiffreGrille(ligne,colonne)); return (grille&)*this; }
Code:

grille &operator=(const grille &aCopier);

et ça marche.
Dans ce petit tuto, il est indiqué qu'il faut renvoyer une référence sur ce type. c'est pourquoi j'ai mis return (grille&)*this;
qu'en pensez-vous?

15/03/2016, 21h44
Médinoc

Si les grilles sont toujours aux mêmes dimensions, je suppose que c'est OK.