06.友元类友元函数和运算符重载

(创建于2017/12/24)

友元函数

友元函数提供了一种外部访问类私有属性的方法,如下，如果modifyA方法不添加friend，则编译失败

 #define  _CRT_SECURE_NO_WARNINGS
#include "iostream"  //包含c++的头文件
using namespace std;

class B {
public:
    B(int a) {
        this->a = a;
    }
private:
    int a = 10;

    friend void modifyA(B*b);
};
void modifyA(B *b) {
    b->a = 20;
}
int main() {
    B b(10);
    system("pause");
}

友元类

 #define  _CRT_SECURE_NO_WARNINGS
#include "iostream"  //包含c++的头文件
using namespace std;
class A {
    friend class B;
private:
    int x;
public :
    void display() {
        cout << "x"<

#define _CRT_SECURE_NO_WARNINGS
#include   //这个头文件和命名空间有一个不存在 cout就无法使用
using namespace std;

class A {
private:
    int i;
public:
    A(int i) {
        this->i = i;
    }
    void myprint() {
        cout << i << endl;
    }
    //友元函数
    friend void modify_i(A *a, int i);
};

//友元函数的实现，再友元函数中可以访问私有的属性
void modify_i(A *a, int b) {
    a->i = b;
}


//友元类
class B {
    friend class C;
private:
    int i;
};
//C这个友元类可以访问B的任何属性
class C {
private:
    B b;
public:
    C() {

    }
    void setAValue() {
        b.i = 20;
        cout << b.i << endl;
    }
};


void main() {
    A* a = new A(10);
    a->myprint();

    modify_i(a,12);
    a->myprint();

    cout << "----------------------------------------------" << endl;

    C *c = new C();
    c->setAValue();
    system("pause");
}

运算符重载

#define  _CRT_SECURE_NO_WARNINGS
#include "iostream"  //包含c++的头文件
using namespace std;
class A {
public:
    A(int a, int b) {

    }
public:
    int x;
};
A operator+(A &a1, A &a2) {
    return A(a1.x, a2.x);
}
int main() {
    A a1(1,2);
    A a2(3,4);
    A a3 = a1 + a2;
    system("pause");
}

运算符重载的两种方式和友元函数结合

 #define  _CRT_SECURE_NO_WARNINGS
#include "iostream"  //包含c++的头文件
using namespace std;
class A {
public:
    A(int a, int b) {

    }
    //实现运算符重载的两种方式之二：成员函数写在类的内部
    A operator-(A&a) {
        return A(this->x,a.x);
    }

    friend A operator+(A &a1, A &a2);
private:
    int x;
};

//实现运算符重载的两种方式之一：全局函数写在类的外边
//当x属性定义为私有的时候，在函数外部无法访问，此时，需要
//将重载后的函数定义为类的友元函数方可
A operator+(A &a1, A &a2) {
    return A(a1.x, a2.x);
}
int main() {
    A a1(1,2);
    A a2(3,4);
    A a3 = a1 + a2;
    system("pause");
}

一元运算符重载（++/--）

一元运算符--和++分前置和后置两种，虽然是同一个运算符但是放置的位置还会影响运算的逻辑，那么对这样一个运算符做重载怎么办，怎么区分是前置还是后置，这就需要在operator++（形参列表）形参列表中增加一个占位作为区别，当运算符是前置的时候，做一般处理，如A& operator--(A &a)，传入一个引用，因为是前置，所以先运算再赋值，然后返回这个对象的引用；而当运算符后置的时候，则在形参中增加一个int，用来告诉编译器这个运算符是后置的
friend A operator++(A &a, int)，由于后置运算的逻辑，是先返回本身，然后做++或--操作，所以下边的代码是先用一个对象接收这个引用，然后将引用++ --，返回的还是++ -- 之前的那个对象

 #define  _CRT_SECURE_NO_WARNINGS
#include "iostream"
using namespace std;
class A {
public:
    A(int a, int b) {
        this->x = a;
        this->y = b;
    }
    void printA() {
        cout <<"x="<

重载<<符号

#define _CRT_SECURE_NO_WARNINGS
#include "iostream"
using namespace std;
#define Func(a,b) a>b?a:b

class Name {
public:
    Name() {}
    Name(int a, int b) {
        this->a = a;
        this->b = b;
    }
    friend ostream& operator<<(ostream &cout, Name& n);
private:
    int a,b;
public:
    void print() {
        cout << "a=" << a << ",b=" << b;
    }
};
////链式调用，函数返回值当左值，需要返回一个引用
ostream& operator<<(ostream &cout,Name& n) {
    cout << n.a <<"---" <