IdentifiantMot de passe
Loading...
Mot de passe oublié ?Je m'inscris ! (gratuit)
Navigation

Inscrivez-vous gratuitement
pour pouvoir participer, suivre les réponses en temps réel, voter pour les messages, poser vos propres questions et recevoir la newsletter

 C++ Discussion :

Problème opérateur affection


Sujet :

C++

  1. #1
    Membre éclairé
    Profil pro
    Inscrit en
    Juillet 2008
    Messages
    298
    Détails du profil
    Informations personnelles :
    Localisation : France

    Informations forums :
    Inscription : Juillet 2008
    Messages : 298
    Par défaut Problème opérateur affection
    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.

  2. #2
    Rédacteur
    Avatar de 3DArchi
    Profil pro
    Inscrit en
    Juin 2008
    Messages
    7 634
    Détails du profil
    Informations personnelles :
    Localisation : France

    Informations forums :
    Inscription : Juin 2008
    Messages : 7 634
    Par défaut
    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);
    }

  3. #3
    Membre Expert
    Avatar de Goten
    Profil pro
    Inscrit en
    Juillet 2008
    Messages
    1 580
    Détails du profil
    Informations personnelles :
    Âge : 34
    Localisation : France

    Informations forums :
    Inscription : Juillet 2008
    Messages : 1 580
    Par défaut
    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.

  4. #4
    Rédacteur
    Avatar de 3DArchi
    Profil pro
    Inscrit en
    Juin 2008
    Messages
    7 634
    Détails du profil
    Informations personnelles :
    Localisation : France

    Informations forums :
    Inscription : Juin 2008
    Messages : 7 634
    Par défaut
    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?).

  5. #5
    Expert éminent
    Avatar de Médinoc
    Homme Profil pro
    Développeur informatique
    Inscrit en
    Septembre 2005
    Messages
    27 395
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 41
    Localisation : France

    Informations professionnelles :
    Activité : Développeur informatique
    Secteur : High Tech - Éditeur de logiciels

    Informations forums :
    Inscription : Septembre 2005
    Messages : 27 395
    Par défaut
    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...
    SVP, pas de questions techniques par MP. Surtout si je ne vous ai jamais parlé avant.

    "Aw, come on, who would be so stupid as to insert a cast to make an error go away without actually fixing the error?"
    Apparently everyone.
    -- Raymond Chen.
    Traduction obligatoire: "Oh, voyons, qui serait assez stupide pour mettre un cast pour faire disparaitre un message d'erreur sans vraiment corriger l'erreur?" - Apparemment, tout le monde. -- Raymond Chen.

  6. #6
    Rédacteur
    Avatar de 3DArchi
    Profil pro
    Inscrit en
    Juin 2008
    Messages
    7 634
    Détails du profil
    Informations personnelles :
    Localisation : France

    Informations forums :
    Inscription : Juin 2008
    Messages : 7 634
    Par défaut
    Citation Envoyé par Médinoc Voir le message
    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 !

  7. #7
    Membre éclairé
    Profil pro
    Inscrit en
    Juillet 2008
    Messages
    298
    Détails du profil
    Informations personnelles :
    Localisation : France

    Informations forums :
    Inscription : Juillet 2008
    Messages : 298
    Par défaut
    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

  8. #8
    Membre Expert
    Avatar de Goten
    Profil pro
    Inscrit en
    Juillet 2008
    Messages
    1 580
    Détails du profil
    Informations personnelles :
    Âge : 34
    Localisation : France

    Informations forums :
    Inscription : Juillet 2008
    Messages : 1 580
    Par défaut
    Relis la fin de son code.. il t'a bien donné un exemple générique sur les opérateurs d'affectation ;

  9. #9
    Alp
    Alp est déconnecté
    Expert confirmé

    Avatar de Alp
    Homme Profil pro
    Inscrit en
    Juin 2005
    Messages
    8 575
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 36
    Localisation : France, Bouches du Rhône (Provence Alpes Côte d'Azur)

    Informations forums :
    Inscription : Juin 2005
    Messages : 8 575
    Par défaut
    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 '='.

  10. #10
    Rédacteur
    Avatar de 3DArchi
    Profil pro
    Inscrit en
    Juin 2008
    Messages
    7 634
    Détails du profil
    Informations personnelles :
    Localisation : France

    Informations forums :
    Inscription : Juin 2008
    Messages : 7 634
    Par défaut
    Salut,
    Citation Envoyé par bobosh Voir le message
    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 Voir le message
    -si vous pouvez m'accorder un peux plus de temp pour pouvoir effectuer ceci :

    - String s4 = '?';

    Merci encore de vos réponses
    Pour
    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...

Discussions similaires

  1. problème d'affectation
    Par Nelmo dans le forum MFC
    Réponses: 8
    Dernier message: 04/05/2006, 14h29
  2. Réponses: 3
    Dernier message: 04/04/2006, 09h39
  3. Problème d'affectation de variable
    Par bob33 dans le forum C
    Réponses: 3
    Dernier message: 04/11/2005, 17h01
  4. problème d'affectation de tableau ...
    Par Mike888 dans le forum C
    Réponses: 23
    Dernier message: 26/02/2005, 14h52
  5. Entier 64 bits sous linux, problème d'affectation
    Par Steki-kun dans le forum Linux
    Réponses: 2
    Dernier message: 13/01/2005, 21h10

Partager

Partager
  • Envoyer la discussion sur Viadeo
  • Envoyer la discussion sur Twitter
  • Envoyer la discussion sur Google
  • Envoyer la discussion sur Facebook
  • Envoyer la discussion sur Digg
  • Envoyer la discussion sur Delicious
  • Envoyer la discussion sur MySpace
  • Envoyer la discussion sur Yahoo