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