C++: 面向对象简介

class String
{
public:                                 
   String(const char* cstr=0);                     
   String(const String& str);                    
   String& operator=(const String& str);         
   ~String();                                    
   char* get_c_str() const { return m_data; }
private:
   char* m_data;
};

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() {
  Account::set_rate(5.0);  // 通过 class 名调用

  Account a;
  a.set_rate(7.0);  // 通过 class 实例调用
}

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

A& A::getInstance() {
  static A a;  // 第一次调用时，才会创建 a
  return a;
}

namespace std {
    // ...
}

#include<iostream>
using namespace std; 

int main() {
    cin >>  ...;
    cout << ...;
}

#include<iostream>
using std::cout;

int main() {
    std::cin >> ...;
    cout << ...;
}

#include<iostream>

int main() {
    std::cin >> ...;
    std::cout << ...;
}

template <typename 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 是 first in first out
    void push(const value_type& x) { c.push_back(x); }
    void pop() { c.pop_front(); }
};

// 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; // 负责具体的实现
};

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

String::String() { ... }
}

#include <iostream>

int main() {
    string s("Hello");  // 创建 string s，假设背后的 StringRep 为 sr; sr.count == 1
    string s1(s);       // 创建 string s1, 背后仍然是 sr; sr.count == 2
    s1[0] = 'h';        // 修改 s1 不影响 s，为 s1 创建一个新的 StringRep 对象; src.count == 1
    string s2 = s;         // 创建 string s2, 背后仍然是 sr; sr.count == 2
    string* ps1 = new string(s); // 创建 string 指针 ps1, 背后对象仍然是 sr; sr.count == 3
    delete ps1;            // 删除 ps1，sr.count == 2
    
    string t("Hello");   // 创建 string 对象 t，t 背后的 StringRep 不是 sr，而是一个全新的 StringRep对象
    
    // main 函数退出时，这些变量都会被析构掉。
}

// Subject 类的设计
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);
        }
    }
};

// Observer 类的设计
class Observer {
public:
    virtual void update(Subject* sub, int value) = 0;
}

// Component 类 （base class)
class Component {
    int value;
public:
    Component(int val): value(val){}
    virtual void add(Component* elem) {}  // 默认实现不做任何事情
};

// Primitive 类 (对应 文件系统中的“文件”)
class Primitive : public Component{
public:
    Primitive(int val): Component(val) {}
};

// Composite 类 (对应 文件系统中的“目录”)
class Composite : public Component {
    vector<Component*> c;
public:
    Composite(int val): Component(val) {}
    
    void add(Component* elem) {
        c.push_back(elem);
    } 
}

#include <iostream>
enum imageType {
    LSAT, SPOT
};

// 父类 Image 的实现
class Image {
public:
    virtual void draw() = 0;
    static Image* findAndClone(imageType);
protected:
    virtual imageType returnType() = 0;
    virtual Image* clone() = 0;
    // 每增加一个子类，都要注册到 prototype 中
    static void addPrototype(Image *image) {
        _prototypes[_nextSlot++] = image;
    }
private:
    // addPrototype() 方法 将注册的 prototype 存放在这个变量中
    static Image* _prototypes[10];
    static int _nextSlot;
};

// 初始化 static 变量
Image* Image::_prototypes[10];
int Image::_nextSlot;

// Client 调用 这个 public 方法创建 Image的子类的对象
Image* Image::findAndClone(imageType type) {
    for(int i = 0;i < _nextSlot; i++) {
        if( _prototypes[i]->returnType() == type) {
            return _prototypes[i]->clone();
        }
    }
}

// 子类 LandSatImage 的实现
class LandSatImage : public Image {
public:
    imageType returnType() { return LSAT; }
    void draw() { cout << "LandSatImage::draw " << _id << end; }
    Image* clone() { return new LastSatImage(1); } // 只在注册的时候调用，创建时不能调用
protected:
    // 只能从clone 方法调用，不要从其它位置调用
    LandSatImage(int dummy) { // 这个参数没有任何意义，只是为了与默认构造函数区分开
        _id  = _count++;  // id 用来标示 该对象 是 clone() 方法创建的第几个对象
    }
private:
    // 这里，静态的 _landSatImage 被初始化时，会调用默认构造函数 LandSatImage(), 
    // 默认构造函数 会调用 addPrototype 方法 将自己注册到父类。
    static LandSatImage _landSatImage;
    LandSatImage() {
        addPrototype(this);
    }

    int _id;
    static int _count;
};

// 初始化操作在这里
LandSatImage LandSatImage::_landSatImage;

// 该变量对 clone 方法创建的对象进行计数
int LandSatImage::_count = 0;