C++继承-复合-委托

1.继承Inheritance，表示is-a

struct _List_node_base
{
    _List_node_base* _M_next;
    _List_node_base* _M_prec;
};

template<typename _Tp>
struct _List_node : public _List_node_base
{
    _Tp _M_data;    
};

子类指向父类
继承也可以有public protected private
继承最有价值的点是和虚函数的搭配使用

继承下的构造和析构
父类的析构函数必须是虚函数
一个良好的习惯是只要该以后会成为父类，那么它的析构函数就需要成为虚函数不virtual

2.复合Composition

表示has-a

Adapter设计模式

template<class T>
//先进先出
class queue{
    ...
    
protected:
    //两段进出
    deque<T> c; //底层容器
public:
    //以下完全利用c的操作函数完成
    bool empty() const {return c.empty();}
    size_type size() const {return c.size();}
    reference front() {return c.front();}
    reference back() {return c.back();}
    //先出先出，只开放了deque的两个功能
    void push(const value_type& x){c.push_back();}
    void pop(){c.pop_front();}
}

抽象出Composition关系
构造由内而外，首先调用里面的deque的默认构造函数
析构是先析构自身，再调用deque的析构函数

生命周期：同时

3.委托Delegation

Composition by reference.

//file String.hpp
class StringRep;
class String{
public:
    String();
    String(const char* s);
    String(const String& s);
    String &operator=(const String& s);
    ~String();
...
private:
    StringRep* rep;//pimpl  存在一个指针指向StringRep
};

在任意一个时间点，都可以使用StringRep，委托给StringRep

//file String.cpp
#include "String.hpp"
namespace{
    class StringRep{
        friend class String;
        StringRep(const char* s);
        ~StringRep();
        int count;
        char* rep;    
    };
}
String::String(){...}
...

左边对String的实现永远交给StringRep，而它只开放拷贝构造赋值
point to implementation 指针指向具体实现 （Handle、Body）
设计手法：左边对外不变，右边对类的实现（就可以任意切换）【编译防火墙】

生命周期：先有String，需要用的时候才有StringRep

有String a ； String b；String c；
同时指向StringRep，StringRep里面使用引用计数，共享同一个Hello

Copy On Write概念
当a想要改变rep里面的值时，那么rep就拷贝构造出一份出来，让a单独地改动
b，c依旧共享rep

4.继承+复合关系下的构造和析构

5.委托+继承

class Subject
{
    //真正的data位置
    int m_value;
    vector<Observer*> m_views; //委托delegation
public:
    //注册观察者
    void attach(Observer* obs)
    {
        m_views.push_back(obs);
    }
    void set_val(int value)
    {
        m_value = value;
        notify();    
    }
    //通知所有观察者，更新value
    void notify()
    {
        for(int i = 0;i < m_views.size();++i)  
            m_view[i]->update(this,m_value);  
    }
}

Observer,让Subject可以拥有多个Observer
就像ppt一样

像上图中就是有四个Observer在观察同一个矩形

class Observer
{
public:
    virtual void update(Subject* sub,int value)=0;
};//Observer可以被继承

–学习自侯捷老师