C++面向对象高级编程(侯捷)笔记2

news2024/11/13 8:50:08

侯捷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指的是构造函数

在这里插入图片描述

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处:http://www.coloradmin.cn/o/1354667.html

如若内容造成侵权/违法违规/事实不符,请联系多彩编程网进行投诉反馈,一经查实,立即删除!

相关文章

Linux的systemctl命令

Linux系统很多软件均支持使用systemctl命令控制&#xff1a;启动、停止、开机自启 形式&#xff1a; systemctl start | stop | status | enable | disable 服务名 enable : 自启动 disable : 关闭自启动 系统内置的服务比较多&#xff0c;比如&#xff1a; NetworkManage…

B01、运行时数据区概述-03

1、什么是内存 内存是非常重要的系统资源,是硬盘和CPU的中间仓库及桥梁,承载着操作系统和应用程序的实时运行。JVM内存布局规定了Java在运行过程中内存申请、分配、管理的策略,保证了JVM的高效稳定运行。不同的JVM对于内存的划分方式和管理机制存在着部分差异。 2、线程共享和…

可狱可囚的爬虫系列课程 08:新闻数据爬取实战

前言 本篇文章中我带大家针对前面所学 Requests 和 BeautifulSoup4 进行一个实操检验。 相信大家平时或多或少都有看新闻的习惯&#xff0c;那么我们今天所要爬取的网站便是新闻类型的&#xff1a;中国新闻网&#xff0c;我们先来使用爬虫爬取一些具有明显规则或规律的信息&am…

华芯微特MCU之TIMER触发ADC

01 TIMER定时器之脉冲发送功能 我们今天详细讲解一下TIMER的ADC触发功能。 SWM190的TIMER2/3支持SAR ADC触发功能&#xff0c;此功能配置为定时器或脉冲发送均有效&#xff0c;可通过配置相应寄存器实现。 将SAR ADC CTRL寄存器中TRIG设置为TIMER2触发或TIMER3触发。TIMER可作…

GZ075 云计算应用赛题第5套

2023年全国职业院校技能大赛&#xff08;高职组&#xff09; “云计算应用”赛项赛卷5 某企业根据自身业务需求&#xff0c;实施数字化转型&#xff0c;规划和建设数字化平台&#xff0c;平台聚焦“DevOps开发运维一体化”和“数据驱动产品开发”&#xff0c;拟采用开源OpenSt…

C++上位软件通过Snap7开源库访问西门子S7-200/合信M226ES数据块的方法

前言 上一篇文章中介绍了Snap7访问西门子S7-1200/S7-1500 DB块的方法&#xff0c;对于S7-200PLC是没有数据块访问的。S7-200PLC中Snap7只能通过访问MB块&#xff0c;VB块的方法进行和PLC之间的Snap7通信和数据交换。手头没有S7-200PLC故通过合信CTMC M226ES运动控制器进行测试&…

【CANopen】关于STM32中CanFestival的pdo应用

系列文章目录 文章目录 系列文章目录一、发送1、同步传输2、异步传输 二、接收 使用STM32F407单片机 pdo属于过程数据用来传输实时数据&#xff0c;即单向传输&#xff0c;无需接收节点回应。 一、发送 分为同步传输和异步传输。 1、同步传输 分为循环传输&#xff08;周期…

看板表格样式,去掉element表格背景

<div class"ml-20"><el-input v-model.trim"queryParams.wipOrderNo" size"small" clearable style"width:150px" placeholder"请输入工单号" /><el-select class"ml-20" v-model"queryParam…

Ubuntu18.04配置静态ip

文章目录 查看网卡名、ip地址、网关切换root用户&#xff0c;进入配置文件配置静态IP 查看网卡名、ip地址、网关 首先查看网卡名、ip地址、网关&#xff0c;找到对应的网卡名并记录其地址 ifconfigroute -n切换root用户&#xff0c;进入配置文件 sudo -icd /etc/netplanvim …

服务器终端快速下载coco数据集

######解压到当前文件夹 sudo apt-get install aria2 aria2c -c <url> #<url>即为官网下载地址# url # download images http://images.cocodataset.org/zips/train2017.zip http://images.cocodataset.org/zips/val2017.zip# download annotations http://i…

