Problème opérateur affection

Version imprimable

Bonjour,

j'essaye de créer une class String, mais je n'arrive pas à faire fonctionner mon opérateur d'affectation.

Je vous transmet mon code :

le . 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
 
 
#ifndef _Sring
#define _Strng
 
class String {
 
private:
 
	char* _string; 
 
public:
 
	String();   //constructeur par défaut
	~String();   // destructeur
	String(const String &stringACopier);
	String operator=(const String &aString);
 
 
 
};
 
#endif

et le .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
 
 
#include "String.h"
#include <iostream>
using namespace std;
 
String::String(){
 
	_string = new char();
 
}
 
String::~String(){
 
	delete [] _string;
 
}
 
String::String(const String &stringACopier){
 
	if( this != &stringACopier){
 
		_string = new char[strlen(stringACopier._string)+1];	
 
		if (_string != NULL){
			strcpy (_string, stringACopier._string);
		}
 
	}
 
 
}
 
String String::operator=(const String &aString){
 
	if( this != &aString){
 
		if (_string != NULL){
			delete [] _string;
		}
 
		_string = new char[strlen(aString._string)+1];	
 
		if (_string != NULL){
			strcpy (_string, aString._string);
		}
 
	}
 
	return (*this);
}

j'éspère que vous pourrez m'aider car je ne vois vraiment pas d'où vient le problème.

Car quand dans le main je fais :

Code:

1
2
3
4
5
 
 
	String s1;
	s1 ="azd";  //j'ai une erreur ici
	String s2 = s1;//mais pas là

merci d'avance et joyeuses fêtes.

Bonjour,
Pour répondre concrètement à ton problème, l'opérateur que tu as écrit permet d'affecter un objet String à un autre objet String. Or "azd" est un const char*. Rien ne permet de le transformer en String. L'idée va donc être de rajouté un constructeur depuis un char* vers un String :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 class String { ... public: String(); explicit String(const char*);// explicit pour ne pas avoir de conversion non maitrisée dans notre dos. ... }; String::String(const char*str_) { _string = new char[strlen(str_)+1]; if (_string != NULL){ strcpy (_string, str_); } }
Ensuite, tu l'utilises simplement :
Code:

1 2 s1 =String("azd");
Pour cette solution, j'ai repris tes principes. Maintenant, voici quelques conseils supplémentaires :
1/ je présume que ceci fait parti d'un exercice pour apprendre, car sinon il existe std::string pour gérer les chaines de caractères.

2/ strcpy n'est pas une fonction sûre, particulièrement si la chaîne à recopier est mal formée et ne se termine pas par \0. On préfère utiliser strncpy, puisqu'on peut spécifier une taille.

3/ Tu peux gérer les exceptions dans tes allocations. C'est une bonne habitude à prendre.

4/ Généralement, pour l'opérateur =, on préfère l'idiome copy and swap. Cela se traduit comme ça (de manière générique):
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 T& T::operator=(const T&rhs_) { if(this!=&rhs_){ T temp(rhs_); temp.swap(*this); } return *this; } // ou encore mieux: T& T::operator=(T rhs_) { if(this!=&rhs_){ rhs_.swap(*this); } return *this; } void T::swap(T&rhs_) { // pour chaque membre: std::swap(membre_1, rhs_.membre_1); std::swap(membre_2, rhs_.membre_2); ... std::swap(membre_n, rhs_.membre_n); }

24/12/2008, 14h42
Goten

Une question en passant... n'est il pas établie que le test anti auto-affectation est un anti-idiome? Surtout quand on utilise derrière l'idiome du copy & swap?

ps : ce n'est qu'un point que j'aimerais éclaircir ... je n'affirme rien.
24/12/2008, 15h00
3DArchi
Tu as raison, j'ai fait un copier/coller rapide. Avec T T::operator=(T rhs_), on a toujours une copie...
D'ailleurs, comment fait-tu pour avoir un copy-constructeur sur lui-même? Je pense à ça :
Code:

