侯捷C++面向对象高级编程

本文是学习笔记，仅供个人学习使用，如有侵权，请联系删除。

如果你对C++面向对象的组合、继承和委托不了解，对什么是拷贝构造、什么是拷贝赋值和析构不清楚，对类设计中的Adapter、pImpl、Template method、Observer、Composite、Prototype等设计模式认识不清，想知道在面向对象中如何引入设计模式，那么这门课就是你需要的。

学习地址：

Youtube: C++面向对象高级编程（侯捷）

B站: 侯捷C++之C++面向对象高级编程（上）

7 三大函数：拷贝构造、拷贝赋值、析构

Class with pointer member(s)

String class的框架

// string.h
#ifndef __MYSTRING__
#define __MYSTRING__

// 1
class String
{
    ...
};
// 2
String::function(...)...
Global-function(...)...
#endif
    
    
// string-test.cpp
int main()
{
    String s1();
    String s2("hello");
    
    String s3(s1);
    cout << s3 << endl;
    s3 = s2;
    cout << s3 << endl;
}

Big Three 三个特殊函数：拷贝构造，拷贝赋值，析构函数

class String
{
public:
    String(const char* cstr = 0);
    String(const String& str); // 拷贝构造，接收的是自己一样的类型String
    String& operator = (const String& str);  // 拷贝赋值
    ~String();  // 析构函数
    char* get_c_str() const {return m_data;}
private:
    char* m_data;
};

构造函数和析构函数

class里面有指针，多半要动态分配，对象要死亡之前，会调用析构函数，在析构函数里面释放掉动态分配的内存。

inline
String::String(const char* cstr = 0)
{
    if(cstr) {
        m_data = new char[strlen(cstr) + 1];  // +1是因为最后还有一个结束符号\0
        strcpy(m_data, cstr);
    }
    else {  // 未指定初值，设为空字符串
        m_data = new char[1];
        *m_data = '\0';
    }
}

inline
String::~String()
{
	delete[] m_data;
}

// 使用
{
    String s1();
    String s2("hello");
    
    String* p = new String("hello");
    delete p;
}

Class with pointer member(s)必须要拷贝构造和拷贝赋值

String a("hello");
String b("hello");

b = a;

使用默认拷贝构造或者默认拷贝赋值，会造成b的m_data指针指向a的空间，造成b原本指向的内存空间泄露（没有指针指向它），这个叫浅拷贝(只是指针指过去，不创建新的空间)

深拷贝：创建一份新的内存空间并拷贝过去

inline
String::String(const String& str)
{
	m_data = new char[strlen(str.m_data) + 1];
    strcpy(m_data, str.m_data);
}

// 使用
{
    String s1("hello");
    String s2(s1);
    String s2 = s1;
}

拷贝赋值操作 copy assignment operator

inline
String& String::operator=(const String& str)
{
    if(this == &str)  // 检测自我赋值
        return *this;
    delete[] m_data;  // 1. 先释放掉自己的部分的空间
	m_data = new char[strlen(str.m_data) + 1]; // 2.重新分配跟str一样大的空间
    strcpy(m_data, str.m_data); // 3.将str的内容拷贝到新分配的空间
    return *this;
}

// 使用
{
    String s1("hello");
    String s2(s1);
    String s2 = s1;
}

一定要在拷贝赋值操作里面检查自我赋值

如果是 s1 = s1，若没有检查自我赋值的情况下，首先会delete掉自己，然后重新分配右边的（自己）同样大小的空间就无从谈起了，会产生不确定的行为。

output函数

#include<iostream.h>
ostream& operator <<(ostream& os, const String& str)
{
    os << str.get_c_str();
    return os;
}

// 使用
{
    String s1("hello");
    cout << s1;
}

8 堆 栈和内存管理

所谓stack，所谓heap

Stack：是存在于某作用域的一块内存空间。例如当调用函数时，函数本身即会形成一个stack用来放置它所接收的参数，以及返回地址。

在函数体内声明的任何变量，其所使用的内存块都取自stack。

Heap：是指由操作系统提供的一块global内存空间，程序可变动分配从其中获得若干区块。

