C++網易雲課堂開發工程師--組合與繼承

着一個章節主要圍繞：繼承，複合，委託三個方面進行介紹。

複合：表示has-a

template<class T, class Sequence = deque<T>>　　　　　　　　　　　　　　queue<>------------------>deque

class queue{　　　　　　　　　　　　　　　　　　　　　　　　　　　　   queue中包含deque

　　protected:　　　　　　　　　　　　　　　　　　　　　　　　　　　  deque中兩端都可以進出，queue一端能夠進出

　　　　Sequence 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 是兩端能夠進出，queue是末端先進先出

　　　　void push(const value_type& push_back(x);)

　　　　void pop() {c.pop_front();}

}

～～～～～～～～～～～～～～～～～～～～～～～～～～～～～～～～

複合，是指一個類A中包含另一個類B，A中的功能徹底由類B來實現。

～～～～～～～～～～～～～～～～～～～～～～～～～～～～～～～～

從內存的角度出發，理解複合。

Sizeof: 40                                                               Sizeof:16*2 + 4 + 4　　　　　　　　　　　　Sizeof:4*4

template <class T>　　　　　　　　　　　　template <class T>　　　　　　　　　　　　template <class T>

class queue{　　　　　　　　　　　　　　　class deque{　　　　　　　　　　　　　　　class Ttr{

　　protected:　　　　　　　　　　　　　　　　protected:　　 　　　　　　　　　　　　　　T*　　cur;　　　　　　　　　　　　

　　　　deque<T>　　C;　　　　　　　　　　　　Itr<T>　　start;　　　　　　　　　　　　 T*　　first;

}　　　　　　　　　　　　　　　　　　　　　　　Itr<T>　　finish;　　　　　　　　　　　　T*　　last;

　　　　　　　　　　　　　　　　　　　　　　　  T**　　map;　　　　　　　　　　　　　   T** 　 node;

　　　　　　　　　　　　　　　　　　　　　　　  unsigned int map_size;　　　　　　　}
　　　　　　　　　　　　　　　　　　　　   }

～～～～～～～～～～～～～～～～～～～～～～～～～～～～～～～～～

複合關係下的構造和析構函數

Container<*>--------->Component

(內存較大)　　　　 （內存較小）

構造函數由內而外

Container的構造函數首先調用Component的default構造函數（默認構造函數），而後才執行本身。

Container::Container(...):　　Component()　　{...}

析構函數由外而內

Container的析構函數首先執行本身，而後才調用Component的析構函數。

Container::~Container(...)　　{...~Component()}

Delegation(委託).　　Composition by reference

class StringRep;　　　　　　　　　　　　　　　　　　　　　　　　　　　　#include "String.hpp"

class String{　　　　　　　　　　　　　　　　　　　　　　　　　　　　　   namespace{

　　public:　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　class StringRep{

　　　　String();　　　　　　　　　　　　　　　　　　　　　　　　　　　　　 friend class String;

　　　　String(const char* s);　　　　　　　　　　　　　　　　　　　　　　　　　　StringRep(const char* s);

　　　　String(const String& s);　　　　　　　　　　　　　　　　　　　　　　　　　~StringRep();

　　　　String &operator = (const Sting& s);　　　　　　　　　　　　　　　　　　　   int count;

　　　　~String(); 　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　char* rep;　

　　private:　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　};

　　　　StringRep* rep;　　　　　　　　　　　　　　　　　　　　　　　　　}

}

～～～～～～～～～～～～～～～～～～～～～～～～～～～～～～～～～～～

與複合不一樣的是，左邊的類被建立時，右邊的類未必須要建立。

右邊的進行變更時，並不會影響左邊的類。   或者稱爲編譯防火牆，當右邊類發生改變時，編譯器編譯右邊類時便可。

Inheritance(繼承),　　表示is-a

struct _list_node_base

{

　　_List_node_base*　　_M_next;

　　_List_node_base*　　_M_prev;

};

template<typename _Tp>

struct _List_node : public　_List_node_base

{

　　_Tp　_M_data;

}

～～～～～～～～～～～～～～～～～～～～～～～～～～～～～～～～

構造由內而外

Derived的構造函數首先調用Base的default構造函數，而後才執行本身。

Derived::Derived(...):Base() 　　{...}

析構由外而內

Derived的析構函數首先執行本身，而後才調用Base的析構函數。

Derived::~Derived(...) {... ~Base()};

base Class 的析構函數必須是virtual 不然會出現undefined behavior