组合与继承

类和类之间的关系

/********************

继承，复合，委托

********************/

一、复合
template <calss,calss Sequence = deque<T>>//默认Sequence 是这种类型
//我里面有另外一种东西，那么就是代表复合
template <class T>
class queue
{
protected:
deque<T> c;
public:
bool empty() const{return c.empty();}//全都调用的c完成的
size_type size() const{return c.size();}
};

//A拥有B,A的功能都让B来做。

二、复合下的构造和析构

1、构造由内而外

外部的构造函数收先调用内部的default函数，然后再执行自己

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

2、析构由外而内

Container 的析构函数首先执行自己，然后才调用Component的析构函数

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

三、 委托（Delegation）（Composition By reference）

class StringRep;
class String
{
public:
String();
String(const char* s);
String (const String& s);
~String();
private:
StringRep *rep;


};
class StringRep
{
friend class String;
StringRep(const char* s);
}

String中有一个指针指向StringRep，这就叫做委托，意思是我在任何时间点，我都可以调用你。把任务委托给你

四、继承（表示 is-a）

struct _List_node_base
{
_List_node_base* _M_next;
_List_node_base* _M_prev;
};
template <typename _Tp>
struct _List_node
:public _List_nde_base//继承
{
_Tp _M_data;
};                                                                       

子类的对象里面有父类的成分在里面

五、继承关系下的析构和构造

构造由内而外 Dreived的构造函数首先调用Base的default的构造函数，然后再执行自己

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

析构由外而内 Derived的析构函数首先执行自己，然后才调用Base的析构函数

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