Zusammenfassung der wichtigsten Punkte der C++-Überprüfung Nr. 7 – Operatorüberladung

Operator-Überladung
Die sogenannte Überladung soll eine neue Bedeutung geben. Bei der Funktionsüberladung geht es darum, einer vorhandenen Funktion eine neue Bedeutung zu geben, damit sie neue Funktionen erreichen kann. Daher kann ein Funktionsname zur Darstellung von Funktionen mit unterschiedlichen Funktionen verwendet werden, d. h. „ein Name hat mehrere Verwendungszwecke“. Der

-Operator kann auch überladen sein. Tatsächlich nutzen wir bereits die Operatorüberladung, ohne es überhaupt zu merken. Beispielsweise ist jeder daran gewöhnt, den Additionsoperator „+“ zu verwenden, um ganze Zahlen, Zahlen mit einfacher und doppelter Genauigkeit wie 5+8, 5,8 +3,67 usw. zu addieren. Tatsächlich können Computer ganze Zahlen mit einfacher Genauigkeit addieren -Präzisionszahlen und Zahlen mit doppelter Genauigkeit sind sehr unterschiedlich, aber da C++ den Operator „+“ überladen hat, kann er auf Operationen der Typen int, float und doUble angewendet werden.

Die Operanden vordefinierter Operatoren in C++ können nur Basisdatentypen sein. Tatsächlich sind ähnliche Operationen aber auch für viele benutzerdefinierte Typen (z. B. Klassen) erforderlich. Zu diesem Zeitpunkt müssen diese Operatoren in C++ neu definiert und den vorhandenen Operatoren neue Funktionen zugewiesen werden, damit sie für bestimmte Typen zum Ausführen bestimmter Operationen verwendet werden können. Der Kern der Operatorüberladung ist die Funktionsüberladung, die die Skalierbarkeit von C++ bietet und eine der attraktivsten Funktionen von C++ darstellt.

Operatorüberladung wird durch die Erstellung von Operatorfunktionen erreicht, die die Operationen definieren, die der überlastete Operator ausführen wird. Die Definition einer Operatorfunktion ähnelt der Definition anderer Funktionen. Der einzige Unterschied besteht darin, dass der Funktionsname der Operatorfunktion aus dem Schlüsselwort Operator und dem zu überladenden Operatorsymbol besteht. Das allgemeine Format der Operatorfunktionsdefinition lautet wie folgt:

Operator ()

{
     <函数体>
}

Operatorüberladung Die folgenden Regeln muss befolgt werden:

(1) Zusätzlich zum generischen Beziehungsoperator „.“, Mitgliedszeigeroperator „.*“, Bereichsoperator „::“, Sizeof-Operator und ternärer Operation Außer dem Operator „? :“, alle Operatoren in C++ können überladen werden.

(2) Überladene Operatoren sind auf die Operatoren beschränkt, die eine Überladung im Rahmen vorhandener Operatoren in der Sprache C++ ermöglichen, und neue Operatoren können nicht erstellt werden.

(3) Bei der Überladung von Operatoren handelt es sich im Wesentlichen um eine Funktionsüberladung. Daher folgt die Wahl der Operatorüberladung durch den Compiler dem Auswahlprinzip der Funktionsüberladung.

(4) Überladene Operatoren können weder die Priorität und Assoziativität des Operators noch die Anzahl der Operanden und die Syntaxstruktur des Operators ändern.

(5) Eine Operatorüberladung kann die Bedeutung des Operators für interne Typobjekte nicht ändern. Es kann nur mit Objekten benutzerdefinierter Typen verwendet werden oder wenn Objekte benutzerdefinierter Typen und Objekte interner Typen gemischt werden.

(6) Das Überladen von Operatoren ist eine geeignete Transformation des ursprünglichen Operators basierend auf den tatsächlichen Anforderungen neuer Datentypen. Die überladene Funktion sollte der ursprünglichen Funktion ähneln, um die Verwendung überladener Operationen ohne Zweck zu vermeiden.

Das Überladen von Operatorfunktionen hat im Allgemeinen zwei Formen: Überladen als Mitgliedsfunktion der Klasse und Überladen als Nichtmitgliedsfunktion der Klasse. Nicht-Mitglieder-Funktionen sind in der Regel Freunde. (Ein Operator kann als Nichtmitglieds- und Nichtfreundfunktion überladen werden. Wenn eine solche Operatorfunktion jedoch auf die privaten und geschützten Mitglieder der Klasse zugreift, muss sie die in der öffentlichen Schnittstelle bereitgestellten Methoden zum Festlegen von Daten und Lesen von Daten verwenden (Funktionen, die Leistung wird reduziert, wenn diese Funktionen aufgerufen werden, um die Leistung zu verbessern.) Das allgemeine Format des

-Memberfunktionsoperators

-Operator ist als Memberfunktion überladen einer Klasse:

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

Wenn ein Operator als Mitgliedsfunktion einer Klasse überladen wird, ist die Anzahl der Parameter der Funktion um eins geringer als der ursprüngliche Operand (mit Ausnahme der Dies liegt daran, dass die Member-Funktion implizit auf ein Objekt der Klasse zugreift, indem sie diesen Zeiger verwendet, der als ganz linker Operand der Operatorfunktion dient. Deshalb:

(1) Wenn der Binäroperator als Mitgliedsfunktion der Klasse überladen wird, gibt die Funktion nur explizit einen Parameter an, der der rechte Operand des Operators ist.

(2) Wenn der vorangestellte unäre Operator als Mitgliedsfunktion einer Klasse überladen wird, besteht keine Notwendigkeit, die Parameter explizit anzugeben, d. h. die Funktion hat keine formalen Parameter.

(3) Wenn der postfixierte unäre Operator als Mitgliedsfunktion der Klasse überladen wird, muss die Funktion einen ganzzahligen formalen Parameter haben.

Das Format zum Aufrufen von Elementfunktionsoperatoren lautet wie folgt:

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

Es entspricht

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

Zum Beispiel: a+b entspricht a.operator +(b). Im Allgemeinen verwenden wir den idiomatischen Ausdruck von Operatoren.

Friend-Funktionsoperator

Das allgemeine Format der Operatorüberladung als Friend-Funktion einer Klasse ist:

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

Beim Betrieb Wenn das Symbol als Freundfunktion der Klasse überladen wird, ändert sich die Anzahl der Operanden nicht. Alle Operanden müssen über die formalen Parameter der Funktion übergeben werden von links nach rechts.

Das Format zum Aufrufen des Friend-Funktionsoperators ist wie folgt:

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

Es entspricht

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

Zum Beispiel: a+b entspricht dem Operator +(a,b).

Vergleich zweier überladener Formen

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

(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）！