Remplacement d'un opérateur à l'aide de const pour les deux paramètres en C ++

Question

J'essaie de créer une fonction d'opérateur substituée à l'aide des deux paramètres const, mais je ne vois pas comment le faire. Voici un exemple simple:

class Number
{
    Number()
    {
        value = 1;
    };

    inline Number operator + (const Number& n)
    {
        Number result;

        result.value = value + n.value;
        return result;
    }

    int value;
}

Ce que j'essaie de faire ici est de passer deux arguments à la fonction d’addition qui sont tous deux constants et de renvoyer le résultat sans rien changer à la classe:

const Number a = Number();
const Number b = Number();
Number c = a + b;

Est-ce possible et comment pourrais-je m'y prendre?

Merci,

Dan

Answer 1

inline est compris dans les déclarations de classe, vous n'avez donc pas besoin de le spécifier.

De manière idiomatique, vous feriez de opérateur + une fonction non membre déclarée en dehors de la définition de la classe, comme ceci:

Number operator+( const Number& left, const Number& right );

Vous devrez peut-être en faire un ami de la classe si elle a besoin d'accéder aux éléments internes de Number .

Si vous devez l'avoir en tant que fonction membre, vous devez faire la fonction elle-même:

Number operator+( const Number& n ) const
{ // ...

Pour des classes telles que Number , l'opérateur + est généralement implémenté en termes d'opérateur + = , car vous souhaitez généralement que tous les opérateurs habituels fonctionnent comme prévu. et opérateur + = est généralement plus facile à implémenter et opérateur + tend à ne perdre en efficacité aucune efficacité si on l'implémentait séparément.

Dans la classe:

Number& operator+=( const Number& n );

En dehors de la classe:

Number operator+( const Number& left, const Number& right )
{
    return Number( left ) += right;
}

ou même:

Number operator+( Number left, const Number& right )
{
    return left += right;
}

Answer 2

class Number
{
    Number()
    {
        value = 1;
    };

    inline Number operator + (const Number& n) const
    {
        Number result;

        result = value + n.value;
        return result;
    }

    int value;
}

Answer 3

Que diriez-vous de:

inline Number operator + (const Number& n) const

Answer 4

Même si j’estime que les réponses précédentes sont suffisantes, je pense qu’il faut apporter des éclaircissements.

Les opérateurs viennent (généralement) de deux manières

La première étant les fonctions non membres, la seconde étant la fonction membre dont le paramètre est "l'opérande droit". de l'opération et qui renvoie généralement l'objet modifié actuel.

Par exemple, imaginons un opérateur § pour une classe T . Il pourrait être écrit sous forme de fonction non membre :

T operator § (const T & lhs, const T & rhs)
{
   T result ;
   // do the lhs § rhs operation, and puts the result into "result"
   return result ;
}

ou en tant que fonction membre :

T & T::operator § (const T & rhs)
{
   // do the "this § rhs" operation, and puts the result into "this"
   return *this ;
}

ou même (très inhabituellement) comme une autre fonction membre :

T T::operator § (const T & rhs) const
{
   T result ;
   // do the "this § rhs" operation, and puts the result into "result"
   return result ;
}

Généralement, vous devriez préférer la fonction non-membre, ne serait-ce que parce que vous ne devriez pas la déclarer amie. Ainsi, l’utilisation de la fonction non membre non ami améliore l’encapsulation de votre objet.

Clause de non-responsabilité: il existe d'autres variantes, mais je me limite à des opérateurs arithmétiques tels que + , * , / , - , etc. ici, ainsi que "crédible". prototypes d'opérateurs.

Analysez votre utilisation de l'opérateur

Dans le cas de + :

1. Chaque opérande doit être constant car a = b + c ne doit pas changer b , ni c .
2. Vous pouvez accumuler + , comme dans a = b + c + d + e , de sorte que des temporaires doivent exister.

T & T::operator += (const T & rhs)
{
   // do the "this § rhs" operation, and puts the result into "this"
   return *this ;
}

Dans le cas de + = :

1. Vous savez que l'opérande gauche A (de A + = B) sera modifié.
2. Vous savez que l'opérande gauche A (de A + = B) est son propre résultat.

Vous devriez donc utiliser:

T & operator + (const T & lhs, const T & rhs)
{
   static T result ; // result is STATIC !!!!
   // do the lhs + rhs operation, and puts the result into "result"
   return result ;
}

Comme toujours, l'optimisation prématurée est la racine de tous les maux

J'ai vu ce type de code dans le code de production, donc il se produit :

<*>

L’auteur espérait en économiser un temporaire. Avec ce type de code, écrire a = b + c + d conduit à des résultats intéressants (et erronés).

^ _ ^

Dernier mais non le moindre

J'ai écrit une liste de prototypes de surcharge d'opérateurs sur cette page . La page est encore en construction, mais son utilisation principale (facile à copier / coller des prototypes fonctionnels) peut être très utile ...