标签：on() 返回 a+b int friend 打破 返回值 div person
1.友元函数
定义：在C++中，一个普通函数是不可以直接访问类中的任意成员的，但是如果把这个函数声明为友元函数，那么这个函数就可以访问类中的所有成员。
优点：能够不受限制地访问类中的任意成员，在一定程度上可以提高程序的执行效率。
缺点：打破类的封装性。
声明格式：friend 返回值数据类型 函数名（参数类别） 可以在类中的任意位置声明
（1）普通函数声明为友元函数
class Student{ friend void student_info(Student& student_info); public: Student(){} ~Student(){} protected: private: } //声明函数为友元函数 void student_info(Student& stu){}
（2）一个类的成员函数可以声明为另一个类的友元函数（一般不建议使用）
class Cat;//引用形参，指针，引用 class Person{ public: Person(Cat& c):caty(c){} ~Person(){} void show(); private: Cat &caty; } class Cat { public: Cat(){} ~Cat(){} private: friend void show(); }
（3）还可以把一个类A声明为另一个类B的友元类，这样友元类A的成员函数就可以访问类B的私有成员了。
class Cat{ public: Cat(){} ~Cat(){} private: friend class Person;//声明为友元类 } class Person{ }
友元类的特点：友元类是单向的，不能被继承。
2.运算符重载
算术运算符"+","-"只能用于基本数据类型（包括指针）的运算，但是对于自定义数据类型（Complex）是没有办法运算的。运算符重载之后，就可以对自定义数据类型进行运算了。
注意事项：
（1）运算符重载只能对已有的运算符进程重载
（2）不能重载的运算符（::，sizeof，?:，.*，->*，.）
（3）运算符重载不能改变运算符原来的特性和规则
双目运算符的重载
（1）成员函数重载 运算符的左值是函数调用者，右值是函数参数
Complex A,B; Complex C=A+B;//重载函数 A.Complex(B) Complex operator+(Complex B){ Complex C; C.real=this->real+B.real; C.image=this->image+B.image; return C; }
（2）友元函数重载
Complex A,B; Complex C=A+B;//operator(A,B) //友元函数重载，不是成员函数，所以没有this指针 Complex operator+(Complex& A,Complex& B) { Complex C; C.real=A.real+B.real; C.image=A.image+B.image; return C; }
由于友元函数不是成员函数，没有this指针，所以左右值都要通过参数传递，左值是第一个参数，右值是第二个参数。
（3）输出重载 实质上也是友元重载
operator& operator<<(ostream& out,Complex &C){ out<<"("<<","<<C.image<<")"<<endl; return out; }
单目运算符重载 A++是先用了再+1，++A是先+1再用
（1）成员函数重载
A++的情况
Complex operator++(int){ //保存原来的值 Complex old=*this;//==>old(*this) this->real+=1; this->image+=1; return lod; }
++A的情况
Complex& operator++(){ this->real+=1; this->image+=1 return *this; }
（3）括号 []，{}重载
（1）成员函数重载
重载[]
int &operator[](int i){ return this->array[i]; }
重载（）
coid operator()(){ cout<<"()()()()()"<<endl; }
（4）数据类型转换重载
（1）成员函数 格式：operator 数据类型 （）{return 要转换的类型数据}
operator int*() { return array } operator int() { return length; } Sqlist sq(10); int a=sq;//operaotr int(); int *p=sq;//operator int*();
转换为自定义的数据类型
class B{ public: B(){} ~B(){} }; class A{ public: A(){} ~A(){} operator B(){return b;} B b; } int main() { A a; B b=a; return 0; }
（5）.赋值运算符重载
class Data{ public: Data(){ cout<<"Data()"<<endl; p=new int(32); } ~Data(){cout<<"~Data()"<<endl;} Data(Data& d){cout<<"Data(Data& d"<<endl;} int data; int *p; //重载赋值运算符 Data& operator(Data& d) { if(this!= &d)//避免拷贝给自己 { this->data=d.data; memcpy(this->p,d,p,sizeof(int)); } return *this; } } int main() { Data a; a.data=123; Data b=a; Data c; c=a; cout<<a.data<<" "<<b.data<<" "<<c.data<<endl; cout<<a.p<<" "<<b.p<<" "<<c.p<<endl; return 0; }
2.构造函数隐式转换
class Number{ public: Number(int n=0):num(n){} void show(){cout<<this->number}; private: int num; } //使用 Number ynum=123;//构造函数隐式转换 ynum.show();
想要避免隐式转换，就在构造函数前面添加"explicit"关键字
PS：有哪里写错写漏了，请指正，互相学习。
标签：on() 返回 a+b int friend 打破 返回值 div person
原文地址：https://www.cnblogs.com/smallqizhang/p/12528434.html
