C++程序设计兼谈对象模型（侯捷）笔记

C++程序设计兼谈对象模型（侯捷)

这是C++面向对象程序设计的续集笔记，仅供个人学习使用。如有侵权，请联系删除。

主要内容：涉及到模板中的类模板、函数模板、成员模板以及模板模板参数，后面包含对象模型中虚函数调用（动态绑定）的具体原理。

参考链接：

Youtube: C++面向对象高级开发（下）

Github：源码和PPT

文章目录

  • C++程序设计兼谈对象模型（侯捷)
    • 2 conversion function 转换函数
    • 3 non-explicit-one-argument constructor
    • 4 pointer-like classes
    • 5 function-like classes
    • 6 namespace经验谈
    • 7 class template 类模板
    • 8 function template 函数模板
    • 9 member template 成员模板
    • 10 specialization 模板特化
    • 11 模板偏特化
    • 12 模板模板参数
    • 13 关于C++标准库
    • 14 三个主题 variadic templates等
    • 15 reference
    • 16 复合&继承关系下的构造和析构
    • 17 （对象模型）关于vptr和vtbl，虚指针和虚表
    • 18 （对象模型）关于this
    • 19 （对象模型）关于Dynamic Binding
    • 后记

2 conversion function 转换函数

conversion function 转换函数

把这种东西转变为别的类型：把Fraction转变为double

class Fraction
{
public:
    Fraction(int num, int den=1)
        : m_numerator(num), m_denominator(den) {}
    operator double() const{ // 转换函数，没有return type返回类型, 没有参数
        return (double) (m_numerator / m_denominator);
    }
    
private:
    int m_numerator; // 分子
    int m_denominator; // 分母
}

// 使用
Fraction f(3, 5);
double d = 4 + f;  // 调用operator double() 将f转换为0.6

3 non-explicit-one-argument constructor

one argument: 只要1个实参就够了， 注意和parameter的区别，下面的Fraction构造函数有两个parameter，但是只有一个argument。

non explicit one argument constructor的作用：可以把别的东西转变为这种类型

class Fraction
{
public:
    Fraction(int num, int den=1)
        : m_numerator(num), m_denominator(den) {}
    
    Fraction operator+(const Fraction& f) {
        return Fraction(......); 
    }
    
private:
    int m_numerator; // 分子
    int m_denominator; // 分母
}

// 使用
Fraction f(3, 5);
double d2 = f + 4;  // 调用non-explicit constructor 将4转为 Fraction(4, 1), 然后调用operator+

如果 double转换和重载+操作符并存，编译器就会产生歧义，会报错

class Fraction
{
public:
    Fraction(int num, int den=1)
        : m_numerator(num), m_denominator(den) {}
    
    operator double() const { // 转换函数
        return (double) (m_numerator / m_denominator);
    }
    
    Fraction operator+(const Fraction& f) {
        return Fraction(......); 
    }
    
private:
    int m_numerator; // 分子
    int m_denominator; // 分母
}

// 使用
Fraction f(3, 5);
Fraction d2 = f + 4;  // 【Error】ambiguous

explicit-one-argument constructor

explicit关键字的作用是防止类构造函数的隐式自动转换.

class Fraction
{
public:
    explicit Fraction(int num, int den=1)
        : m_numerator(num), m_denominator(den) {}
    
    operator double() const { // 转换函数
        return (double) (m_numerator / m_denominator);
    }
    
    Fraction operator+(const Fraction& f) {
        return Fraction(......); 
    }
    
private:
    int m_numerator; // 分子
    int m_denominator; // 分母
}

// 使用
Fraction f(3, 5);
Fraction d2 = f + 4;  // 【Error】conversion from "double" to "Fraction" requested.

转换函数在标准库中的例子

template<class Alloc>
class vector<bool, Alloc>
{
public:
    typedef __bit_reference reference;
protected:
    reference operator[](size_type n) {
        return *(begin() + difference_type(n));
    }
 ...
}

struct __bit_reference {
    unsigned int* p;
    unsigned int mask;
    ...
public:
    operator bool() const {return !(!(*p & mask));}
...
}

