侯捷C++面向对象高级编程
本文是学习笔记,仅供个人学习使用,如有侵权,请联系删除。
如果你对C++面向对象的组合、继承和委托不了解,对什么是拷贝构造、什么是拷贝赋值和析构不清楚,对类设计中的Adapter、pImpl、Template method、Observer、Composite、Prototype等设计模式认识不清,想知道在面向对象中如何引入设计模式,那么这门课就是你需要的。
学习地址:
Youtube: C++面向对象高级编程(侯捷)
B站: 侯捷C++之C++面向对象高级编程(上)
文章目录
- 侯捷C++面向对象高级编程
- 7 三大函数:拷贝构造、拷贝赋值、析构
- 8 堆 栈和内存管理
- 9 复习String类的实现过程
- 10 扩展补充:类模板,函数模板及其他
- 11 组合与继承
- Composition复合,表示has-a
- Delegation委托. Composition by reference
- Inheritance(继承),表示is-a
- 12 虚函数和多态
- 13 委托相关设计
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指的是构造函数