侯捷C++八部曲（一，面向对象）

zaizai1007

已于 2024-04-08 10:26:58 修改

阅读量934

点赞数 17

分类专栏： C++ 文章标签： C++

于 2023-12-04 22:01:08 首次发布

本文链接：https://blog.csdn.net/zaizai1007/article/details/134793117

版权

C++ 专栏收录该内容

40 篇文章 3 订阅

订阅专栏

头文件和类的声明

inline

inline修饰函数，是给编译器的一个建议，到底是否为inline由编译器来决定，inline修饰的函数在使用时是做简单的替换，这样就避免了一些函数栈空间的使用，从能提升效率。从另一种角度看，是替代宏的一种方法。

函数若在class body 内定义完成则自动成为 inline 的候选人

构造函数放在 private 区

#include <stdio.h>
#include<stdlib.h>

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

A& A::getInstance()
{
	static A a;
	return a;
}

A::getInstance();

比如像单例模式，不想让别人随意创建对象

const

const函数表示函数不会改变成员变量内容，不改变成员变量的函数一定要加。如果声明一个const的类对象，表明这个类对象里面的值不能修改，但是类成员函数没有声明成cosnt，这样就会报错。

COW：copy on write，写时复制，在写的时候才进行复制，没写的时候，共享同一个字符串

charT
operator[] (size_type pos) const {
//不必考虑写时复制的问题，效率高，string[1]
}

reference
operator[] (size_type pos){
//要考虑写时复制的问题，string[1] = 't'
}

当成员函数的const版本和non-const版本同时存在的时候，const 对象只能调用const版本，non-const对象只能调用non-const版本

值传递和引用传递

尽量不要值传递，建议使用引用传递。引用传递底部是一个指针，一个指针四个字节。如果不希望函数修改引用的值，可以加const加以限制。函数返回值也尽量使用引用。
引用传参，传递者无需知道接收者以什么引用形式接收。

友元

一个类想要拿到另一个类的私有成员变量，那么就需要在另一个类中把这个类声明为友元。但是同一个类之间的不同实例能够取到彼此之间的私有成员变量，因为，相同class的各个对象互为友元。

数据放在private中
参数传递使用引用
返回值使用引用
const，应加尽加

操作符重载

写成成员函数
所有的非static成员函数都包含一个隐含的 this 指针，返回的是类引用

非成员函数
不能返回类引用，因为非成员函数操作符重载，一定会在函数方法内新建一个类对象来接收操作结果，如果返回引用，这个新对象在出了函数体之后，生命周期就结束了，引用就是失效了。所以只能返回值。

创建一个临时对象并返回该对象

拷贝赋值

拷贝赋值要检测是不是自我赋值，如果没有这个操作，可能会发生错误：因为拷贝赋值需要先进行delete操作，如果是自我赋值，那么delete掉本体，那么指向这个内存的另一个指针也会找不到相应的值，从而报错。

malloc

malloc：上下加块表示长度（以后销毁的时候告诉编译器销毁大小）。灰色是Debug模式下的情况

内存管理

C++内存模型分成五个部分：堆、栈、全局/静态存储区（C语言还分.bss段和.data段）、常量区、代码区

new的内部步骤：1.分配内存 2.转化类型 3.构造函数

delete步骤：1.析构函数 2.释放内存

字节对齐可以通过#pragma pack(4)进行设置，32位默认4字节对齐。

array new要搭配array delete，否则会造成内存泄露，为什么？对于没有指针的类，就算array new不搭配array delete也是不会发生内存泄露的。申请一个空间，带一个上下cookie，这个cookie中会存放当前内存块的大小，delete时是会完全释放掉这一个内存块的。但是对于有指针的类来说，申请一个该类型的数组，申请的空间中存放的是元素的指针，就算有上下cookie，delete能释放掉指针所占的空间，但是不能释放掉指针指向的内存空间。所以，使用array delete也就是delete[]，就是为了告诉编译器，我们需要多次调用当前类的析构函数，去释放指针指向的内存。