如下图所示：一个vector里面保存的都是bool值，然后返回的是reference类型，这里就要有bool的转换函数。另外下图中还涉及到一种设计模式:proxy，具体关于proxy的知识不展开。

在这里插入图片描述

4 pointer-like classes

pointer like classes 关于智能指针

为什么要把一个类设计出来像一个指针呢？比指针做的事情更多一点

template<class T>
class shared_ptr
{
public:
    T& operator*() const //*号操作符重载
    { return *px;} // 传指针指向的内容
    
    T* operator->() const // -> 操作符重载
    { return px;}
    
    shared_ptr(T* p): px(p) {}
private:
    T* px;
    long* pn;
};

struct Foo
{
    ...
    void method(void) {......}
}

// 使用
shared_ptr<Foo> sp(new Foo); // 传一个指针进来

Foo f(*sp); // 使用*这个操作符
sp->method(); // 使用->这个操作符

在这里插入图片描述

pointer like classes，关于迭代器

迭代器也像指针，指向一个元素


template<class T>
struct __list_node {
    void* prev;
    void* next;
    T data;
};

template<class T, class Ref, class Ptr>
struct __list_iterator {
    typedef __list_iterator<T, Ref, Ptr> self;
    typedef Ptr pointer;
    typedef Ref reference;
    typedef __list_node<T>* link_type;
    link_type node;
    bool operator==(const self& x) const {return node == x.node;}
    bool operator!=(const self& x) const {return node != x.node;}
    reference operator*() const {return (*node).data;}
    pointer operator->() const {return &(operator*());}
    self& operator++() { node = (link_type)((*node).next); return *this;}
    self operator++(int) { self tmp = *this; ++*this; return tmp;}
    self& operator--() { node = (link_type)((*node).prev); return *this;}
    self operator--(int) { self tmp = *this; --*this; return tmp;}
}

T&
operator*() const {return (*node).data;} // 对迭代器解参考，就是拿链表节点中的data

T* 
operator->() const {return &(operator*());} // 获得上面operator*操作的地址

在这里插入图片描述

5 function-like classes

function like classes，所谓仿函数

重载()符号的用意，就是让这个类创建出来的对象是函数对象。

template<class T1, class T2>
struct pair {
    T1 first;
    T2 second;
    pair(): first(T1()), second(T2()) {}
    pair(const T1& a, const T2& b)
        : first(a), second(b) {}
};

template<class T>
struct identity {
  const T&
  operator()(const T& x) const {return x;}
};

template <class Pair>
struct select1st {
    const typename Pair::first_type&
    operator()(const Pair& x) const
    { return x.first;}
};

template <class Pair>
struct select2nd {
    const typename Pair::second_type&
    operator()(const Pair& x) const
    { return x.second;}
};

在这里插入图片描述

标准库中的仿函数的奇特模样:继承自unary_function

template<class T>
struct identity: public unary_function<T, T> {
  const T&
  operator()(const T& x) const {return x;}
};

template <class Pair>
struct select1st: public unary_function<Pair, typename Pair::first_type> {
    const typename Pair::first_type&
    operator()(const Pair& x) const
    { return x.first;}
};

template <class Pair>
struct select2nd: public unary_function<Pair, typename Pair::second_type>  {
    const typename Pair::second_type&
    operator()(const Pair& x) const
    { return x.second;}
};

还有继承自binary_function的仿函数

标准库中，仿函数所使用的奇特的base classes

在这里插入图片描述

6 namespace经验谈

命名空间起到隔离的作用，不同的命名空间里面可以有相同的函数名、变量名等，但是它们属于不同的范围。

在这里插入图片描述

7 class template 类模板

class template，类模板

在设计一个类的时候，允许某个变量或者参数的类型由使用者任意指定，那么就可以把这个类称为模板类，或者叫类模板。

在这里插入图片描述

8 function template 函数模板

function template，函数模板

在使用时，不用指明参数的type，编译器会进行实参推导

在这里插入图片描述

9 member template 成员模板

member template 成员模板

在标准库中的构造函数中会出现大量的member template，为的是让构造函数更有弹性一些，比如用派生类来初始化基类。

