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 !