Problème avec la surcharge de l'opérateur + en fonction ami

**Raiden1234** · 03/03/2008, 13h25

Bonjour,

Alors voila j'ai surchargé l'opérateur + en tant que fonction ami et j'ai une erreur lors de l'execution du programme, du type

Code :

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

Erreur de segmentation

sur certain pc et de type

Code :

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

*** glibc detected *** free(): invalid next size (fast): 0x0804b078 ***

Abandon

Donc je m'explique : j'ai deux fichiers, un fichier chaine.h qui définit une classe Chain avec prototypes des fonctions et un fichier chaine.cpp qui contient le main et la définition des fonctions.

Pour mieux illustrer, voici le code :

chaine.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
class Chaine{
 
	// prototypes fonctions amies
	friend bool operator == (Chaine A, Chaine B);
	friend char * operator + (Chaine A, Chaine B);
 
	private:
 
		char *ch;
 
	public:
 
		// prototypes et/ou definitions des fonctions membres
		inline Chaine();
		inline Chaine(char car);
		inline Chaine(char c[]);
		inline Chaine(Chaine &P);
 
		inline ~Chaine();
 
		inline int taille() const;
		inline void Afficher();
 
		inline char operator [] (int indice) const;
		inline char & operator [] (int indice);
		inline char * operator = (const Chaine &P);
		inline char * operator += (const Chaine &P);
		inline Chaine & operator () (int indice, int len);
 
};

chaine.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
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
#include <iostream>
#include <cmath>
#include "chaine.h"
 
using namespace std;
 
int main() {
 
	Chaine c1("Bonjour");
	Chaine c2(c1);
	c1.Afficher();
	cout << c1.taille() << endl;
	cout << c1[3] << endl;
	Chaine c3("abc");
	c3 = c1;
	c3.Afficher();
	c3 = "abc";
	c1 += c3;
	c1.Afficher();
	Chaine cc("Bonjour");
	Chaine c4 = cc(2,3);
	c4.Afficher();
 
        // ERREUR ICI DE MA SURCHARGE DE L'OPERATEUR +
	cout << c1+c2 << endl;
 
	if (c1 == cc) {
		cout << "Les deux chaines sont identiques" << endl;
	}else{
		cout << "Les deux chaines sont différentes" << endl;
	}
 
}
 
inline Chaine::Chaine() {
	ch = 0;
}
 
inline Chaine::Chaine(char car) {
	ch = new char[1];
	ch[0]=car;
}
 
inline Chaine::Chaine(char c[]) {
	ch=new char[strlen(c)+1];
	strcpy(ch,c);
}
 
inline Chaine::Chaine(Chaine &P) {
	ch=new char[strlen(P.ch)+1];
	strcpy(ch,P.ch);
}
 
inline Chaine::~Chaine() {
	if (ch) { 
		delete []ch;
	}
}
 
inline void Chaine::Afficher() {
	cout << ch << endl;
}
 
inline int Chaine::taille() const {
	return strlen(ch);
}
 
inline char Chaine::operator [] (int indice) const{
	return ch[indice];
}
 
inline char & Chaine::operator [] (int indice) {	
	return ch[indice];
}
 
inline char * Chaine::operator = (const Chaine &P) {
	//ch=new char[strlen(P.ch)+1];
	return strcpy(ch,P.ch);
}
 
inline char * Chaine::operator += (const Chaine &P) {
 
	return strcat(ch,P.ch);
}
 
inline Chaine & Chaine::operator () (int indice, int len) {
	char *c = new char[len+1];
 
	for (int i = 0;i < len; i++) {
		c += this->ch[indice+i];
	}
	cout << c;
	return *this;
}
 
bool operator == (Chaine A, Chaine B) {
 
	if (strcmp(A.ch,B.ch) == 0) {
		return true;
	}else{
		return false;
	}
 
}
 
// SURCHARGE D'OPERATEUR QUI POSE PROBLEME
char * operator + (Chaine A, Chaine B) {
 
	return (strcat(A.ch,B.ch));
 }

J'avais déjà réalisé, comme vous pourrez le constater, quelques surcharges d'opérateurs en tant que fonctions membres (certaines consultaient seulement d'autres modifiaient).

Ensuite je me suis mis au surcharge d'opérateur en fonction ami, j'ai réussi à réaliser celle qui consulte (opérateur ==) par contre j'ai des problèmes pour celle qui modifie (opérateur +).

Merci de l'aide que vous voudrez bien m'apporter

Andréas

**Emmanuel Deloget** · 03/03/2008, 14h09

Envoyé par Raiden1234

Code :

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

1
2
3
4
5
6
 
// SURCHARGE D'OPERATEUR QUI POSE PROBLEME
char * operator + (Chaine A, Chaine B) {
 
	return (strcat(A.ch,B.ch));
 }

J'avais déjà réalisé, comme vous pourrez le constater, quelques surcharges d'opérateurs en tant que fonctions membres (certaines consultaient seulement d'autres modifiaient).

Ensuite je me suis mis au surcharge d'opérateur en fonction ami, j'ai réussi à réaliser celle qui consulte (opérateur ==) par contre j'ai des problèmes pour celle qui modifie (opérateur +).

Merci de l'aide que vous voudrez bien m'apporter

Andréas

strcat ne réalloue pas le buffer - il faut le faire toi même. += devrait lui aussi planter sauvagement. Quand à ce code:

Code :

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

1
2
3
4
 
char c = '1';
Chaine cs(c);
cs.Affiche();

Il plantera aussi, parce que le constructeur qui prend un caractère en paramètre est mal formé (il crée un char* de 1 caractère, et ne prévoie pas de place pour '\0').

Il y a de nombreux problèmes dans ta classe. Je te conseille de bien y réflechir afin de les corriger.

**Raiden1234** · 03/03/2008, 15h36

J'ai réfléchi sur la question du buffer et j'ai réécrit la surcharge comme ceci :

Code :

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

1
2
3
4
5
6
7
8
9
10
char * operator + (Chaine A, Chaine B) {
 
	char *c = new char[strlen(A.ch)+strlen(B.ch)+1];
 
	strcat(c,A.ch);
	strcat(c,B.ch);
 
	return c;
 
 }

Est-ce plus juste ? En tout cas elle semble fonctionner.

De plus j'aurais une question, le constructeur de recopie profonde n'est pas cencé s'occuper des réallouments lors de de manipulation de chaine de caractère ?

Désolé pour mes questions simplistes, je débute en C++.

**Médinoc** · 03/03/2008, 15h42

Sauf que tu devrais mettre le résultat dans une nouvelle Chaine plutôt que retourner un char*.

Code :

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

1
2
3
4
5
6
7
8
9
10
11
Chaine operator + (Chaine const & A, Chaine const & B) {
 
	char *c = new char[strlen(A.ch)+strlen(B.ch)+1];
 
	strcpy(c,A.ch);
	strcat(c,B.ch);
 
	Chaine ret(c);
	delete[] c; //je suppose que le constructeur de Chaine fait une copie
	return ret;
}

Ou, selon les caractéristiques de la classe Chaine, tu peux peut-être faire plus optimisé en évitant une copie.