Discussion :

[bobosh]

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 :

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

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

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

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.

[3DArchi]

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 :

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

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

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 :

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

[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.

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

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

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?).

[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 C :

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

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...

[3DArchi]

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

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

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 !

[bobosh]

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

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

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

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

[Goten]

Relis la fin de son code.. il t'a bien donné un exemple générique sur les opérateurs d'affectation ;

[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 '='.

[3DArchi]

Salut,

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.

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

- String s4 = '?';

Merci encore de vos réponses

Pour

Code :

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

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 :

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

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

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...