c1 便是所谓的 stack object ，其生命在作用域（scope）结束之际结束。这种作用域内的 object ，又称为 auto object，因为它会被 [自动] 清空

static

静态对象需要在类外进行定义

引用

引用必须要有初值
引用的实现是用指针，但是它不能再改变指向，引用代表的东西是多大，这个引用就是多大（这个是编译器做出来的假象）
引用的地址和他所代表的变量的地址、值完全相同
引用是一种漂亮的指针
引用通常不用于声明变量，而用于参数类型和返回类型的描述

Composition has-a

委托

下图：非常有名的写法。编译防火墙，一个类用指针指向另一个类，功能在那里实现。这样比如abc三个对象可以共享一段空间，但是当a要改的时候我们可以单独复制一块新的给a来改动，bc则保持共享

拥有另一个类的指针 Composition by reference

--> 生命是不同步的

继承 is-a

继承+复合关系下的构造和析构
构造，先调用父类的构造，然后调用复合的构造，最后调用自己的构造
析构，先调用自己的析构，然后调用复合的析构，最后调用父类的析构

虚指针&虚函数表

注意看这个执行顺序，仔细观察这张图右下角左上角

这个 OnFileOpen 函数将 Serialize 函数动作延缓到了子类中去进行。将这种函数或者做法叫做Template Method

pointer-like，智能指针

比如说shared_ptr重载了运算符*和->
迭代器也可以看作是一种智能指针

智能指针，比普通的指针拥有更多的功能

-> 有点特殊，箭头作用以后的结果它会继续作用下去

Function-like classes 所谓仿函数

设计一个类，让它看起来像函数一样

member template 成员模板

specialization 模板特化

泛化又叫做全泛化，对应的叫做偏特化，其实也就是模板偏化有程度之分，可以部分类型指定，称之为偏特化（老师这里分为了个数上的偏和范围上的偏）：

partial specialization 模板偏特化

template template parameter 模板模板参数

三个主题

把参数分为了一个和一包，把一个打印出来以后再递归调用，将一包分成一个和一包

注意函数中 ... 的位置，没有规律可言，语法如此

如果没有这个版本，最后的print(42)就会失败。

可以用sizeof…(args)来看那一包是几个。

#include <iostream>
using namespace std;

void print()
{
	
}

template<typename T, typename... Types>
void print(const T& firstArg, const Types&... args)
{
	cout << firstArg << endl;
	cout << "args_num:  " << sizeof...(args) << endl;
	print(args...);
}

int main()
{
	print(7.5, "hello", 42);
	return 0;
}

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

这只是老师自己运行的结果，这两个方法的执行顺序并不会对之后的代码运行造成影响

虚指针&虚函数表

继承函数继承的是函数的调用权，而不是内存

虚函数只要在子类里面被重写，子类的虚函数表就会把重写的函数的指针改变指向，和父类的指针不指向同一个地址

通过指针，指针向上转型，调用的是虚函数，满足这三个条件，就会是动态绑定
继承了一个有虚函数表的类，那么也会有自己独立的虚函数表，如果没有重写，那么这个独立的虚函数表指向的函数地址不变，但是如果重写了，就会将对应的函数地址指针指向改变，就相当于有一个自己的实现，这才能完成多态。A *p = new B()，这么一句，B有自己的虚函数表，A类型的指针指向了B类的地址，使用A调用虚函数的时候，其实是调用B类的虚函数表中的函数，所以叫之为动态绑定，但是使用A调用非虚函数的话，还是使用的是A自己里面的非虚函数，本质上来说，指针p还是A类型的，而且A类型里面的非虚函数没有经过动态编译。
通过对象调用，不会动态绑定，只有通过指针调用才会动态绑定。

找到vptr（虚函数表指针），再找到vtbl（虚函数表），再找到函数地址。