c++运算符重载

1、概述

基本数据类型间的运算符没有重载的必要，所以运算符重载主要是面向对象之间的。

1.1 能够重载的运算符

+  -  *  /  %  ^  &  |  ~  !  =  <  >  +=  -=  *=  /=  %=  ^=  &=  |=
<<  >>  <<=  >>=  ==  !=  <=  >=  &&  ||  ++  --  ,  ->*  ->  ()  []
new  new[]  delete  delete[]

其中，[] 是下标操作符，() 是函数调用操作符。自增自减操作符的前置和后置形式都可以重载。

1.2 不能重载的运算符

长度运算符”sizeof“、条件运算符”: ?“、成员选择符”.“、对象选择符”.*“和域解析操作符”::“不能被重载。

1.3运算符重载的限制

重载不能改变运算符的优先级和结合性。

重载不会改变运算符的用法

重载运算符的函数不能有默认的参数，否则就改变了运算符操作数的个数。

1.4定义方式

运算符重载是通过函数定义实现的，它本质上是函数重载

返回值类型 operator 运算符名称 (形参表列){
    //TODO:
}

2、+-*/%运算符重载

在进行对象之间的运算时，程序会调用与运算符相对应的函数进行处理，所以运算符重载有两种方式：成员函数和友元函数。

成员函数的形式比较简单，就是在类里面定义了一个与操作符相关的函数。友元函数因为没有this指针，所以形参会多一个。

class A
{
public:
 A(int d):data(d){}

 A operator+(A&);//成员函数重载方式
 A operator-(A&);
 A operator*(A&);
 A operator/(A&);
 A operator%(A&);

 friend A operator+(A&,A&);//友元函数重载方式
 friend A operator-(A&,A&);
 friend A operator*(A&,A&);
 friend A operator/(A&,A&);
 friend A operator%(A&,A&);

private:
 int data;
};

//成员函数的实现
A A::operator+(A &a)
{
 return A(data+a.data);
}
A A::operator-(A &a)
{
 return A(data-a.data);
}
A A::operator*(A &a)
{
 return A(data*a.data);
}
A A::operator/(A &a)
{
 return A(data/a.data);
}
A A::operator%(A &a)
{
 return A(data%a.data);
}

//友元函数的实现
A operator+(A &a1,A &a2)
{
 return A(a1.data+a2.data);
}
A operator-(A &a1,A &a2)
{
 return A(a1.data-a2.data);
}
A operator*(A &a1,A &a2)
{
 return A(a1.data*a2.data);
}
A operator/(A &a1,A &a2)
{
 return A(a1.data/a2.data);
}
A operator%(A &a1,A &a2)
{
 return A(a1.data%a2.data);
}

//测试：对类A的对象进行+、-、*、/
void main(void)
{
 A a1(1),a2(2),a3(3);
 a1=a2+a3;
 //或者
 a1=a2.operator+(a3);
}

3、关系运算符重载

关系运算符有==,!=,<,>,<=,>=,其重载申明如下：

bool operator == (const A& ); 
bool operator != (const A& );
bool operator < (const A& );
bool operator <= (const A& );
bool operator > (const A& );
bool operator >= (const A& );

4、逻辑运算符重载

bool operator || (const A& );
bool operator && (const A& );
bool operator ! ();

5、单目运算符重载

这里的+、-是正负的意思，放在对象前面。

A& operator + ();
A& operator - ();
A* operator & ();
A& operator * ();

6、自增减运算符重载

++和–-根据位置的不同有四种情况，都可以重载。在这个函数中int参数是没有任何意义的，它的存在只是为了区分是前置形式还是后置形式。

A& operator ++ ();//前置++
A operator ++ (int);//后置++
A& operator --();//前置--
A operator -- (int);//后置--

7、位运算符重载（包含输入输出运算符）

在重载输入运算符时，采用引用的方式进行参数传递：输入的参数里面包含一个 istream 类的引用，返回值仍然为该引用。这样做的一个明显好处就是可以采用链式输入

A operator | (const A& );
A operator & (const A& );
A operator ^ (const A& );
A operator << (int i);//位运算符重载
A operator >> (int i);//位运算符重载
A operator ~ ();