template<class T1, class T2>
struct pair{
    typedef T1 first_type;
    typedef T2 second_type;
    
    T1 first;
    T2 second;
    pair(): first(T1()), second(T2()) {}
    pair(const T1& a, const T2& b): first(a), second(b) {}
 #ifdef __STL_MEMBER_TEMPLATES	
    template<class U1, class U2>  // 成员模板
    pair(const pair<U1, U2>& p): first(p.first), second(p.second) {}
 #endif
};

下面以鲫鱼继承鱼类，麻雀继承鸟类来展示成员函数。

在这里插入图片描述

把一个鲫鱼和麻雀构成的pair，放进一个鱼类和鸟类构成的pair，这个是可以的。

class Base1 {};
class Derived1: public Base1 {};

class Base2 {};
class Derived2: public Base2 {};


pair<Derived1, Derived2> p;
pair<Base1, Base2> p2(p);

pair<Base1, Base2> p2(pair<Derived1, Derived2>()); //把一个派生类1和派生类2构成的pair，放进一个基类1和基类2构成的pair，反过来不可以

template<typename _Tp>
class shared_ptr: public __shared_ptr<_Tp>
{
    template<typename _Tp1>
    explicit shared_ptr(_Tp1* __p)
    	: __shared_ptr<_Tp>(__P) {}
};

Base* ptr = new Derived1;  // up-cast 向上转型是可以的

shared_ptr<Base1> sptr(new Derived1);

智能指针模拟向上转型：可以用派生类来初始化基类

在这里插入图片描述

10 specialization 模板特化

specialization 模板特化：限定模板实现的具体类型，比如下面指定hash的类型为char，int和long。

template<class Key>
struct hash {};

// 特化
template<>
struct hash<char> {
    size_t operator()(char x) const {return x;}
};

template<>
struct hash<int> {
    size_t operator()(int x) const {return x;}
};

template<>
struct hash<long> {
    size_t operator()(long x) const {return x;}
};

使用过程如下：

cout << hash<long>()(1000);

在这里插入图片描述

11 模板偏特化

模板偏特化——个数的偏

模板中可以指定某些参数为特定类型。

在这里插入图片描述

模板偏特化——范围的偏

从指向任意类型T，变成指向任意类型的指针*T，范围变小了。

在这里插入图片描述

12 模板模板参数

template template parameter,模板模板参数

可以让模板参数它本身是个类模板。下图中第二个参数为模板模板参数Container，它接收第一个模板参数来实例化自己，比如接收下面T类型。

template<typename T, template<typename T> class Conatainer>
class XCls
{
private:
    Container<T> c;
public:
    ...
}

在这里插入图片描述

13 关于C++标准库

Containers、Iterators、Algorithms、Functors的等使用，有另外一门课进行剖析。

14 三个主题 variadic templates等

variadic templates 可变参数模板

使用3个点…来表示

template<typename T, typename... Types>

void print()
{
    
}
void print(const T& firstArg, const Types&... args)
{
	cout << firstArg << endl;
    print(args...);
}

在这里插入图片描述

auto 用法:自动推导变量类型

之前的用法

list<string> c;
list<string>::iterator ite;
ite = find(c.begin(), c.end(), target);

C++11的用法

list<string> c;
auto ite = find(c.begin(), c.end(), target);

ranged-base for

能传引用就传引用，速度快。

vector<double> vec;

for(auto elem: vec) {
    cout << elem << endl;
}

for (auto& elem: vec) { // 改变原来的数据，要传引用&
    elem *= 3;
}

在这里插入图片描述

15 reference

int x = 0;

pointer to interger: int *p = &x;

reference to interger: int& r = x; r不是指针，r代表x, x的地址在哪，r的地址就在哪。 但是底层实现的时候使用指针实现的。

如果 int x2 = 5; r = x2;由于r已经代表了x，它不能重新代表其他的东西，经过r = x2;之后，r和x都变成了5.

在这里插入图片描述

reference引用的常见用途

在这里插入图片描述

16 复合&继承关系下的构造和析构

