总结4

const关键字
1、表示只读
2、必须初始化
3、常量指针与指针常量
4、性能不受影响

成员引用变量没重载运算符时

#include 
#include 
using namespace std;

class Base{
    public:
        int& a;
    public:
        Base(int& a):a(a){}
};

int main()
{
    int a, b;
    Base b1(a), b2(b);//a绑定到b1对象中，b绑定到b2对象中
    a = 10;
    b = 20;

    cout << b1.a << endl;//10
    cout << b2.a << endl;//20

    memcpy(&b1, &b2, sizeof(Base));//b绑定到b1对象中，同时b也绑定到b2对象中

    cout << b1.a << endl;//20
    cout << b2.a << endl;//20

    b1.a = 30;//修改b的值,b1对象和b2对象中的数据都被修改
    cout << b2.a << endl;//30
    cout << a << " " << b << endl;//10 30
    return 0;
}

成员引用变量有重载运算符时

成员引用变量，必须构造函数进行列表初始化，必须重载复制运算符

#include 
#include 
using namespace std;
/*
 * const成员变量，必须构造函数进行列表初始化，必须重载复制运算符
 * 成员引用变量，必须构造函数进行列表初始化，必须重载复制运算符
*/
class Base{
    public:
        int& a;
    public:
        Base(int& a):a(a){}
        Base& operator = (const Base& rhs){this->a = rhs.a;}
};

/*
class Base{
private:
	const int a;
public:
	Base():a(123){}
	int getA()const{return this->a;}
	Base& operator=(const Base& base){return *this;}
};
*/

int main()
{
    int a, b;
    Base b1(a), b2(b);//a绑定到b1对象中，b绑定到b2对象中
    a = 10;
    b = 20;

    cout << b1.a << endl;//10
    cout << b2.a << endl;//20
    
    //有重载运算符时
    b1 = b2;//此时b没有绑定到b1对象中，只是把b2对象里的值赋值而已

    cout << b1.a << endl;//20
    cout << b2.a << endl;//20

    b1.a = 30;//修改的只是a的值,30
    cout << b2.a << endl;//20
    cout << a << " " << b << endl;//30 20
    return 0;
}

设计原则

设计原则，在面向对象之下
设计之初，编写程序过程中发生的变化，总是应付不好
逐渐总结出一些规律，使得满足此规律的代码，能够有效的应付变化‘
此类规律蜕变为设计原则
在此原则的基础上，总结出面向对象

SOLID原则
1、开发关闭原则：总原则，对修改是关闭的，对扩展是开发的
2、接口隔离原则：隔离变化，接口产生的变化要单一
3、单一职责原则：职责要单一，不需要无关项
4、里氏替换原则：基类与派生类是is的关系，不是has的关系，行为要同一
5、依赖倒置原则：依赖于抽象，不依赖细节，上层模块不依赖底层模块，依赖抽象

继承：继承
接口：继承接口类
关联：一个类中有另一个类
依赖：类的行为依赖于其他类
聚合：多个，少几个影响不大
组合：多个，少一个影响都很大

//接口
class A{
private:
	B& b;
public:
	A(B& b):b(b){}
};