1. Surcharge de l'opérateur
Définir un opérateur surchargé revient à définir une fonction, sauf que le nom de la fonction est operator @ (@ représente un opérateur)
Le nombre de paramètres dans la liste de paramètres de fonction dépend de deux facteurs:
1) Que l'opérateur soit unaire ou binaire; et
2) l'opérateur est défini comme une fonction globale (le paramètre mono est un paramètre binaire vaut deux) ou la fonction membre (la fonction d'appartenance pour un paramètre n'est pas binaire et seulement un paramètre);
#include <iostream>
#include<string.h>
using namespace std;
class CMyPoint
{
int x,y;
public:
CMyPoint(int i,int j){
x=i;y=j;}
CMyPoint operator+(CMyPoint &p)//重载二元运算符
{
return CMyPoint(x+p.x,y+p.y);
}
CMyPoint operator-(CMyPoint &p)//重载二元运算符
{
return CMyPoint(x-p.x,y-p.y);
}
void showPoint()
{
cout<<"x="<<x<<endl;
cout<<"y="<<y<<endl;
}
};
int main()
{
CMyPoint p1(10,0);
CMyPoint p2(0,10);
CMyPoint p3=p1+p2;
CMyPoint p4=p1-p2;
p3.showPoint();
p4.showPoint();
return 0;
}
2. Surcharge d'amis
Utilisez l'opérateur de surcharge de la fonction membre, s'il existe une expression p = 20 + p1,
le compilateur l'interprétera comme: 20.opérateur + (p1), le premier nombre est un entier et les opérateurs existants ne peuvent pas être résolus;
opérateurs amis La proposition :
Parfois, certains opérateurs doivent être surchargés en tant qu'amis au lieu de membres, principalement à cause de l'ordre des opérateurs dans les expressions, car lorsqu'il est surchargé en tant que membres de fonction, l'objet de classe lui-même est utilisé comme premier paramètre d'opération;
#include <iostream>
#include<string.h>
using namespace std;
class CMyPoint
{
int x,y;
public:
CMyPoint(int i,int j){
x=i;y=j;}
friend CMyPoint operator+(CMyPoint &p1,CMyPoint &p2)//友元重载
{
return CMyPoint(p1.x+p2.x,p1.y+p2.y);
}
friend CMyPoint operator-(CMyPoint &p1,CMyPoint &p2)//友元重载
{
return CMyPoint(p1.x-p2.x,p1.y-p2.y);
}
friend CMyPoint operator+(int v,CMyPoint &p)
{
return (CMyPoint(p.x+v,p.y+v));
}
void showPoint()
{
cout<<"x="<<x<<endl;
cout<<"y="<<y<<endl;
}
};
int main()
{
CMyPoint p1(10,0);
CMyPoint p2(0,10);
CMyPoint p3=p1+p2;
CMyPoint p4=p1-p2;
p3.showPoint();
return 0;
}
Surcharge d'opérateur unaire pour surcharge d'amis:
friend <返回类型> operator <重载的运算符>(<形参1>)
{
.......}
Opérateur binaire:
friend <返回类型> operator <重载的运算符>(<形参1,形参2>)
{
......}
3. Fonction de conversion de type:
La fonction de conversion consiste à convertir un type de valeur en un autre type de valeur; la
conversion de type C ++ comprend la conversion implicite automatique et la conversion de type coercitif; la
fonction de conversion est un moyen de coercition; elle est dans la classe La définition de la fonction membre non statique, son le format est généralement le suivant:
class <类名>
{
public：
operator <类型>（）；
}
Cas:
#include<math.h>
#include<iostream>
using namespace std;
class CMyPoint{
int x,y;
public:
CMyPoint(int i,int j){
x=i;
y=j;
}
operator double();
};
CMyPoint::operator double(){
//类型转换函数，将对象强制转化为一个double
return sqrt(x*x+y*y);
}
int main()
{
CMyPoint p1(1,2);
double d=(double)p1;
cout<<d<<endl;
return 0;
}
4. Surcharge de l'opérateur d'affectation
1. Les objets du même type peuvent être affectés directement
2. Tous les types d'objets ne peuvent pas être affectés de cette manière, par exemple, lorsqu'il y a des tableaux dynamiques ou des données dynamiques dans les objets, ils ne peuvent pas être affectés directement les uns aux autres;
classification:
1. opérateur d'affectation par défaut,
2. opérateur d'affectation de surcharge;
class CMyPoint1
{
int x,y;
char *name;
public:
CMyPoint1():x(0),y(0),name(NULL){
}
CMyPoint1(int x,int y,char name[]);
~CMyPoint1();
CMyPoint1& operator=(const CMyPoint1 &r);
}
CMyPoint1::~CMyPoint1()//析构函数实现
{
if(name){
delete[] name;
}
}
CMyPoint1& CMyPoint1::operator =(const CMyPoint1 &r){
//重载赋值运算符
x=r.x;
y=r.y;
if(this->name){
//先查看是否为NULL
delete[] this->name;
this->name=NULL;
}
if(r.name){
//必须name不为NULL才能赋值
this->name=new char[strlen(r.name)+1];
strcpy(this->name,r.name);
}
return *this;//返回一个对象
}
CMyPoint1::CMyPoint1(int i=0,int j=0,char name[])//带参构造函数
{
x=i;
y=j;
if(name){
this->name=new char[strlen(name)+1];
strcpy(this->name,name);
}
}
Points à noter:
1. La fonction surchargée de l'opérateur d'affectation renvoie une référence à un objet au lieu d'un objet;
2. L'opérateur d'affectation ne peut pas surcharger les fonctions ami, uniquement les fonctions membres non statiques;
3. La fonction d'opérateur d'affectation est la seule qui ne peut pas être utilisée Fonction d'opérateur héritée
4. Dans certaines circonstances, il peut renvoyer const CDemo &.
5. Incrémenter et décrémenter la surcharge de l'opérateur
1. Guillemet avant:
++ i et i ++ ne sont pas les mêmes,
donc lorsque les opérateurs de surcharge doivent être distingués;
opérateur de préfixe: (++ i)
opérateur CDemo ++ ();
opérateur postfix: (i ++)
opérateur CDemo ++ (int);
case_entrée:
output_case:
p1:(3,4)
p2:(1,2)
p3:(3,4)
code:
#include<stdio.h>
using namespace std;
class CMyPoint{
int x,y;
public:
CMyPoint(int i,int j){
x=i;
y=j;
}
CMyPoint(){
x=0;
y=0;
}
CMyPoint operator++();//++i
CMyPoint operator++(int);//i++
CMyPoint& operator=(const CMyPoint &r);
int getX();
int getY();
};
int CMyPoint::getX(){
return x;
}
int CMyPoint::getY(){
return y;
}
CMyPoint CMyPoint::operator++(){
//++CMyPoint
x++;
y++;
return *this;
}
CMyPoint CMyPoint::operator++(int){
//CMyPoint++
CMyPoint p(*this);//拷贝函数
x++;y++;
return p;//（先用在加）
}
CMyPoint& CMyPoint::operator=(const CMyPoint &r){
x=r.x;
y=r.y;
return *this;
}//重写赋值运算符
int main()
{
CMyPoint p1(1,2),p2,p3;
p2=p1++;
p3=++p1;
printf("p1:(%d,%d)\n",p1.getX(),p1.getY());
printf("p2:(%d,%d)\n",p2.getX(),p2.getY());
printf("p3:(%d,%d)\n",p3.getX(),p3.getY());
return 0;
}
2. Définition de l'opérateur d'auto-incrémentation et d'auto-décrémentation: Définition de l'opérateur d'
auto-incrémentation du préfixe:
opérateur CDemo ++ (CDemo &);
opérateur CDemo– (CDemo &)
Définition de l'opérateur d'auto-incrémentation du suffixe:
opérateur CDemo ++ (CDemo &, int);
CDemo opérateur– (CDemo &, int);
3. Opérateurs qui ne peuvent pas être surchargés:
1) Opérateur ternaire:?:
2) Opérateur membre:.
3) Opérateur pointeur membre: *
4) Opérateur d'étendue :::
5) Opérateur Sizeof