Object Oriented Programming(OOP)/Object Oriented Design(OOD)
- Inheritance(继承)
- Composition(复合)
- Delegation(委托)
Composition(复合)，表示 has-a
template <class T, class Sequence = deque<T>>
class queue
{
…
protected:
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& x) { c.push_back(x); }
void pop() { c.pop_front(); }
};
以上的设计模式被称为Adapter，将原有的类包装，只开放部分功能。
构造由内而外
Container 的构造函数首先调用 Component 的 default 构造函数，然后才执行自己。（若要执行非默认的构造函数，需要手动写出要调用的构造函数）
Container::Container(…): Component() { … };
析构由外而内
Container 的析构函数首先执行自己，然后才调用 Component 的析构函数。
Container::~Container(…) { … ~Component(); };
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
};
// file String.cpp
#include "String.cpp"
namespace
{
class StringRep
{
friend class String;
StringRep(const char* s);
~StringRep();
int count;
char* rep;
};
}
String::String() { …; }
…
以上的设计模式被称为Handle/Body(pImpl)，里面包含一个指针指向实现全部功能的类。
count的功能是做reference counting。
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 的 dtor 必须是 virtual ，否则会出现 undefined behavior。
Inheritance(继承) with virtual functions(虚函数)
- non-virtual 函数：你不希望 derived class 重新定义(override，覆写)它。
- virtual 函数：你希望derived class 重新定义(override，覆写)它，且你对它已有默认定义。
- pure virtual 函数：你希望 derived class 一定要重新定义(override，覆写)它，你对它没有默认定义。
class Shape
{
public:
virtual void draw() const = 0; // pure virtual
virtual void error(const std::string& msg); // impure virtual
int objectID() const; // non-virtual
};
class Rectangle:public Shape{ … };
class Ellipse:public Shape{ … };
以下的设计模式被称为Template Method。
#include <iostream>
using namespace std;
class CDocument
{
public:
void OnFileOpen()
{
// 这是个算法，每个 cout 输出代表一个实际动作
cout << "dialog..." << endl;
cout << "check file status..." << endl;
cout << "open file..." << endl;
Serialize();
cout << "close file..." << endl;
cout << "update all views..." << endl;
}
virtual void Serialize() { };
};
class CMyDoc :public CDocument
{
public:
virtual void Serialize()
{
// 只有应用程序本身才知道如何读取自己的文件(格式)
cout << "CMyDoc::Serialize()" << endl;
}
};
int main()
{
CMyDoc myDoc; // 假设对应[File/Open]
myDoc.OnFileOpen();
}
Inheritance+Composition 关系下的构造和析构
测试代码如下：
#include <iostream>
class Base;
class Component;
class Derived;
class Base
{
public:
Base()
{
std::cout << "The ctor of class Base has completed" << std::endl;
}
};
class Component
{
public:
Component()
{
std::cout << "The ctor of class Component has completed" << std::endl;
}
};
class Derived :public Base
{
public:
Derived(int n) :n(n)
{
std::cout << "The ctor of class Derived has completed" << std::endl;
}
private:
int n;
Component a;
};
int main()
{
Derived d(2);
system("pause");
return 0;
}
