C++运算符重载——重载一元运算符

时间:2023-11-11 19:51:02

0、重载一元操作符的方法

一元运算符即只需要一个操作用的运算符,如取地址运算符(&)、复数(-)、自减(--)、自加(++)等。

运算符重载可以分为3种方式:类的非静态成员函数、类的友元函数、普通函数。

例如有 1 个操作数 a,一元运算符 ? (表示一个一元运算符),a? 或者?a 的操作会被解释为下面2种形式之一

//a? or ?a
a.operator?(); //类的非静态成员函数
operator?(a); //友元函数 和 普通函数

第一种形式是运算符被重载为类的非静态成员函数,没有参数。

这种方式要求操作数(即a)必须是一个对象,operator?是这个对象的非静态成员函数,

第二种形式是运算符被重载为类的友元函数 或 普通函数,有1个参数。

重载为 类的友元函数 和 普通函数的区别是 类的友元函数可以直接访问类的私有成员,而普通函数不可以。

1、重载++、--(前置 和 后置)

自增运算符(++)和 自减运算符(--)都有 前置 和 后置 2中情况。

C++中为了区分前置和后置规定:前置重载与普通运算符重载一致,后置重载需要在参数列表中加入一个无用的参数。

++/-- 的3种重载方式如下: 前置的情况可以返回类的引用,后置的情况只能返回临时对象。

//类的非静态成员函数
class X
{
X& operator++(){...} //前置++
X operator++(int){...} //后置++ X& operator--(){...}   //前置--  
X operator--(int){...} //后置--
}
/*-----------------------------------------------------*/
//类的友元函数
class X
{
friend X& operator++(X& ref){...} //前置++
friend X operator++(X& ref, int){...} //后置++ friend X& operator--(X& ref){...} //前置--
friend X operator--(X& ref, int){...} //后置--
}
/*-----------------------------------------------------*/
//普通函数
class X
{
...
}
X& operator++(X& ref){...} //前置++
X operator++(X& ref, int){...} //后置++ X& operator--(X& ref){...} //前置--
X operator--(X& ref, int){...} //后置--

下例中有3个Counter类 CounterA、CounterB 和CounterC,3个类都重载了前置++、-- 和后置++、--。

其中CounterA使用类的非静态成员函数方式重载,CounterB使用类的友元函数方式重载,CounterC使用普通函数方式重载。

