1
votes

Comprendre l'opérateur booléen == (paramètre 1, paramètre 2)

opérateur booléen == (str_array a, str_array b)

Où str_array est une structure pour mon devoir. Que signifie cette notation, comment cela devra-t-il être pris en compte lorsque j'implémentera la fonction, et comment l'appeler une fois que j'ai terminé (comme pour les appels de fonction normaux?)

C'est la première fois que vous voyez cette notation. L'implémentation est une simple comparaison entre deux variables str_array (je sais comment implémenter cela sans la notation bizarre)

c++ operator-overloading

0 commentaires

4 Réponses :

1
votes

Lorsque vous faites quelque chose comme (où a et b sont str_array)

if (a == b) { // ...

Cette fonction sera appelée.

operator == est le nom de la fonction qui utilise les appels == . Vous êtes censé renvoyer true si les arguments sont égaux.

0 commentaires

2
votes

Comment puis-je l'appeler lorsque j'ai terminé?

Comme vous avez défini un opérateur , alors il n'est pas appelé comme une fonction «normale»! Il peut plutôt être utilisé comme un opérateur «normal»:
bool operator==(str_array a, str_array b) {
    bool answer;
    //..
    // some code that sets "answer" according to the (in)equality of a and b
    //
    return answer;
}
La mise en œuvre ressemblera cependant à une fonction normale:
str_array sa1;
str_array sa2;
//.. some code
if (sa1 == sa2) { // Here, you are calling the == OPERATOR that you've defined
    //.. do something
}

0 commentaires

0
votes

Il s'agit d'une surcharge d'opérateurs . Vous créez une surcharge de l'opérateur == qui accepte un objet str_array de chaque côté de l'opérateur:

str_array a1;
str_array a2;
...
if (a1 == a2)
    do_something();

0 commentaires

0
votes

Cette fonction

a1 = 10
a2 = 10
a3 = 20
a1 == a2 is true
a2 == a3 is false
a1 == a2 is true

introduit un opérateur d'égalité surchargé (operator ==) pour les objets de type str_array.

Vous pouvez donc comparez deux objets du type comme vous le faites avec des types fondamentaux comme par exemple

#include <iostream>
#include <iomanip>

class A
{
public:
    explicit A( int x = 0 ) : x( x ) {}

    friend bool operator ==( const A &a1, const A &a2 )
    {
        return a1.x == a2.x;
    }

    friend std::ostream & operator <<( std::ostream &os, const A &a )
    {
        return os << a.x;
    }

private:
    int x;
};

int main() 
{
    A a1( 10 ), a2( 10 ), a3( 20 );

    std::cout << "a1 = " << a1 << '\n';
    std::cout << "a2 = " << a2 << '\n';
    std::cout << "a3 = " << a3 << '\n';

    std::cout << "a1 == a2 is " << std::boolalpha << ( a1 == a2 ) << '\n';
    std::cout << "a2 == a3 is " << std::boolalpha << ( a2 == a3 ) << '\n';
    std::cout << "a1 == a2 is " << std::boolalpha << operator ==( a1, a2 ) << '\n';

    return 0;
}

Le compilateur remplacera l'expression a == b pour un appel de l'opérateur surchargé == (fonction).

Voici un programme démonstratif avec deux opérateurs surchargés: operator == et operator .

if ( a == b ) { /* do something */ }

Sa sortie est

bool operator==(str_array a, str_array b);

0 commentaires