c Synthèse des points clés de la revue n°7 - Surcharge des opérateurs

Surcharge des opérateurs
La soi-disant surcharge vise à donner un nouveau sens. La surcharge de fonctions consiste à donner une nouvelle signification à une fonction existante afin qu'elle puisse réaliser de nouvelles fonctions. Par conséquent, un nom de fonction peut être utilisé pour représenter des fonctions avec différentes fonctions, c'est-à-dire « un nom a plusieurs utilisations ». L'opérateur

peut également être surchargé. En fait, nous utilisons déjà la surcharge d’opérateurs sans même nous en rendre compte. Par exemple, tout le monde est habitué à utiliser l'opérateur d'addition "" pour additionner des nombres entiers, des nombres simple précision et des nombres double précision, tels que 5 8, 5,8 3,67, etc. les nombres de précision et les nombres à double précision sont Le processus est très différent, mais comme C a surchargé l'opérateur " ", il peut être appliqué aux opérations de type int, float et doUble.

Les opérandes des opérateurs prédéfinis en C ne peuvent être que des types de données de base. Mais en fait, des opérations similaires sont également requises pour de nombreux types définis par l'utilisateur (tels que les classes). À l’heure actuelle, ces opérateurs doivent être redéfinis en C et attribuer de nouvelles fonctions aux opérateurs existants afin qu’ils puissent être utilisés pour des types spécifiques afin d’effectuer des opérations spécifiques. L'essence de la surcharge d'opérateurs est la surcharge de fonctions, qui assure l'évolutivité du C et constitue l'une des fonctionnalités les plus attrayantes du C.

La surcharge de l'opérateur est obtenue en créant une fonction d'opérateur, qui définit l'opération que l'opérateur surchargé effectuera. La définition d'une fonction opérateur est similaire à la définition d'autres fonctions. La seule différence est que le nom de la fonction opérateur est composé du mot-clé opérateur et du symbole de l'opérateur à surcharger. Le format général de la définition de la fonction de l'opérateur est le suivant :

opérateur ()

{
     <函数体>
}

Surcharge de l'opérateur Les règles suivantes doit être suivi :

(1) En plus de l'opérateur de relation générique ".", de l'opérateur de pointeur de membre ".*", de l'opérateur de portée "::", de l'opérateur sizeof et de l'opération ternaire Sauf pour l'opérateur "? :", tous les opérateurs en C peuvent être surchargés.

(2) Les opérateurs surchargés sont limités aux opérateurs qui permettent la surcharge dans le cadre des opérateurs existants en langage C, et de nouveaux opérateurs ne peuvent pas être créés.

(3) La surcharge d'opérateurs est essentiellement une surcharge de fonctions, donc le choix du compilateur de surcharge d'opérateurs suit le principe de sélection de la surcharge de fonctions.

(4) Les opérateurs surchargés ne peuvent pas modifier la priorité et l'associativité de l'opérateur, ni le nombre d'opérandes et la structure syntaxique de l'opérateur.

(5) La surcharge d'opérateur ne peut pas changer la signification de l'opérateur pour les objets de type interne. Il ne peut être utilisé qu'avec des objets de types définis par l'utilisateur ou lorsque des objets de types définis par l'utilisateur et des objets de types internes sont mélangés.

(6) La surcharge d'opérateur est une transformation appropriée de l'opérateur d'origine basée sur les besoins réels de nouveaux types de données. La fonction surchargée doit être similaire à la fonction d'origine pour éviter d'utiliser des opérations surchargées sans but.

La surcharge de fonctions d'opérateur a généralement deux formes : la surcharge en tant que fonction membre de la classe et la surcharge en tant que fonction non membre de la classe. Les fonctions non membres sont généralement des amis. (Un opérateur peut être surchargé en tant que fonction non membre et non amie. Cependant, lorsqu'une telle fonction d'opérateur accède aux membres privés et protégés de la classe, elle doit utiliser les méthodes de définition des données et de lecture des données fournies dans l'interface publique. de la classe. Les performances seront réduites lors de l'appel de ces fonctions. Ces fonctions peuvent être intégrées pour améliorer les performances) Le format général de l'opérateur de fonction membre

