C++运算符的重载

一、C++运算符重载的总结

11、运算符重载其实是一种特殊的函数重载必须定义一个函数，告诉C++编译器，当遇到该重载运算符时调用此函数。这个函数叫做运算符重载函数，通常为类的成员函数。

一般格式：
返回值类型  类名::operator重载的运算符（参数表）

{.......}

2、operator是关键字。它与重载的运算符一起构成函数名。因函数名的特殊性，C++可以将这类函数识别出来。

3、运算符重载函数名必须为 关键字operator加一个合法的运算符。在 调用该函数时，将右操作数作为函数的实参。

4、当用类的成员函数实现 运算符重载时，运算符重载函数的参数（当为双目运算符时）为一个或（当为单目运算符时）没有。运算符的左操作数一定是对象，因为重载的运算符是该对象的成员函数，而右操作数是该函数的参数。

5、单目运算符“++”和“--”存在前置和后置的问题

前置“++”格式为：

返回类型 类名::operator++()

而后置“++”格式为：

返回类型 类名::operator++(int)

后置++中的参数int仅作为区分，并无实际意义，可以给一个变量名，也可以不给变量名。

6.C++中只有极少数的运算符不允许重载

？：  三目运算符    C++中没有定义三目5运算符的语法

.和。*   成员操作符   为保证成员操作符 对成员访问的安全性

::   作用域操作符    该操作符右操作数不是表达式

sizeof    类型字长操作符    该操作符的 操作数为 类型名，不是表达式。

还有#，##，//,/**/

二、一些运算符重载

Int operator +(const Int&it)const
{
   //Int tmp(this->value+it.value);
   //return tmp;//要多构建一个对象
   return Int(this->value+it.value);
}
 //c=a+b;c=a.operator+(b);
//c=operator+(&a,b);
Int operator+(const int x)const
{
  return Int(this->value+x);
}//c=a+10;c=a+x;
//c=a.operator+(10)

Int operator+(const int x)const

Int operator+(const int& x)const

这里给引用还是不给引用好呢？

给引用：1、是要先找出它的地址（访问一次 内存）

               2、从地址里面找出它的值（访问第二次）

不给：只用访问一次

所以对于内置类型，不给引用

2.1“<<”">>"的重载

输出流重载

ostream & operator<<(ostream &out)const
{
  out<<value;
  return out;
}//a.operator<<(cout);
};
int main()
{
  Int a(10);
  const Int b(20);
  a<<(cout);
  b.operator<<(cout);
  //operator<<(&b,cout);
}

为什么返回ostream &?怎么把它改成cout<<这样子的？

可以进行连续的输出。

第二个问题：

把它定义成外部函数，有三个解决方法：

1、把这个函数设置成Int的友元，这样就可以访问私有。

2.调用类的公有方法，获取value

3.it<<out，类里本身有一个<<的成员函数，可以打印出value。//it.operator<<(out)//operator<<(&it,out)

输入流 重载：

istream &operator>>(istream &in,const Int &it)
{
   //in>>it.value;
   //inn>>it.value();
   it>>in;
   return in;
}
   

2.2前置++和后置++的重载

Int &operator++()
{
  this->value++;
  return *this;
}
Int operator++(int)
{
  Int tmp(*this);
  this->value+=1;
  return tmp;
}
Int operator++(int)
{
   int x=this->value;
   ++*this;
   return Int(x);
)
Int operator++(int)
{
 return Int(this->value++);
}

为什么前置++只用构建一次对象，而后置++不断地构建和析构对象？ 

前置++本身不会返回亡值对象作为过渡，但是后置++每次会 构建一个亡值作为过渡。每次都要构建和析构。

2.3前置--和后置--

2.4运算符（）的重载

#include <iostream>
using namespace std;
class Add
{
private:
	int value;
public:
	Add(int x=0):value(x){}
	~Add(){}
	int operator()(int x, int y)
	{
		value = x + y;
		return value;
	}
};
int main()
{
	Add  add(0);
	int x = 10, y = 20, z = 0;
	z = add(x, y);
	//z=add.operator()(x,y)
	cout << z << endl;
	return 0;
}

我们把这样的函数叫做仿函数。看着像一个函数，实际上 是一个对象。

如果只有一个参数成为一元仿函数，上述代码是二元仿函数，以此类推。

仿函数用于替代函数指针。

下面这样写是对是错呢？

是正确的。Add是类名，类名加（）会调用构造函数，只是这里创建的是不具名对象，它也可以调用类的成员函数，所以是正确的。

可以用这种方法突破语法的 限制，使常对象使用常方法的值也可以修改。

或者在前面加上异变关键字使它可以修改。