class Complex {...};
...
{
    Complex c1(1, 2);  // c1占用的空间来自stack
    Complex* p = new Complex(3); // 从堆动态分配而来
}

stack objects的生命期

c1就是所谓的stack object，其生命在作用域结束之际结束。这种作用域内的object，又被称为auto object，因为它会被自动清理。

static local objects的生命期

class Complex {...};
...
{
    static Complex c2(1, 2); 
}

c2便是所谓的static object,其生命在作用域结束之后依然存在，直到整个程序结束。

global objects的生命期

class Complex {...};
...
Complex c3(1, 2); 

int main()
{
    ...
}

c3便是所谓的global object，其生命在整个程序结束之后才结束。也可以把它视为一种static object，其作用域是整个程序。

heap objects的生命期

class Complex {...};
...
{
    Complex* p = new Complex(3); 
    delete p; // delete指针
}

p所指向的便是heap object，其生命在它被deleted之际结束。

class Complex {...};
...
{
    Complex* p = new Complex(3); 
}

以上出现内存泄漏（memory leak），因为当作用域结束，p所指向heap object依然存在，但指针p的生命却结束了，作用域之外再也看不到p（也就没机会delete p）。

new：先分配memory，再调用构造函数

Complex* pc = new Complex(1, 2);

// new被编译器转化为：
Complex *pc;
void* mem = operator new(sizeof(Complex)); // 1. 分配内存， operator new是一个函数名，内部调用malloc函数
pc = static_cast<Complex*>(mem); // 2. 转型
pc->Complex::Complex(1, 2); // 3. 构造函数

// 上面构造函数隐藏的this指针：
// 这里构造函数是成员函数，所以会有一个隐藏的this指针，谁调用这个函数，谁就是this
Complex::Complex(pc, 1, 2);// 这里pc就是this，只不过它是隐藏的

delete：先调用析构函数，再释放内存

Complex* pc = new Complex(1, 2);
delete pc;

// delete被编译器转化为：
Complex::~Complex(pc); // 1. 析构函数
operator delete(pc);// 2. 释放内存, delete内部调用free(pc)，operator delete是一个函数名

array new 一定要搭配array delete

String* p = new String[3];
delete[] p; // 唤起3次析构函数，正确的用法

//错误的用法，不加[]
String* p = new String[3];
delete p; // 唤起1次析构函数，错误的用法

9 复习String类的实现过程

String类的具体类，构造函数，成员函数等如上面的笔记所示。

10 扩展补充：类模板，函数模板及其他

进一步补充：static

静态成员：当类的成员被定义为静态的时候，无论创建多少个类的对象，静态成员的副本只有一个。静态成员在类的所有对象中是共享的。

静态成员函数：可以把函数和类的对象独立开来，静态成员函数可以在类的对象不存在的情况下被调用。静态成员函数只能访问静态成员数据、其他静态成员函数和类外部的其他函数。

static function静态函数没有this指针

静态变量的初始化不能放在类的定义中，在类的外部来重新声明来进行初始化。

C++ 类的静态成员

银行的例子：利率为静态变量

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);
    Account a;
    a.set_rate(7.0);
}

调用static函数的方式有：

（1）通过object调用

（2）通过class name调用

构造函数可以被放在private区，在设计模式中，单例模式（singleton）便是这样做的

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

A& A::getInstance() 
{
    static A a;  //只有调用的时候，A才会创建，离开这个函数之后，静态变量A依然存在
    return a;
}

外界调用时

A::getInstance().setup();

没有人使用单例的话，这个单例就不存在；一旦有人用了一次，单例才出现，并且只有一份。

进一步补充 cout

cout是一种ostream，这里对<<进行了各种各样的重载，所以cout可以打印输出各种各样的数据。

进一步补充：class template 类模板

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;
    friend complex& __doapl(complex*, const complex&);
};

// 使用模板的例子，指定T的具体类型
{
    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 进行引数推导

template<class T>  // 引数推导的结果，T为stone，于是调用stone::operator<
inline
const T& min(const T&, const T&, b)
{
    return b < a ? b : a;
}

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

命名空间定义了上下文，它可作为附加信息来区分不同库中相同名称的函数、类、变量等。命名空间

namespace name
{
	...
}

11 组合与继承

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

把上面的class Sequence = deque替换进来

class queue {
...
protected:
    deque<T> 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();}
};