1 2 3 4 String::String(const String &stringACopier){ if( this != &stringACopier){
Si on reste avec la forme T& T::operator=(T const & rhs_), alors là, je pense qu'il faut faire le test (d'ailleurs, c'est dans la forme canonique de Coplien, non?).
24/12/2008, 15h11
Médinoc
Que signifient les lettres "rhs" dans le cas présent? Car si le "r" est pour référence, il est à supprimer de la seconde implémentation de operetor=, puisqu'on ne bosse plus avec des références...

De plus, au sujet de strncpy() : Elle a ses propres problèmes, notamment lorsqu'elle tronque une chaîne trop longue. À strncpy(d, s, n), préférer:
Code:

1 2 d[0] = '\0'; strncat(d, s, n-1);
Ceci tronque la chaîne correctement.

De plus, lors qu'on vient de faire un new avec un strlen(), on peut penser que mettre directement un strcpy() est plus simple et plus rapide à l'exécution qu'un strncpy(). Mais dans ce cas, autant mettre directement un memcpy(), qui sera encore plus rapide et ne provoquera pas de warning...
24/12/2008, 15h15
3DArchi
Citation:
Envoyé par Médinoc

De plus, au sujet de strncpy() : Elle a ses propres problèmes, notamment lorsqu'elle tronque une chaîne trop longue. À strncpy(d, s, n), préférer:

Code:

1 2 d[0] = '\0'; strncat(d, s, n-1);

Ceci tronque la chaîne correctement.
C'est vrai, j'oublie tous le temps. Mea culpa !

je pensais avoir résolu le problème en faisant :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 String& String::operator=(const char * aString){ if (_string != NULL){ delete [] _string; } _string = new char[strlen(aString)+1]; if (_string != NULL){ strcpy (_string, aString); } return (*this); }
Car si je ne me trompe pas c'est un constructeur que tu m'as donné et ce n'est pas plutôt l'opérateur d'affectation qu'il faut utiliser???

et j'avais ajouté ça en tant que constructeur :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 String::String(char * uneChaine){ _string = new char[strlen(uneChaine)+1]; if (_string != NULL){ strcpy (_string, uneChaine); } }
En faite je dois construire les méthode pour faire :

- s1 = "hello ";(opérateur d'affectation)
- String s3(", how are you"); (constructeur comme tu m'as montré)

Si je ne me trompe pas.

PS :

-si vous pouvez m'accorder un peux plus de temp pour pouvoir effectuer ceci :

- String s4 = '?';

Merci encore de vos réponses

24/12/2008, 19h45
Goten

Relis la fin de son code.. il t'a bien donné un exemple générique sur les opérateurs d'affectation ;
28/12/2008, 16h18
Alp

A titre anecdotique, 'rhs' signifie right hand side... Par exemple, pour l'opérateur =, ce que tu assignes à ton objet se trouve à droite (right) du signe '='.

Salut,

Citation:

Envoyé par bobosh

je pensais avoir résolu le problème en faisant :
Car si je ne me trompe pas c'est un constructeur que tu m'as donné et ce n'est pas plutôt l'opérateur d'affectation qu'il faut utiliser???

Oui, le constructeur te permet de construire un String à partir d'une chaîne et l'opérateur = ensuite est celui qui prend un paramètre String. C'est pour ça qu'un seul des deux suffit.

Citation:

Envoyé par bobosh

-si vous pouvez m'accorder un peux plus de temp pour pouvoir effectuer ceci :

- String s4 = '?';

Merci encore de vos réponses

Pour

Code:

String s4 = '?';

Le principe est le même que pour la chaîne de caractère, sauf que tu travaille avec char au lieu de char*. Tu as préféré surcharger l'opérateur = avec un char*, donc dans la logique de ce que tu as fait, ce serait :
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 String& String::operator=(const char aChar){ if (_string != NULL){ delete [] _string; } _string = new char[2]; if (_string != NULL){ _string[0]=aChar; _string[1]=0; } return (*this); } et String::String(char unChar){ _string = new char[2]; if (_string != NULL){ _string[0]=unChar; _string[1]=0; } }
Mais, pour reprendre ce que j'avais dit au début, la bonne pratique est :
-> Un constructeur pour ces types (String(char) et String(const char*)
-> Un seul opérateur =(String) avec l'idiome copy and swap.

Les constructeurs peuvent être 'explicit' pour éviter des conversions que tu n'anticiperaient pas :
Code:

1 2 3 String s1 = string("tutu");// Constructeur String(const char*) explicite. String s2 = "tutu"; // constructeur String(const char*) non explicite.
Ca évite de dupliquer ton code et donc de dupliquer d'éventuel bugs...