单独的继承关系、符合关系的继承与析构请参加我的笔记C++面向对象高级编程（侯捷）笔记2中关于11 组合与继承的部分。

这里记录继承+组合关系下的构造和析构

构造由内而外

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

析构由外而内

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

在这里插入图片描述

17 （对象模型）关于vptr和vtbl，虚指针和虚表

下面开始谈Object Model的内容。

虚指针vptr和虚表vtbl

virtual function虚函数有两个步骤来支持：

  1. 每一个class产生出一堆指向virtual functions的指针，放在virtual table（vtbl）中。
  2. 每一个class object被添加了一个指针，指向相关的virtual table。通常这个指针被称为vptr。vptr的设置和重置都由每个class的构造函数、析构函数和拷贝赋值运算符自动完成。

参考：深度探索C++对象模型

继承中，子类的对象里面有父类的成分

调用虚函数的过程，通过vptr得到vtbl，然后查找表中的第n个函数

(*(p->vptr[n]))(p); 或
(*p->vptr[n])(p);

在这里插入图片描述

18 （对象模型）关于this

对象模型object model：关于this

动态绑定的三个条件：

  1. 通过指针调用
  2. 指针有向上转型的动作
  3. 调用虚函数

在这里插入图片描述

编译器对动态绑定动作：

把

this->Serialize();

编译成下面这种形式:虚指针指向虚表，调用特定的虚函数

(*(this->vptr)[n])(this);

19 （对象模型）关于Dynamic Binding

对象模型：关于Dynamic Binding

静态绑定：直接调用汇编的call指令，跳转到函数地址。

B b;
A a = (A)b;
a.vfunc1(); // 静态绑定，直接call vfunc的地址

在这里插入图片描述

动态绑定：虚指针查虚表得到虚函数的地址，进行调用。

A* pa = new B;  // 向上转型
pa->vfunc1();

在这里插入图片描述

后记

从2024年1月1日开始，截至2024年1月4日，共花费4天，学习完C++面向对象高级编程（上）和C++面向对象高级编程（下），其中后者的标题为C++程序设计兼谈对象模型。

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

如若内容造成侵权/违法违规/事实不符，请联系我们进行投诉反馈qq邮箱809451989@qq.com，一经查实，立即删除！

相关文章

python统计分析——直方图（df.hist）

python统计分析——直方图（df.hist）

使用dataframe.hist()或series.hist()函数绘制直方图 import numpy as np import pandas as pd from matplotlib import pyplot as plt.dfpd.DataFrame(data{type:[A,A,A,A,A,A,A,A,A,A,B,B,B,B,B,B,B,B,B,B],value:[2,3,3,4,4,4,4,5,5,6,5,6,6,7,7,7,7,8,8,9] }) serpd.Serie…
阅读更多...
基于综合特征的细菌噬菌体宿主预测工具iPHoP (Integrated Phage HOst Prediction)的介绍以及使用方法详细流程

基于综合特征的细菌噬菌体宿主预测工具iPHoP (Integrated Phage HOst Prediction)的介绍以及使用方法详细流程

介绍 iPHoP&#xff08;Integrated Phage HOst Prediction&#xff09;是一种基于综合特征的细菌噬菌体宿主预测方法。它是通过整合基因组序列、蛋白质序列和宿主基因组信息来预测细菌噬菌体的宿主范围。 iPHoP的预测过程分为三个步骤&#xff1a;特征提取、特征选择和宿主预…
阅读更多...
shell sshpass 主机交互 在另外一台主机上执行某个命令 批量管理主机 以及一些案例

shell sshpass 主机交互 在另外一台主机上执行某个命令 批量管理主机 以及一些案例

目录 作用安装 sshpasssshpass 用法在远程主机执行某个命令 案例批量传输密匙批量拷贝文件批量修改密码 作用 就是用一台主机 控制另外一台主机免交互任务管理工具方便批量管理主机使用方法就是在ssh 前边加一个 sshpass 安装 sshpass # 安装 sshpass yum -y install sshpas…
阅读更多...
晨控CK-GW08-EC与欧姆龙PLC工业EtherCAT协议通讯指南

