C++面对对象高级编程——复合、委托与继承

C++面对对象高级编程——复合、委托与继承

🌍复合、委托与继承

• 本节主要探讨的是类与类之间的关系。
  

  
  

• 包含Inheritance（继承）、Composition（组合）和Delegation（委托）三种关系。
  

  
  

🌳Composition（组合）

template<class T,class Sequence = deque<t>> 
class queue{
......
protected:
	sequence c;  //底层dequed容器
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& x) {c.push_back(x);}
	void pop() { c.pop_frond();}
	};

上述代码等效为

template<class T> 
class queue{
......
protected:
	deque<T> c;  //底层dequed容器
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& x) {c.push_back(x);}
	void pop() { c.pop_frond();}
	};

🍀组合关系特点
从上面可以看出

• queue容器内含一个deque容器；
• queue容器 *** 作函数也是封装了deque的函数

以上两种特点表示了queue have a deque,属于类的组合关系。

🍀组合类的大小计算

Itr类16字节

template <class T>
struct Itr{
	T* cur;//指针4字节
	T* first; //指针4字节
	T* last;//指针4字节
	T** node;//指向指针的指针，4字节；
	..........
	};

deque类40字节

template <class T>
class deque{
protected:
	Itr<T> start;//Itr对象16字节
	Itr<T> finsih;//Itr对象16字节
	T** map;//指向指针的指针4字节
	unsigned int map_size;//4字节
	};

queue类40字节

template<class T>
class queue{
protected：
	deque<T> c;//deque类型为40字节
	};

代码如上所示，queue类内有一个queue类，无其它数据，queue类的大小等于queue类的大小。

🍀Composition（组合）关系下的构造与析构

container object形如的queue类，component part形如本例中的deque类。

component part组成了container object。

• 构造由内而外
  container的构造函数首先调用component的默认构造函数，然后再调用自己的构造函数。
  

  
  

• 析构由外而内
  container首先析构自己，然后再析构component的析构函数。
  

  
  

例如：在构造queue对象时，queue类的构造函数先调用deque的构造函数，再执行自己的构造函数。

析构时先执行自己的析构函数，再执行deque的析构函数。

🌳Delegation（委托） Composition by reference（通过引用来组合）

//file1 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; //通过指针指向另外一个对象来组合成String对象，成为委托；此设计为pimpl设计模式

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

• String类中的StringRep * rep;通过指针rep指向StringRep对象，在任何需要StringRep对象的时候就可以通过指针来构造，把String类的工作交给StringRep类来做。
  

  
  

  这种特殊的组合称之为委托，是通过指针来实现的。
  

  
  

  但是我们一般把通过指针实现的方法说成通过引用来实现，实际上不是引用，只是说成Composition by reference（通过引用来组合）。
  

  
  

• 当String类创建时，StringRep类不一定创建。
  

  
  

🌳继承

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_date;
};

程序中struct _List_node: public _List_Node_base表示struct _List_node类公有继承_List_Node_base类，struct _List_node类拥有了_List_Node_base类的全部数据。

🍀继承关系下的构造与析构

• 构造由内而外
  Derived object(派生对象）首先调用Base（基类）的默认构造函数，再调用自己的默认构造函数。
  

  
  

• 析构由外而内
  Derived object首先析构自己，再调用Base类的析构函数。