其中 queue里面has a deque，就是复合关系

这里还有设计模式中的Adapter模式，queue使用deque开放的6个函数，改头换面改装适配一下。这里谁是adapter呢？queue。

UML类图中使用黑色菱形代表复合。

从内存的角度看一下composition

如下图，Itr里面有4个指针，大小共为16B；deque里面有2个Itr、1个指针、1个unsigned int，每个Itr的大小为16B，deque大小共为40B；queue里面有deque，故为40B。

Composition复合关系下的构造和析构

构造由内而外

Container的构造函数首先调用Component的默认构造函数，然后才执行自己。这是编译器帮我们做的。

Container::Container(...): Component() {...};

析构由外而内

Container的析构函数首先执行自己，然后才调用Component的析构函数。

Container::~Container(...) {... ~Component() };

Delegation委托. Composition by reference

还是Container“有“ component，只是有一个指针指向另一个component，比如下面的String类中rep指针，指向StringRep类。

UML类图中用白色的菱形表示委托。

// 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.hpp"
namespace {
class StringRep{
friend class String;
    StringRep(const char* s);
    ~StringRep();
    int count;
    char* rep;
};
}

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

pimpl：pointer to Implementation，另一个名字叫做handle/body

外界看到的是左边的接口，而右边的实现通过一个指针指向，外界看不到。

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

UML类图中使用空心的三角形表示继承，从子类指向父类

继承关系下的构造和析构

父类是Base，Derived是派生类，派生类的对象里面有父类的成分在里面。

构造由内而外

Derived的构造函数首先调用Base的默认构造函数，然后才执行自己。

Derived::Derived(...): Base() {...};

析构由外而内

Derived的析构函数首先执行自己，然后才调用Base的析构函数。

Derived::~Derived(...) {... ~Base()};

base class的析构函数必须是virtual，否则会出现undefined behavior。

12 虚函数和多态

Inheritance with virtual functions 虚函数

non-virtual函数：不希望derived class重新定义

virtual函数：希望derived class重新定义（override），且它已有默认定义。

pure virtual函数：希望derived class一定要重新定义，对它没有默认定义

class Shape{
public:
    virtual void draw() const = 0;  // 纯虚函数， 被子类重新定义
    virtual void error(const std::string& msg);  // 虚函数， 父类有默认的定义
    int objectID() const;
};
class Rectangle:public Shape{...};
class Ellipse:public Shape{...};

打开文件的例子

这种写法是一个大名鼎鼎的设计模式：Template method

函数的一个动作延缓到子类去实现。应用框架先把固定功能的函数写好，遇到无法决定的函数把它写成虚函数，让应用这个框架的子类去定义它。

13 委托相关设计

委托和继承

Observer设计模式：定义了一种一对多的依赖关系，当一个对象的状态发生改变时，其所有依赖者都会收到通知并自动更新。

Subject：比如excel中的数据

Observer：使用者可以开多个窗口来观察Subject，比如使用柱状图、折线图等不同的窗口来观察excel中的数据。这就是通过派生子类来实现的。

Subject和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_view.size(); ++i)
            m_views[i]->update(this, m_value);
    }
};

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

Composite设计模式

组合模式（Composite Pattern），又叫部分整体模式，是用于把一组相似的对象当作一个单一的对象。

这里是用Primitive，Composite和Component三个类合作完成的。Composite类想要放不同类的对象，这样让不同的类继承自同一个父类，这样就可以把父类的指针存在Composite里，从而实现把一组相似的对象都存进来。

Prototype设计模式

原型模式

原型模式（Prototype Pattern）是用于创建重复的对象，同时又能保证性能。这种模式是实现了一个原型接口，该接口用于创建当前对象的克隆。

遇到问题：如下图所示，波浪线上面是提前写好的类，但是它要用到未来才出现的类，该怎么办呢？

波浪线下面的类继承上面的类，然后调用父类的addPrototype将自己添加到父类的空间，让父类看到子类。子类调用clone函数生成自己的拷贝。

父类如下：

子类如下:下图中的ctor指的是构造函数