C surcharge opérateur de (facile à comprendre)

la surcharge de l'opérateur, l'opérateur existant est redéfinie, lui donnant une autre fonction, pour accueillir différents types de données.

Vous pouvez redéfinir ou remplacer la plupart des opérateurs C ++ intégré. Par exemple, +, -, *, /,

++, -, >>, << et ainsi de suite, de sorte que vous pouvez utiliser pour personnaliser le type de l'opérateur.

Le format de base de la surcharge des opérateurs

Opérateur est surchargé avec le nom de fonction spéciale, le nom de la fonction est un opérateur clé et

Par la suite, l'opérateur de symboles de remplacement. Comme avec d'autres fonctions, la surcharge opérateur une

Un type de retour et la liste des paramètres.

opérateur point + (const Point &);

Opérateur surcharge de deux manières: l'une est (fonctions membres en fonction de la classe de surcharge de l'opérateur) classe l'emporte sur l'autre est (une fonction amie en fonction de l'opérateur surcharge et similaires) en dehors de la classe des surcharges

Dans les remplacements de classe

#include <iostream>
using namespace std;

class Point{
public:
    Point(){};
    Point (int x, int y): x(x),y(y) {};
    Point operator+(const Point &a){ //类内重载，运算符重载函数作为类的成员函数
        Point ret;
        ret.x = this->x + a.x;
        ret.y = this->y + a.y;
        return ret;
    }
    int x,y;
};

int main() {
    Point a(2,4),b(5,3);
    Point c = a + b;
    cout<< "x :" << c.x << endl;
    cout<<"y :" << c.y << endl;
}

Lorsque le code ci-dessus est compilé et exécuté, il produit les résultats suivants:

x: 7

et 7

la surcharge d'opérateur de surcharge est la classe, en fonction de la fonction de membre de surcharge opérateur, le code ci - dessus , par exemple , a + b + correspond à l'objet appelle un procédé et transmettre des paramètres b Object

en dehors de la classe robuste

#include <iostream>
using namespace std;

class Point{
public:
    Point(){};
    Point (int x, int y): x(x),y(y) {};
    friend Point operator+(const Point &, const Point &);
    int x,y;
};

Point operator+(const Point &a,const Point &b){//类外重载,运算符重载函数作为类的友元函数
    Point ret;
    ret.x = a.x + b.x;
    ret.y = a.y + b.y;
    return ret;
}

int main() {
     Point a(2,4),b(5,3);
    Point c = a + b;
    cout<< "x :" << c.x << endl;
    cout<<"y :" << c.y << endl;
}

Lorsque le code ci-dessus est compilé et exécuté, il produira les mêmes résultats que ci-dessus

Des exemples de divers surcharge d'opérateur

L'exemple de code suivant illustre la surcharge des différents opérateurs, plusieurs surcharge des opérateurs de présentation de base.

L'insertion de l'opérateur >> et << extraction surcharge d'opérateur

Pour extraire la surcharge de l' opérateur <<, par exemple, coutil est la ostreamclasse d'objet. ostreamClasse et coutsont dans le fichier d' en- tête <iostream>déclaration. ostreamClasse sera <<surchargée en fonction de membre.

nous remplaçons ici l' <<utilisation de coutsortie cible

#include <iostream>
using namespace std;

class Point{
public:
    Point(){};
    Point (int x, int y): x(x),y(y) {};
    friend Point operator+(const Point &, const Point &);
    friend ostream &operator<<(ostream &out , const Point &a);
private:
    int x,y;
};

Point operator+(const Point &a,const Point &b){
    Point ret;
    ret.x = a.x + b.x;
    ret.y = a.y + b.y;
    return ret;
}

ostream &operator<<(ostream &out , const Point &a){
    out << "<Point>( " << a.x << ", " << a.y << ")";
    return out;
}

int main() {
    Point a(2,4),b(5,3);
    Point c = a + b;
    cout << c<< endl;
}

Lorsque le code ci-dessus est compilé et exécuté, il produit les résultats suivants:

<Point> (7, 7)

Note: surcharge <<, la classe est surchargée en dehors, il est d' usage que les gens utilisent cin>>et cout<<, et doivent utiliser une fonction ami aux opérateurs de surcharge, si la fonction membre surchargée de se produire c<<cout;ce code naturel.

Aussi quelqu'un doit ostream &operator<<(ostream &out , const Point &a)fonctionner se demander, d' abord en surcharge <<, le type de valeur de retour est ostream&, le premier paramètre est ostream&. En d' autres termes, l'expression cout<<cde la valeur de retour est encore cout, il cout<<c<<endl;peut être établi

avant la surcharge de l'opérateur et à l'arrière ++ ++ surcharge d'opérateur

 #include <iostream>
using namespace std;

class Point{
public:
    Point(){};
    Point (int x, int y): x(x),y(y) {};
    friend Point operator+(const Point &, const Point &);
    friend ostream &operator<<(ostream &out , const Point &a);
    Point& operator++(){ //前置运算符，需要引用返回，不需要参数。返回自增后的值，且返回的是一个左值 
        x++;
        y++;
        return *this;
    }

    const Point operator++(int){//后置++，不需要引用返回，需要参数区分。返回自增前的值，且返回的是一个右值
        Point temp(x,y);
        x++;
        y++;
        return temp;
    }
private:
    int x,y;
};

Point operator+(const Point &a,const Point &b){
    Point ret;
    ret.x = a.x + b.x;
    ret.y = a.y + b.y;
    return ret;
}

ostream &operator<<(ostream &out , const Point &a){
    out << "<Point>(" << a.x << " , " << a.y << ")";
    return out;
}


int main() {
    Point a(2,4),b(5,3);
    Point c = a + b;
    cout << c << endl;
    c++;
    cout << c << endl;
    ++c;
    cout << c << endl;
}

Lorsque le code ci-dessus est compilé et exécuté, il produit les résultats suivants:

(7, 7)
<Point> (8, 8)
<Point> (9, 9)

1> est une différence entre avant et arrière opérateurs, besoin d'ajouter le paramètre « int » dans les fonctions de surcharge opérateur arrière, bien que le type ici, sauf pour montrer la différence ne représente pas un sens réel;

2> retourne la variable de référence avant, le retour arrière est constante. Alors ++++ c légitime et c ++++ pas légitime;

3> c ++++ Pourquoi ne pas laisser ce soit légal? Si vous voulez atteindre c ++++ légitime, vous devez retourner à l'ensemble des variables ou des références variables. c ++ c la valeur est de revenir +1, il est impossible de revenir à c, il faut d'abord établir une variable locale pour maintenir la valeur initiale c, puis revenir à des variables locales (variables locales ne permettent pas renvoie une référence), mais renvoie une variable locale après cela, si remembrés à la fois ++ opérateur, est impliqué dans le calcul de la valeur d'une variable locale, dans ce cas c ++++ fait équivalent à c ++, il n'y aurait pas de sens.