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

Langage C++ Discussion :

[operator] probleme seulement sous linux gcc 4.4.6


Sujet :

Langage C++

Vue hybride

Message précédent Message précédent   Message suivant Message suivant
  1. #1
    Membre Expert
    Profil pro
    Inscrit en
    Juillet 2008
    Messages
    1 562
    Détails du profil
    Informations personnelles :
    Localisation : France

    Informations forums :
    Inscription : Juillet 2008
    Messages : 1 562
    Par défaut [operator] probleme seulement sous linux gcc 4.4.6
    Bonjour

    j'aimerais trouver une solution au problème suivant
    en effet je peux pas changer de compilateur et j'ai fait des test avec visual studio (avec le même code) et ça passe

    bref j'ai une classe :
    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
     
    class Zota {
    	float value;
    public:
    	float getValue() {
    		return this->value;
    	}
    	explicit Zota(float value) :
    			value(value) {
    	}
    	virtual Zota operator+(Zota &ob) {
    		return Zota(this->getValue() + ob.getValue());
    	}
    	virtual Zota operator+(double ob) {
    		return Zota(this->getValue() + ob);
    	}
    	virtual Zota operator*(Zota &ob) {
    		return Zota(this->getValue() * ob.getValue());
    	}
     
    	virtual string toString() {
    		return to_string((long long)this->value);
    	}
    };
    et j'execute le code suivant
    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
     
    cout << endl << "* test beta (ref)" << endl;
    		Zota a(2);
    		Zota b(3);
    		Zota c(5);
    		{
    			Zota d = a + b + c;
    			cout << " a + b + c = " << d.toString() << endl;
    		}
    		{
    			Zota d = a + 10;
    			cout << " a + 10 = " << d.toString() << endl;
    		}
    //		{
    //			Zota d = 11 + a;
    //			cout << " 11 + a = " << d.toString() << endl;
    //		}
    		{
    			Zota d = a * b;
    			cout << " a * b = " << d.toString() << endl;
    		}
    		{
    			Zota d = (a * b) + c;   // CA PASSE
    			cout << " (a * b) + c = " << d.toString() << endl;
    		}
    		{
    			Zota d = c + (a * b); // CA COMPILE PAS
    			cout << " c + (a * b) = " << d.toString() << endl;
    		}
    bref (a * b) + c ca passe et
    c + (a *b) ca compile pas avec l'erreur suivante :
    error: no match for ‘operator+’ in ‘c + Zota::operator*(((Zota&)(& b)))’

    si vous avez une idée de la solution possible

    merci

  2. #2
    Membre Expert

    Homme Profil pro
    Ingénieur développement logiciels
    Inscrit en
    Août 2004
    Messages
    1 391
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 35
    Localisation : France, Doubs (Franche Comté)

    Informations professionnelles :
    Activité : Ingénieur développement logiciels

    Informations forums :
    Inscription : Août 2004
    Messages : 1 391
    Par défaut
    Ca ne compile pas car tu retournes un temporaire et que ton opérateur d'adition utilise une simple référence, or un temporaire ne peut être attaché à une simple référence.

    Une remarque plus générale, sauf dans certaines situation, la forme canonique des opérateurs binaires symétriques, c'est une fonction libre avec prise par référence constante :
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
     
    Zota operator+(const Zota& lhs, const Zota& rhs) {
      Zota ret=lhs;
      ret+=rhs;
      return ret;
    }
    Et en fonction membre tu codes :
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
     
    struct Zota {
      Zota& operator+=(const Zota& rhs) {
        //stuff
        return *this;
      }
    };

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

    Informations forums :
    Inscription : Juillet 2008
    Messages : 1 562
    Par défaut
    ok en effet ca règle le problème de compilation toutefois je vois pas ce qu'il faut mettre
    dans
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
     
    	Zota& operator+=(const Zota& rhs) {		
    		//stuff
    		return *this;
    	}
    	Zota& operator*=(const Zota& rhs) {
    		//stuff
    		return *this;
    	}
    si je suis ton principe en faisant
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
     
    Zota operator+(const Zota& lhs, const Zota& rhs) {
    	Zota ret = lhs;
    	ret += rhs;
    	return ret;
    }
    Zota operator*(const Zota& lhs, const Zota& rhs) {
    	Zota ret = lhs;
    	ret *= rhs;
    	return ret;
    }

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

    Informations forums :
    Inscription : Juillet 2008
    Messages : 1 562
    Par défaut
    j'ai fait ca
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
     
    Zota& operator+=(const Zota& rhs) {
    		float x = rhs.getValue();
    		this->value = this->value + x;
    		//stuff
    		return *this;
    	}
    	Zota& operator*=(const Zota& rhs) {
    		float x = rhs.getValue();
    		this->value = this->value  * x;
    		//stuff
    		return *this;
    	}
    en corrigeant
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    
    float getValue() const {
    		return this->value;
    	}

  5. #5
    Membre Expert

    Homme Profil pro
    Ingénieur développement logiciels
    Inscrit en
    Août 2004
    Messages
    1 391
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 35
    Localisation : France, Doubs (Franche Comté)

    Informations professionnelles :
    Activité : Ingénieur développement logiciels

    Informations forums :
    Inscription : Août 2004
    Messages : 1 391
    Par défaut
    Ce qui correspond à ton opération, a+=b pour les types fondamentaux, c'est comme faire a=a+b, dans ton cas ça donne :
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
     
    Zota& operator+=(const Zota& rhs) {		
    	value+=rhs.value; //inutile d'utilise this et getValue
    	return *this;
    }
    Zota& operator*=(const Zota& rhs) {
    	value*=rhs.value; //inutile d'utilise this et getValue
    	return *this;
    }

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

    Informations forums :
    Inscription : Juillet 2008
    Messages : 1 562
    Par défaut
    merci je suis passé par une autre écriture pour régler les problèmes des formules
    type :
    • 11 + gamma
    • gamma + 11
    • etc etc ....


    voici ce que ca donne (j'ai changé le nom de la classe)
    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
     
    class Gamma {
    	float value;
    public:
    	float getValue() const {
    		return value;
    	}
    	virtual string toString() {
    		return to_string((long long)value);
    	}
    	Gamma(float value) :
    			value(value) {
    	}
    	Gamma& operator+(const Gamma& rhs) {
    		value += rhs.value;
    		//cout << " - operateur+ = " << value << endl;
    		return *this;
    	}
    	Gamma& operator+(const double ob) {
    		value += ob;
    		//cout << " - operateur+(double) = " << value << endl;
    		return *this;
    	}
    	Gamma& operator*(const Gamma& rhs) {
    		value *= rhs.value;
    		//cout << " - operateur* = " << value << endl;
    		return *this;
    	}
    };
    Gamma operator+(const double ob, const Gamma& rhs) {
    	Gamma ret = rhs;
    	ret = ret + ob;
    	return ret;
    }
    tu en pense quoi ?

  7. #7
    Membre Expert

    Homme Profil pro
    Ingénieur développement logiciels
    Inscrit en
    Août 2004
    Messages
    1 391
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 35
    Localisation : France, Doubs (Franche Comté)

    Informations professionnelles :
    Activité : Ingénieur développement logiciels

    Informations forums :
    Inscription : Août 2004
    Messages : 1 391
    Par défaut
    Que tu n'as pas suivi ce que j'ai marqué avant, donc je ne risque pas d'être d'accord
    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
     
    #include<iostream>
     
    struct Gamma {
    	Gamma(const float& value) : value(value) {}
     
    	Gamma& operator+=(const Gamma& rhs) {
    		value += rhs.value;
    		return *this;
    	}
    	Gamma& operator*=(const Gamma& rhs) {
    		value *= rhs.value;
    		return *this;
    	}
     
    	friend std::ostream& operator<<(std::ostream& os, const Gamma& gamma) {
    		os << gamma.value;
    		return os;
    	}
    	friend std::istream& operator>>(std::istream& is, Gamma& gamma) {
    		is >> gamma.value;
    		return is;
    	}
     
    private:
    	float value;
    };
     
    Gamma operator+(const Gamma& lhs, const Gamma& rhs) {
    	Gamma ret=rhs;
    	ret+=rhs;
    	return ret;
    }
    Gamma operator*(const Gamma& lhs, const Gamma& rhs) {
    	Gamma ret=rhs;
    	ret*=rhs;
    	return ret;
    }
     
    int main()
    {
    	Gamma gamma=1;
    	std::cout << gamma+1 << 1*gamma << std::endl;
    }
    Je ne sais pas à quoi va servir ta classe par contre.

+ Répondre à la discussion
Cette discussion est résolue.

Discussions similaires

  1. probleme( java sous linux): No X11 DISPLAY variable was set
    Par forum92 dans le forum Débuter avec Java
    Réponses: 5
    Dernier message: 21/03/2009, 13h51
  2. Réels aléatoires sous Linux(GCC)
    Par rhani-sama dans le forum Linux
    Réponses: 3
    Dernier message: 31/01/2008, 20h22
  3. probleme ExternalInterface sous linux
    Par Jérémy Lefevre dans le forum Intégration
    Réponses: 2
    Dernier message: 20/06/2007, 12h02
  4. Réponses: 14
    Dernier message: 09/08/2004, 13h42
  5. Problemes de compilation avec g++ sous linux
    Par Selimmel dans le forum Autres éditeurs
    Réponses: 3
    Dernier message: 19/09/2003, 13h43

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