晨控CK-GW08-EC与欧姆龙PLC工业EtherCAT协议通讯指南

晨控CK-GW08-EC与欧姆龙PLC工业EtherCAT协议通讯指南 晨控CK-GW08系列是一款支持标准工业通讯协议EtherCAT的网关控制器,方便用户集成到PLC等控制系统中。系统还集成了8路读写接口&#xff0c;用户可通过通信接口使用EtherCAT协议对8路读写接口所连接的读卡器进行相对独立的读…
阅读更多...
＜软考高项备考＞《论文专题 - 48 范围管理（7） 》

＜软考高项备考＞《论文专题 - 48 范围管理（7） 》

8 收尾 8.1 经验教训 经验&#xff1a; 1、在规划范围管理的时候&#xff0c;对项目的复杂程度过于乐观&#xff0c;考虑的不够周详&#xff0c;制订的计划粒度过于粗糙 2、在收集需求前&#xff0c;没有对需求收集人员进行项目业务上的培训&#xff0c;导致需求收集人员与客…
阅读更多...
Vue3中配置env环境变量

Vue3中配置env环境变量

什么时候会用到这个呢&#xff0c;比如我们的后端开发有多名&#xff0c;很多时候需要切换调用不同人的接口地址&#xff0c;或者在打包的时候&#xff0c;需要指定环境中的后台接口地址&#xff0c;那么我们频繁修改代码&#xff0c;就很麻烦&#xff0c;这个时候&#xff0c;…
阅读更多...
win10提示“KBDSF.DLL文件缺失”，游戏或软件无法启动运行，快速修复方法

win10提示“KBDSF.DLL文件缺失”，游戏或软件无法启动运行，快速修复方法

很多用户在日常使用电脑的时候&#xff0c;或多或少都遇到过&#xff0c;在启动游戏或软件的时候&#xff0c;Windows桌面会弹出错误提示框“KBDSF.DLL文件缺失&#xff0c;造成软件无法启动或运行&#xff0c;请尝试重新安装解决”。 首先&#xff0c;先来了解DLL文件是什么&a…
阅读更多...
JS运行机制、Event Loop

JS运行机制、Event Loop

1、JS运行机制 JS最大的特点就是单线程&#xff0c;所以他同一时间只能做一件事情。使单线程不阻塞&#xff0c;就是事件循环。 在JS当中分为两种任务&#xff1a; 同步任务&#xff1a;立即执行的任务&#xff0c;一般放在主线程中&#xff08;主执行栈&#xff09;。异步任…
阅读更多...
企业级 npm 私有仓库部署方案

企业级 npm 私有仓库部署方案

本文作者系360奇舞团前端开发工程师 淘宝 NPM 镜像站切换新域名时&#xff0c;放了一张知乎博主天猪的图片&#xff0c;如下&#xff1a; _图片来源&#xff1a;https://zhuanlan.zhihu.com/p/432578145 看着逐年增长的访问量&#xff0c;不禁让人感慨&#xff0c;npm 的出现&a…
阅读更多...
并发编程大杀器，京东多线程编排工具asyncTool

并发编程大杀器，京东多线程编排工具asyncTool

一、简介 并发编程大杀器&#xff0c;京东多线程编排工具asyncTool&#xff0c;可以解决任意的多线程并行、串行、阻塞、依赖、回调的并行框架&#xff0c;可以任意组合各线程的执行顺序&#xff0c;带全链路执行结果回调。多线程编排一站式解决方案。 二、特点 多线程编排&am…
阅读更多...
GPT/GPT4科研应用与AI绘图技术及论文高效写作（建议收藏）

GPT/GPT4科研应用与AI绘图技术及论文高效写作（建议收藏）

详情点击链接&#xff1a;GPT/GPT4科研实践应用与AI绘图技术及论文高效写作 一OpenAI 1.最新大模型GPT-4 Turbo 2.最新发布的高级数据分析&#xff0c;AI画图&#xff0c;图像识别&#xff0c;文档API 3.GPT Store 4.从0到1创建自己的GPT应用 5. 模型Gemini以及大模型Clau…
阅读更多...
客服系统接入FastGPT