est surchargé en tant que fonction membre. d'une classe :

Lorsqu'un opérateur est surchargé en tant que fonction membre d'une classe, le nombre de paramètres de la fonction est inférieur d'un à l'opérande d'origine (sauf pour le opérateur unaire post-fixé). En effet, le membre La fonction accède implicitement à un objet de la classe en utilisant ce pointeur, qui sert d'opérande le plus à gauche de la fonction opérateur. Par conséquent :

  <函数类型> operator <运算符>(<参数表>)
    {
     <函数体>
    }

(1) Lorsque l'opérateur binaire est surchargé en tant que fonction membre de la classe, la fonction n'indique explicitement qu'un seul paramètre, qui est l'opérande droit de l'opérateur.

(2) Lorsque l'opérateur unaire préfixé est surchargé en tant que fonction membre d'une classe, il n'est pas nécessaire d'indiquer explicitement les paramètres, c'est-à-dire que la fonction n'a pas de paramètres formels.

(3) Lorsque l'opérateur unaire post-fixé est surchargé en tant que fonction membre de la classe, la fonction doit avoir un paramètre formel entier.

Le format d'appel des opérateurs de fonctions membres est le suivant :

Il est équivalent à

    <对象名>.operator <运算符>(<参数>)

Par exemple : a b est équivalent à a.operator (b). En général, nous utilisons l'expression idiomatique des opérateurs.

    <对象名><运算符><参数>

Opérateur de fonction ami

Le format général de surcharge d'opérateur en tant que fonction ami d'une classe est :

Lors de l'utilisation Lorsque le symbole est surchargé en tant que fonction amie de la classe, puisqu'il n'y a pas de pointeur implicite, le nombre d'opérandes ne change pas. Tous les opérandes doivent être passés via les paramètres formels de la fonction. de gauche à droite.

    friend <函数类型> operator <运算符>(<参数表>)
    {
     <函数体>
    }

Le format pour appeler l'opérateur de la fonction ami est le suivant :

Il est équivalent à

  operator <运算符>(<参数1>,<参数2>)

Par exemple : a b est équivalent à l'opérateur (a,b).

    <参数1><运算符><参数2>

Comparaison de deux formulaires surchargés

　　在多数情况下，将运算符重载为类的成员函数和类的友元函数都是可以的。但成员函数运算符与友元函数运算符也具有各自的一些特点：

(1) 一般情况下，单目运算符最好重载为类的成员函数；双目运算符则最好重载为类的友元函数。

(2) 以下一些双目运算符不能重载为类的友元函数：=、()、[]、->。

(3) 类型转换函数只能定义为一个类的成员函数而不能定义为类的友元函数。

(4) 若一个运算符的操作需要修改对象的状态，选择重载为成员函数较好。

(5) 若运算符所需的操作数（尤其是第一个操作数）希望有隐式类型转换，则只能选用友元函数。

(6) 当运算符函数是一个成员函数时，最左边的操作数（或者只有最左边的操作数）必须是运算符类的一　个类对象（或者是对该类对象的引用）。如果左边的操作数必须是一个不同类的对象，或者是一个内部　类型的对象，该运算符函数必须作为一个友元函数来实现。

(7) 当需要重载运算符具有可交换性时，选择重载为友元函数。

1 为什么会用运算符重载机制（回忆函数重载）

         用复数类举例    //Complex c3 =c1 + c2;

         //原因 Complex是用户自定义类型，编译器根本不知道如何进行加减

         //编译器给提供了一种机制，让用户自己去完成，自定义类型的加减操作。。。。。

         //这个机制就是运算符重载机制

2 运算符重载的本质是一个函数

例如1:

//通过类成员函数完成 - 操作符重载（函数的定义在类里面）
//函数声明 Complex operator-(Complex &c2)
//用类成员函数实现-运算符重载
Complex c4 = c1 - c2; 
c4.printCom(); //打印输出
//c1.operator-(c2);

例如2:

//通过全局函数方法完成+操作符重载（函数的定义在类外）
//函数声明 Complex operator+(Complex &c1, Complex &c2)
//函数调用分析
int main()
{ Complex c1(1, 2), c2(3, 4);//定义两个对象
//Complex c31 = operator+(c1,c2); 函数的调用模式
Complex c3 = c1 + c2; //简写+
c3.printCom();
}