#include <iostream>
using namespace std; class CounterA
{
public:
//默认构造函数(Default constructor)
CounterA(){cout<<"Default Constructor"<<endl;}
//带参数的构造函数(The constructor with parameters)
CounterA(int m):n(m){cout<<"Parameter Constructor"<<endl;}
//拷贝构造函数(Copy constructor)
CounterA(const CounterA& ref){n = ref.n; cout<<"Copy Constructor"<<endl;}
//析构函数(destructor)
~CounterA(){cout<<"Destructor"<<endl;} //重载运算符 ++(前置)
const CounterA& operator++(){++n; return *this;}
//重载运算符 ++(后置)
const CounterA operator++(int dump){CounterA Tmp(*this);++n; return Tmp;}
//重载运算符 --(前置)
const CounterA& operator--(){--n; return *this;}
//重载运算符 --(后置)
const CounterA operator--(int dump){CounterA Tmp(*this);--n; return Tmp;} //输出用函数
void display(void){cout<<"n = " << n << endl;}
//GetData
int GetVal(void){return n;} private:
int n;
}; class CounterB
{
public:
//默认构造函数(Default constructor)
CounterB(){cout<<"Default Constructor"<<endl;}
//带参数的构造函数(The constructor with parameters)
CounterB(int m):n(m){cout<<"Parameter Constructor"<<endl;}
//拷贝构造函数(Copy constructor)
CounterB(const CounterB& ref){n = ref.n; cout<<"Copy Constructor"<<endl;}
//析构函数(destructor)
~CounterB(){cout<<"Destructor"<<endl;} //重载运算符 ++(前置)
friend const CounterB& operator++(CounterB& ref){ref.n += ;return ref;}
//重载运算符 ++(后置)
friend const CounterB operator++(CounterB& ref, int dump){CounterB Tmp(ref);ref.n += ; return Tmp;}
//重载运算符 --(前置)
friend const CounterB& operator--(CounterB& ref){ref.n -= ;return ref;}
//重载运算符 --(后置)
friend const CounterB operator--(CounterB& ref, int dump){CounterB Tmp(ref);ref.n -= ; return Tmp;} //输出用函数
void display(void){cout<<"n = " << n << endl;}
//GetData
int GetVal(void){return n;}
//SetData
void SetVal(int val){n = val;} private:
int n;
}; class CounterC
{
public:
//默认构造函数(Default constructor)
CounterC(){cout<<"Default Constructor"<<endl;}
//带参数的构造函数(The constructor with parameters)
CounterC(int m):n(m){cout<<"Parameter Constructor"<<endl;}
//拷贝构造函数(Copy constructor)
CounterC(const CounterC& ref){n = ref.n; cout<<"Copy Constructor"<<endl;}
//析构函数(destructor)
~CounterC(){cout<<"Destructor"<<endl;} //输出用函数
void display(void){cout<<"n = " << n << endl;}
//GetData
int GetVal(void){return n;}
//SetData
void SetVal(int val){n = val;} private:
int n;
};
//重载运算符 ++(前置)
const CounterC& operator++(CounterC& ref){ref.SetVal(ref.GetVal()+);return ref;}
//重载运算符 ++(后置)
const CounterC operator++(CounterC& ref, int dump){CounterC Tmp(ref);ref.SetVal(ref.GetVal()+); return Tmp;}
//重载运算符 --(前置)
const CounterC& operator--(CounterC& ref){ref.SetVal(ref.GetVal()-);return ref;}
//重载运算符 --(后置)
const CounterC operator--(CounterC& ref, int dump){CounterC Tmp(ref);ref.SetVal(ref.GetVal()-); return Tmp;} int main(void)
{
CounterA cp1();cp1.display();
++cp1;cp1.display();
--cp1;cp1.display();
CounterA cp2(cp1++);cp2.display();
CounterA cp3(cp1--);cp3.display(); CounterB cp4();cp4.display();
++cp4;cp4.display();
--cp4;cp4.display();
CounterB cp5(cp4++);cp5.display();
CounterB cp6(cp4--);cp6.display(); CounterC cp7();cp7.display();
++cp7;cp7.display();
--cp7;cp7.display();
CounterC cp8(cp7++);cp8.display();
CounterC cp9(cp7--);cp9.display(); return ;
}

2、重载负号(-)

下例中有3个Complex类 ComplexA、ComplexB 和ComplexC,3个类都重载了负号。

其中ComplexA使用类的非静态成员函数方式重载,ComplexB使用类的友元函数方式重载,ComplexC使用普通函数方式重载。

#include <iostream>
using namespace std; class ComplexA
{
public:
//constructor
ComplexA(double re, double im):real(re),image(im){}
//Operator Overload : -
ComplexA operator-(){return ComplexA(-real, -image);}
//display
void display(void){if (image>)cout<<real<<"+"<<image<<endl;else cout<<real<<image<<endl;} private:
double real;
double image;
}; class ComplexB
{
public:
//constructor
ComplexB(double re, double im):real(re),image(im){}
//Operator Overload : -
friend ComplexB operator-(ComplexB& ref){return ComplexB(-ref.real, -ref.image);}
//display
void display(void){if (image>)cout<<real<<"+"<<image<<endl;else cout<<real<<image<<endl;}
private:
double real;
double image;
}; class ComplexC
{
public:
//constructor
ComplexC(double re, double im):real(re),image(im){}
//GetData
double GetReal(void){return real;}
double GetImage(void){return image;}
//display
void display(void){if (image>)cout<<real<<"+"<<image<<endl;else cout<<real<<image<<endl;} private:
double real;
double image;
}; //Operator Overload : -
ComplexC operator-(ComplexC& ref){return ComplexC(-ref.GetReal(), -ref.GetImage());} int main(void)
{
ComplexA a1(,);a1.display();
ComplexA a2(-a1);a2.display(); ComplexB b1(,);b1.display();
ComplexB b2(-b1);b2.display(); ComplexC c1(,);c1.display();
ComplexC c2(-c1);c2.display(); return ;
}