客服系统接入FastGPT

接入FastGPT 点击【应用】【外部使用】【API访问】【新建】新建一个KEY&#xff0c;同时也可以看到我们的API根地址 这个根地址和Key可以填入任何支持OpenAI接口的应用里&#xff0c;这个接口是兼容OpenAI格式。 在客服系统【知识库AI配置】里填上接口地址和接口密钥。这样我…
阅读更多...
图像分割实战-系列教程10：U2NET显著性检测实战2

图像分割实战-系列教程10：U2NET显著性检测实战2

&#x1f341;&#x1f341;&#x1f341;图像分割实战-系列教程 总目录 有任何问题欢迎在下面留言 本篇文章的代码运行界面均在Pycharm中进行 本篇文章配套的代码资源已经上传 U2NET显著性检测实战1 U2NET显著性检测实战2 5、残差Unet模块 class RSU7(nn.Module):#UNet07DRES…
阅读更多...
04.MySQL的基本操作

04.MySQL的基本操作

MySQL的基本操作 一、连接和断开MySQL服务器1、通过系统服务器启动、停止MySQL服务器2、通过命令提示符&#xff08;DOS&#xff09;启动、停止MySQL服务器2.1 启动 MySQL 服务器&#xff1a;2.2 停止 MySQL 服务器&#xff1a;2.3 登录和退出mysql 二、创建和管理数据库2.1 创…
阅读更多...
k8s---pod基础下

k8s---pod基础下

k8s的pod与docker重启策略的区别 k8s的重启策略 always deployment的yaml文件只能是always&#xff0c;pod的yaml三种模式都可以。不论正常退出还是非正常退出都重启。OnFailure&#xff1a;正常退出不重启&#xff0c;非正常退出会重启Never&#xff1a;正常退出和非正常退出…
阅读更多...
奇技淫巧：如何给项目中的RabbitMQ添加总开关

奇技淫巧：如何给项目中的RabbitMQ添加总开关

本文主要分享了如何给项目中的RabbitMQ添加总开关&#xff0c;通过简单配置开/关RabbitMQ。 一、需求背景 SpringBoot项目里使用了RabbitMQ&#xff0c;但某些场景下&#xff0c;不希望项目启动时自动检查RabbitMQ连接 例如&#xff1a; 在开发不需要RabbitMQ的功能过程中&…
阅读更多...
Prometheus插件安装（cadvisor）

Prometheus插件安装（cadvisor）

简介 当docker服务数量到一定程度&#xff0c;为了保证系统的文档&#xff0c;我们就需要对docker进行监控。一般情况下我们可以通过docker status命令来做简单的监控&#xff0c;但是无法交给prometheus采集&#xff0c;因此谷歌的cadvisor诞生了。cadvisor不仅可以轻松收集到…
阅读更多...
【Spring进阶系列丨第六篇】Spring的Bean管理（基于注解）

【Spring进阶系列丨第六篇】Spring的Bean管理（基于注解）

文章目录 一、说明二、用于创建对象的2.1、Component注解2.1.1、定义Bean2.1.2、主配置文件配置扫描注解2.1.3、测试2.1.4、Component注解总结 2.2、Controller注解2.3、Service注解2.4、Repository注解 三、用于注入数据的3.1、Autowired注解3.1.1、定义Bean3.1.2、主配置文件…
阅读更多...
Selenium-java元素等待三种方式

Selenium-java元素等待三种方式

第二种方式需要写在创建driver时的代码下面 第三种则是对每个定位元素进行配置
阅读更多...
探索Commons Exec管理外部进程

探索Commons Exec管理外部进程

第1章&#xff1a;引言 咱们在日常的Java开发中&#xff0c;经常会遇到需要调用外部进程或命令的场景。比如说&#xff0c;可能需要在Java程序中启动一个外部的脚本&#xff0c;或者执行一个系统命令。Java虽然提供了Runtime和ProcessBuilder类来处理这类需求&#xff0c;但说…
阅读更多...
最新文章

Copyright @ 2022~2023