CEC2017(Python):蜣螂优化算法DBO求解CEC2017

一、CEC2017简介 参考文献&#xff1a; [1]Awad, N. H., Ali, M. Z., Liang, J. J., Qu, B. Y., & Suganthan, P. N. (2016). “Problem definitions and evaluation criteria for the CEC2017 special session and competition on single objective real-parameter numer…

cnPuTTY 0.80.0.1—PuTTY Release 0.80中文版本简单说明~~

2023-12-18 官方发布了PuTTY 0.80本次发布主要是针对Terrapin攻击(CVE-2023-48795)的修改发布。 更多详细的内容请查看PuTTY Change Log。 有关Terrapin攻击可用简单参考&#xff1a;警告&#xff01;&#xff01;&#xff01;Terrapin攻击(CVE-2023-48795)~~~ 为了缓解此漏洞…

学习JavaEE的日子 day08 方法的重载,递归,万年历

day08 1.方法的重载 >理解&#xff1a;方法与方法之间的关系> 条件&#xff1a;> 1.方法必须在同一个类中> 2.方法名必须一致> 3.参数列表的个数或者类型不一致> 4.与返回值无关> 好处&#xff1a;系统会根据具体实参类型自动匹配到对应的方法…

【Bug】Android BottomNavigationView 图标黑色色块问题

最近在研究Android Jetpack组件&#xff0c;在使用Navigation配合底部导航栏时&#xff0c;发现一个奇怪的问题&#xff0c;如下&#xff1a; 说明&#xff1a;图标来源于Iconfont开源图标库 我的第三个图标变成了一个黑色色块&#xff0c;这个问题前两天我遇见过&#xff0c…

Java 跨平台实现

Java 跨平台实现 1. Java虚拟机&#xff08;JVM&#xff09;2. 中间代码&#xff08;字节码&#xff09;3. Write Once, Run Anywhere (WORA)4. Java 标准库5. 安全性与隔离6. Java Community Process (JCP) Java 的跨平台性主要是通过以下几个关键机制来实现的&#xff1a; 1…

安克创新与火山引擎数智平台开展合作:数据分析降门槛 数据协同破边界

更多技术交流、求职机会&#xff0c;欢迎关注字节跳动数据平台微信公众号&#xff0c;回复【1】进入官方交流群 近日&#xff0c;消费电子品牌安克创新与火山引擎数智平台&#xff08;VeDI&#xff09;达成合作&#xff0c;双方将聚焦安克创新大数据平台的海量数据分析场景&…

听GPT 讲Rust源代码--compiler(4)

File: rust/compiler/rustc_codegen_gcc/src/back/mod.rs rust/compiler/rustc_codegen_gcc/src/back/mod.rs 文件是 Rust 编译器的源代码中的一个模块&#xff0c;主要负责与 GCC&#xff08;GNU 编译器集合&#xff09;相关的后端代码生成。 在 Rust 编译器的架构中&#xff…

Laya游戏开发中AI寻路解决方案

1.AI自动寻路&#xff1a; 机器人代码重构&#xff0c;按照目标点去执行逻辑&#xff0c;提前几帧判断直线&#xff0c;非直线的情况下&#xff0c;预设转弯角度&#xff0c;角度判断到达直线后开始执行到目标点的逻辑 2.U3D布点寻路 3.NevMesh.Js寻路插件 NevMesh.Js你可以在L…

顶顶通呼叫中心中间件通过队列外呼拨打另一个sip并且放音(mod_cti基于FreeSWITCH)

介绍 顶顶通呼叫中心中间件通过队列外呼拨打另一个sip并且放音 一、添加acl 打开ccadmin->点击配置文件->点击acl.conf->在</list>后面添加一条图中的信息->muqi是我自己设置的名字你们可以修改为自己需要的名字->添加好了点击提交XML->在运维调试点…

【数据仓库与联机分析处理】数据仓库

目录 一、数据仓库的概念 二、数据仓库与操作性数据库的区别 三、发展前期 四、数据仓库的系统结构 五、建模划分 六、主要案例 一、数据仓库的概念 目前很难给数据仓库&#xff08;Data Warehouse&#xff09;一个严格的定义&#xff0c;不准确地说&#xff0c;数据仓库…