class template类模板

template <typename T>
class complex {
public:
    complex (T r = 0, T i = 0)
            : re (r), im (r)
    { }
    complex& operator += (const complex&);
    T real () const { return re; }
    T imag () const { return im; }

private:
    T re, im;
    friend complex& __doapl (complex*, const complex&);
};
//调用的时候会将T类型自动替换成调用的类型 类似java的泛型
{
    complex<double> c1(2.5,1.5);
    complex<int> c2(2,6);
}

function template函数模板

    stone r1(2,3), r2(3,3), r3;
    r3 = min(r1, r2);
//编译器会对function template进行引数推导(argument deduction)

template <class T>
inline
const T& min(const T& a, const T& b) {
    return b < a ? b : a;
}
//和java的comparable一样,要进行重写(操作符重载)
class stone {
public:
    stone(int w, int h, int we)
        : _w(w), _h(h), _weight(we)
            { }
    bool operator< (const stone& rhs) const {
        return _weight < rhs._weight;
    }

private:
    int _w, _h, _weight;
};

namespace

//using directive 导入整个命名空间
using namespace std;
//using declaration 声明某个空间内的函数
using std::cout;

OOP & OOD

Composition 复合, has-a

queue是一个容器,容纳(拥有)了deque
请输入图片描述
从内存大小可以看出来,一个queue拥有了一个deque,deque拥有两个Itr

//一个Adapter
template <class T>
class queue {
    ...
protected:
    deque<T> c;
public:
    //可以看出,queue本身的方法也是通过调用底层容易deque的方法实现了
    bool empty() const { return compl c.empty(); }
    size_type size() const { return c.size(); }
    reference front() { return  c.front(); }
    reference back() { return c.back(); }

    void push(const value_type& x) { c.push_back(x); }
    void pop() { c.pop_front(); }
};

Composition下的构造与析构

请输入图片描述
构造由内而外
Container的构造函数先调用Component的default构造函数,然后才执行自己
Container::Container(...): Component() { ... };
析构由外而内
Container的析构函数先执行自己,再调用Component的析构
Container::~Container(...): ~Component() { ... };

Delegation 委托, Composition by reference

请输入图片描述
委托和复合的区别是:委托关系中,其耦合是通过指针进行的(是一种虚的关系)
复合关系中,A和B的生命周期是一致的;而在委托中,是顺次进行的
委托类似java中的接口和实现类关系,A将具体的实现通过指针交予B处理

//Handle /Body 
/*file String.hpp*/
class StringRep;
class StringRep {
public:
    String();
    String(const char* s);
    string(const String& s);
    String &operator = (const String& s);
    ~String ();
    ...
private:
    StringRep* rep; //pimpl,pointers to implements
};

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

Inheritance 继承, is-a

请输入图片描述
类似java中的继承,子类指向父类,子类包含整个父类,但子类在父类的基础上有其他特有的属性

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

Inheritance下的构造与析构

构造由内而外
Derived的构造函数先调用Base的default构造函数,然后才执行自己
Derived::Derived(...): Base() { ... };
析构由外而内
Derived的析构函数先执行自己,再调用Base的析构
Derived::~Derived(...): ~Base() { ... };
base class的dtor必须是virtual,否则会出现undefined behavior

virtual functions虚函数

non-virtual函数:不希望derived class重写(Override)的函数
virtual:希望derived class Override的,它已经有默认定义
pure virtual函数:derived class必须要override的,没有默认定义(类似java的abstract修饰)

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 { ... };

思考:执行的顺序是怎么样的呢?

请输入图片描述

file Random.h
#ifndef CPP_RENSYU_RANDOM_H
#define CPP_RENSYU_RANDOM_H
#include "iostream"

class typea { //base
public:
    typea() { std::cout << "create a" << std::endl; };
};

class typeb {  //component
public:
    typeb() { std::cout << "create b" << std::endl; };
};

class typec : typea {  //derived
protected:
    typeb d;
public:
    typec() { std::cout << "create c" << std::endl; };
};

#endif CPP_RENSYU_RANDOM_H

file main.cpp
#include "iostream"
#include "random.h"

int main() {
    typec* p = new typec();
}

result of execution:
create a
create b
create c
//即base -> component -> dervied
Process finished with exit code 0

至于第二个图,很容易能从逻辑上推导,创建顺序应该是component part-> base part -> Derived object

Delegation+Inheritance

请输入图片描述

//Observer模式
class Subject {
    int m_value;
    vector<Observer*> m_views;
public:
    void attach(Observer* obs) {
        m_views.push_back(obs);
    }
    void set_val(int value) {
        m_value = value;
        notify();
    }
    void notify() {
        for (int i = 0; i < m_views.size(); ++i) {
            m_views[i]->update(this,m_value);
        }
    }
};

class Observer {
public:
    virtual void update(Subject* sub);
};