[C++知识库]C++_3_面向对象编程

面向对象编程的基本思想

static扩充

• 类中的成员可分类为
  • 数据成员
  • 函数成员
  • 其中，未被static修饰的均为非静态成员，需要通过实例化得以调用
  • 换言之，非静态的成员属于对象，在实际调用过程中，是通过传入this指针，区分不同对象所调用的函数
  • 静态成员则属于类，其函数在调用其参数列表中不会有this

    class Account{
    public:
        static double m_rate;
        static void set_rate(const double& x) { m_rate=x };
    }
    // 静态成员初始化
    double Account::m_rate = 8.0;

    int main(){
        // 调用Static函数的方式有二
        // 通过object Or class name
        Account::set_rate(5.0);

        Account a;
        a.set_rate(7.0);
    }

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

class template

    class A{
    public:
        static A& getInstance();
        setup() {...};
    private:
        A();
        A(const A& rhs);
        ...
    }

    // 方式优势在于未被调用时，不会占有额外的空间
    // 调用后，由于static的特性，仍会存在
    A& A::getInstance(){
        static A a;
        return a;
    }

function template

    template <class T>
    inline 
    const T& min(const T& a, cont T& b){
        return b < a ? b : a;
    }

    class stone{
    public:
        stone(int w, int h, int we)
            : _w(w), _h(h), _we(we) {}
        bool operator< (const stone& rhs) const{
            return _weight < rhs._weight;
        }
    private:
        int _w, _h, _weight;
    }

    int main(){

        stone r1(2, 3), r2(2, 2), r3;
        r3 = min(r1, r2);

        return 0;
    }

Composition 复合

• 核心思想：限制一些现有的功能，实现一个新的对象

    template <class T, class Sequence = deque<T>>
    class queue{
        ...
    protected:
        Sequence c;     // 底层容器
    private:
        bool empty() const { return c.empty() }
        void pop()  { c.pop_front(); }
    } 

• 构造过程：由内而外 | 析构过程：由外而内

Delegation 委托

    // file String.hpp
    class StringRep;
    class String{
    public:
        String();
        String(const char* s);
        ...
    private:
        StringRep* rep; // pimpl (handle/body)
    }

    // file String.cpp
    class StringRep{
    friend class String;
        StringRep (const char* s);
        ~StringRep();
        int cnt;
        char* rep;
    }

Inheritance 继承

    struct _List_node_base{
        _List_node_base* _M_next;
        _List_node_base* _M_prev;
    }

    template<typename T>
    struct _List_node : public _List_node_base{
        _Tp _M_data;
    }

虚函数

分类

• non-virtual 有定义，不渴望重写
• virtual 有定义，渴望重写
• pure virtual 无定义，一定要重写

    class Shape{
    public:
        // pure virtual
        virtual void draw() const = 0;
        // virtual
        virtual void error(const char* msg);
        // non-virtual 
        int objectID() const;
    }

Template Method 设计模式

• 基于虚函数实现
• 基本思想是将通用点的部分写出来，然后按需定义接口
• 经典案例MFC
• 
• 此情形构造顺序应该是父类->contain->子类

Observer 设计模式

• 核心思想在于一种数据以多种不同的方式展现
• 子类可以对父类的元素产生改动，且此改动能被余下子类收到

    class Observer{
    public:
        virtual void update(Subject* sub, int val) = 0;
    }

    class Subject{
        int m_val;
        vector<Observer *> m_views;
    public:
        void set_val(int val){
            m_val = val;
            notify();
        }
        void notify(){
            for(auto it:m_views){
                it->update(this, m_val);
            }
        }
    }

Composite 设计模式

• 
• 核心目的在于用存放两种不同的数据
• 实现方式则是通过为不同类型的数据构造同一个父类而解决的

protype 设计模式

• 
• -代表private、+代表public、#代表protected、变量名：函数
• 核心思想在于古旧的类来存储新的原型，用静态的数组进行存储
• Protected部分的构造函数目的在于进行clone操作时，不能调用原有的构造函数，否则会向数组中添加多余的原型
  • 存储位置可在private、protected
  • 通过添加额外的参数，区分与原有的构造函数
• 额外开销：需要拥有一个静态的自己、需要一个私有的构造函数、需要一个clone函数
• PS：static成员需要额外的定义