istream & operator>>(istream &in, A&) //输入运算符>>
friend istream & operator>>(istream &in , A&);

ostream & operator<<(ostream &out, A&) //输出运算符<<
friend ostream & operator<<(ostream &out , A&); 

//重载示例
istream &operator>>(istream & in, A &a){
    in >> a.data;
    return in;
}
//重载输出运算符
ostream & operator<<(ostream & out, A &a){
    out << a.data;
    return out;
}

8、赋值运算符重载

重载赋值运算符时，函数的参数和返回值类型都必须是对象的引用。

A& operator=(const A&);
A& operator += (const A& );
A& operator -= (const A& ); 
A& operator *= (const A& );
A& operator /= (const A& );
A& operator %= (const A& );
A& operator &= (const A& );
A& operator |= (const A& );
A& operator ^= (const A& );
A& operator <<= (int i);
A& operator >>= (int i);

赋值运算符重载函数除了能有对象引用这样的参数之外，也能有其它参数。但是其它参数必须给出默认值。
例如A& operator=(const A&, a = 10);

9、内存运算符重载

以全局函数的方式重载,在重载 new 或 new[] 时，无论是作为成员函数还是作为全局函数，它的第一个参数必须是 size_t 类型。size_t 表示的是要分配空间的大小，对于 new[] 的重载函数而言，size_t 则表示所需要分配的所有空间的总和.

在重载 delete 或 delete[] 时,重载的返回值都是 void 类型，并且都必须有一个 void 类型的指针作为参数，该指针指向需要释放的内存空间。

重载函数也可以有其他参数，但都必须有默认值，并且第一个参数的类型必须是 size_t。

void *operator new(size_t size);
void *operator new(size_t size, int i);
void *operator new[](size_t size);
void operator delete(void*p);
void operator delete(void*p, int i, int j);
void operator delete [](void* p);

以类函数的方式重载

void *A::operator new(size_t size);
void *A::operator new(size_t size, int i);
void *A::operator new[](size_t size);
void A::operator delete(void*p);
void A::operator delete(void*p, int i, int j);
void A::operator delete [](void* p);

10、特殊运算符重载

上面的运算符重载都有两种方式，而下面的运算符的重载只能是成员函数或只有友元函数。

//只能有成员函数
A& operator = (const A& );
char operator [] (int i);//返回值不能作为左值
//[const] 返回值类型 & operator[] (参数)
const char* operator () ();
T operator -> ();
//类型转换符
operator char* () const;
operator int ();
operator const char () const;
operator short int () const;
operator long long () const;
//还有很多就不写了

//而这些只能以友元函数的形式重载
friend inline ostream &operator << (ostream&, A&);//输出流
friend inline istream &operator >> (istream&, A&);//输入流

11、总结

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

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

3.类型转换函数只能定义为一个类的成员函数而不能定义为类的友元函数。 C++提供4个类型转换函数：
    reinterpret_cast（在编译期间实现转换）
    const_cast（在编译期间实现转换）
    stactic_cast（在编译期间实现转换）
    dynamic_cast（在运行期间实现转换，并可以返回转换成功与否的标志）。

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

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

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

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

12、注意事项：

1.除了类属关系运算符”.“、成员指针运算符”.*“、作用域运算符”::“、sizeof运算符
和三目运算符”?:“以外，C++中的所有运算符都可以重载。

2.重载运算符限制在C++语言中已有的运算符范围内的允许重载的运算符之中，不能创建新的运算符。

3.运算符重载实质上是函数重载，因此编译程序对运算符重载的选择，遵循函数重载的选择原则。

4.重载之后的运算符不能改变运算符的优先级和结合性，也不能改变运算符操作数的个数及语法结构。

5.运算符重载不能改变该运算符用于内部类型对象的含义。它只能和用户自定义类型的对象一起使用，
或者用于用户自定义类型的对象和内部类型的对象混合使用时。

6.运算符重载是针对新类型数据的实际需要对原有运算符进行的适当的改造，重载的功能应当与原有功能相类似，避免没有目的地使用重载运算符。