感受操作过程：

例如3：

//前置++操作符 用全局函数实现
Complex& operator++(Complex&c1) 
{ c1.a ++; 
c1.b ++;
return c1; 
}
//调用方法
++c1 ; //=è需要写出操作符重载函数原形
c1.printCom();
//运算符重载函数名定义
//首先承认操作符重载是一个函数 定义函数名--->operator++
//分析函数参数 根据左右操作数的个数------->operator++(Complex &c1)
//分析函数返回值-------> Complex&operator++(Complex &c1) 返回它自身

例如4

//4.1 前置—操作符成员函数实现
Complex& operator--()
{ this->a--;
this->b--;
return *this; //注意返回
}
//4.2 调用方法
--c1;
c1.printCom();
//4.3前置—运算符重载函数名定义
//c1.operator--()

例如5：

//5.1//后置++ 操作符用全局函数实现
Complex operator++(Complex &c1, int) 
{ Complex tmp = c1;
c1.a++;
c1.b++;
return tmp;
}
//5.2 调用方法
c1 ++ ; //先使用后++
//5.3 后置++运算符重载函数名定义
Complex operator++(Complex&c1, int) //函数占位参数 和 前置++ 相区别

例如6：

//6.1 后置— 操作符 用类成员函数实现
Complexoperator--(int) 
{ Complextmp = *this;
this->a--;
this->b--;
return tmp;
}
//6.2 调用方法
c1 ++ ; //先使用后++
//6.3 后置--运算符重载函数名定义
Complex operator--(int) //函数占位参数和 前置-- 相区别

前置和后置运算符总结

C++中通过一个占位参数来区分前置运算和后置运算

定义运算符重载函数名的步骤

全局函数、类成员函数方法实现运算符重载步骤

1）要承认操作符重载是一个函数，写出函数名称operator+ () 

2）根据操作数，写出函数参数 

3）根据业务，完善函数返回值(看函数是返回引用 还是指针 元素)，及实现函数业务

友元函数实现操作符重载的应用场景

1）友元函数和成员函数选择方法 
Ø 当无法修改左操作数的类时，使用全局函数进行重载
Ø =, [], ()和->操作符只能通过成员函数进行重载
2）用友元函数重载 << >>操作符
Ø istream 和 ostream 是 C++ 的预定义流类 
Ø cin 是 istream 的对象，cout 是 ostream 的对象
Ø 运算符 << 由ostream 重载为插入操作，用于输出基本类型数据
Ø 运算符 >> 由 istream 重载为提取操作，用于输入基本类型数据
Ø 用友员函数重载 << 和 >> ，输出和输入用户自定义的数据类型
a）用全局函数方法实现 << 操作符 
ostream& operator<<(ostream &out, Complex &c1)
{ //out<<"12345，生活真是苦"<<endl;
out<<c1.a<<"+ "<<c1.b<<"i "<<endl;
return out;
}
//调用方法
cout<<c1;
//链式编程支持
cout<<c1<<"abcc";
//cout.operator<<(c1).operator<<("abcd");
//函数返回值充当左值 需要返回一个引用
b）类成员函数方法无法实现 <<操作符重载
//因拿到cout这个类的源码
//cout.operator<<(c1);
3） 友元函数重载操作符使用注意点
a） 友员函数重载运算符常用于运算符的左右操作数类型不同的情况
b）其他
Ø 在第一个参数需要隐式转换的情形下，使用友员函数重载运算符是正确的选择
Ø 友员函数没有 this 指针，所需操作数都必须在参数表显式声明，很容易实现类型的隐式转换
Ø C++中不能用友员函数重载的运算符有
= （） ［］ －>

请问：为什么运算法重载成员函数只有一个参数，而友元函数有两个？

由于成员函数有指向对象的this指针，可以通过对象传递参数；而友元函数没有this指针，所以必须要两个参数。（针对二元操作符重载而言）

以上就是c++复习要点总结之七——运算符重载的内容，更多相关内容请关注PHP中文网（www.php.cn）！