运算符重载函数＆　友缘函数　＆成员函数

函数＆　友缘函数　＆成员函数"/>

运算符重载函数＆　友缘函数　＆成员函数

成员函数

一个常规的成员函数在逻辑上这三者时互不干扰的

1、该成员函数可以访问类的私有成员

2、该成员函数属于类的作用域

3、该函数需要通过一个类的对象去调用(this指针)

#include<iostream>
using namespace std;
class Test
{
public:Test(int d):data(d){}//void fun(Test * const this)void fun();
private:int data;
};
//属于 class Test作用域，可以访问私有数据
void Test::fun()
{cout<<"This is fun() data="<<this->data<<endl;
}
void main()
{Test t(10);//通过对象调用t.fun();
}

运算符重载函数

本质：运算符重载函数也是函数，醒目的实现对象和对象的基本操作

整数与整数的基本操作编译器已经给出相应的程序，对象和对象的操作需要程序员去实现

形式：

返回值类型 类名:: operator需重载的运算符号(参数)

例如复数加法

**tip:复数相加：(实部+实部，虚部+虚部)**

#include<iostream>
using namespace std;
class Complex;
//operator(&out,c)
//out．operator<<(c)
ostream& operator<<(ostream &out,const Complex &c);
//复数
class Complex
{friend  ostream& operator<<(ostream &out,const Complex &c);
public:Complex(int real=0,int img=0):m_real(real),m_img(img){}/*Complex Add(const Complex &c){Complex tmp(m_real+c.m_real,m_img+c.m_img);return tmp;}*///直接返回无名零时对象，可以少调用一次拷贝构造函数//对象返回时，对象出了函数域会消失，因此 需要一个临时无名对象开来接受该对象Complex operator+(const Complex &other){//Complex tmp(m_real+other.m_real,m_img+other.m_img);//return tmp;return Complex(m_real+other.m_real,m_img+other.m_img);}void show(){cout<<"("<<m_real<<","<<m_img<<")"<<endl;}~Complex(){cout<<"~Complex()"<<endl;}
private:int m_real;int m_img;
};
//输出运算符重载
ostream& operator<<(ostream &out,const Complex &c)
{out<<"("<<c.m_real<<","<<c.m_img<<")"<<endl;return out;
}
void main()
{Complex c1(1,2);Complex c2(3,4); //operator+(&c1,c2)//这种函数也可以，不醒目而已比起c1+c2;//c1.Add(c1);Complex c;//下面两者一样//c=c1.operator+(c2)c=c1+c2;//c.show();//通过重载输出运算符，输出对象c的值cout<<c<<endl;

重载 a++和++a

++a优点：以引用返回执行效率高，不产生无名零时对象，不调用拷贝构造对象。

#include<iostream>
using namespace std;
class Test
{
public:Test(int d=0):data(d){}~Test(){}Test& operator++() //++i{data++;return *this;}Test operator++(int)//i++{Test tmp(data);data++;return tmp;}private:int data;
};
void main()
{Test t(10);Test a=++t;Test b=t++;
}

不能重载下面符号

 ?:三目运算符 .和.* 成员操作符 ::作用域操作符 sizeof 类型的字节长度

有缘函数

关键字 :friend

有缘函数成员函数区别

1、成员函数，作用于类，调用时需通过对象+.方法调用；有缘函数不属于类，可以直接调用
2、如果把一个函数声明为一个类的友缘函数，则该函数可以访问该类的所用成员
3.如果把一个类声明为另一个类的友缘类，则该友缘类中的所用函数称为有缘函数，并且可以访问该类中的所用成员
4、友缘函数需要两个参数，成员函数需要一个参数，将this指针进行了隐藏

#include<iostream>
using namespace std;
//声明
class Test;
void fun();class Test
{//把fun()声明为Test类的友缘类friend void fun(Test &t);public:Test(int d=0):data(d){}//void fun(Test &t);
private:int data;
};
//fun()不属于Test类d的作用域，且可以访问私有成员
void fun(Test &t)
{cout<<"This is Test friend fun()"<<endl;cout<<t.data<<endl;
}
void main()
{Test t(10);//友缘函数不属于类，直接调用fun(t);
}

重载 << 和 >> 运算符

1、可以用有缘函数作为输出，也可以用成员函数作为输出.

#include<iostream>
using namespace std;
//声明
class Complex;
//operator(&out,c)
//out．operator<<(c)
ostream& operator<<(ostream &out,const Complex &c);
istream& operator>>(istream& cin,Complex &c)
//复数
class Complex
{//ostream&　out.operator<<(c) //ostream& operator<<(&out,c)friend ostream& operator<<(ostream &out,const Complex &c);friend istream& operator>>(istream& cin,Complex &c)
public:Complex(int real=0,int img=0):m_real(real),m_img(img){}Complex operator+(const Complex &other){//Complex tmp(m_real+other.m_real,m_img+other.m_img);//return tmp;return Complex(m_real+other.m_real,m_img+other.m_img);}~Complex(){cout<<"~Complex()"<<endl;}//ostream& operator<<(ostream &out)隐藏了一个对象的this指针/*
public:ostream& operator<<(ostream &out){out<<"("<<m_real<<","<<m_img<<")"<<endl;return out;}
*/
private:int m_real;int m_img;
};
//输出运算符重载
//ostream& operator<<(&c,cout)
ostream& operator<<(ostream &out,const Complex &c)
{out<<"("<<c.m_real<<","<<c.m_img<<")"<<endl;return out;
}
//输入运算符重载
//istream& operator>>(&cin,c3)
istream& operator>>(istream& cin,Complex &c)
{cin>>c.m_real>>c.m_img;return cin;
}
void main()
{Complex c1(1,2);Complex c2(3,4); Complex c;c=c1+c2;//cout.operator<<(c);cout<<c<<endl;//c.operator <<(cout)c<<cout<<endl;Complex c3;//cin.operator>>(c3);cin>>c3;cout<<c3<<endl;
}