Cpp on 随记

04HelloTriangle

Sat, 14 Mar 2026 07:25:12 +0800

你好，三角#

在 OpenGL 中，所有物体都处于三维空间，但屏幕或窗口是一个二维像素数组，因此 OpenGL 的大部分工作是将所有三维坐标转换为适合屏幕的二维像素。将三维坐标转换为二维像素的过程由 OpenGL 的*图形管线 ~~graphics pipeline~~ *管理。图形管线可以分为两大部分：==第一部分将三维坐标转换为二维坐标，第二部分将二维坐标转换为实际的彩色像素 ~~第二部分第一步：把由坐标定义的几何形状，切割成数以万计的待处理像素（片段）。第二步才是填充像素~~ ==。本章将简要讨论图形管线以及如何利用它来创建精美的像素。

图形管线以一组三维坐标作为输入，并将其转换为屏幕上的彩色二维像素。图形管线可以分为多个步骤，每个步骤都需要前一步的输出作为输入 ~~串行，阶段性依赖~~ 。所有这些步骤都高度专业化（每个步骤都具有特定的功能），并且可以轻松地并行执行 ~~同一个步骤并行~~ 。由于其并行特性，如今的显卡拥有数千个小型处理核心，以便在图形管线中快速处理数据。这些处理核心在 GPU 上运行小型程序，用于执行管线的每个步骤。这些小型程序被称为着色器。

~~并行还有另一个意思：当第一批顶点处理完进入“光栅化”车间时，顶点车间并不需要闲着。它可以立刻开始处理下一批模型或者下一帧的顶点~~

开发者可以配置部分着色器，从而编写自定义着色器来替换现有的默认着色器。这使我们能够对渲染管线的特定部分进行更精细的控制，并且由于它们运行在 GPU 上，因此还可以节省宝贵的 CPU 时间。着色器使用 OpenGL 着色语言 (GLSL) ~~OpenGL Shading Language ~~ 编写，我们将在下一章中深入探讨。

下方是图形管线所有阶段的抽象表示。请注意，蓝色部分表示我们可以注入自定义着色器的部分。

顶点着色器 ~~把 3D 空间的坐标转换成屏幕上的 2D 坐标（术语叫标准化设备坐标）~~ ->几何着色器 增减图形：可以把一个点变成一个三角形，或者把一个三角形删掉。这里，几何着色器根据这 3 个点，计算出了第 4 个点的位置，并把它们重新组合。输出：它“发射”出了足够的顶点，组成了两个独立的三角形图元。 ->图元组装 ~~把处理好的点“连线”~~ ->光栅化 ~~计算这个三角形到底盖住了屏幕上哪些像素格子~~ ->片段着色器 ~~根据光照、纹理、材质，给这个像素算出一个最终的 RGBA 值~~ ->测试与混合 ~~深度测试 (Depth Test)：检查这个像素是不是被别的物体挡住了。模板测试：一些特殊遮罩效果。混合 (Blending)：如果是半透明的，就把它和背景颜色融合~~

如您所见，图形管线包含大量模块 ~~应该说的是这六个~~ ，每个模块负责将顶点数据转换为完整渲染像素的特定 ~~某个步骤~~ 步骤。我们将以简化的方式简要解释管线的每个部分，以便您对管线的工作原理有一个大致的了解。

作为图形管线的输入，我们传入一个名为 Vertex Data 的数组，其中包含三个 3D 坐标，它们应该构成一个三角形；这个顶点数据是一个顶点集合。每个顶点都是一个包含 3D 坐标数据的集合。顶点数据使用顶点属性来表示，这些属性可以包含我们想要的任何数据，但为了简单起见，我们假设每个顶点仅包含一个 3D 位置和一个颜色值。

105弱指针

Wed, 11 Mar 2026 21:30:15 +0800

共享指针与唯一指针例子#

#ifdef LY_EP105
#include <iostream>
#include <memory>

class Entity {
public:
	Entity() { std::cout << "Entity Created" << std::endl; }
	~Entity() { std::cout << "Entity Destroyed" << std::endl; }
};

int main() {
	// --- unique_ptr 示例 ---
	{
		std::unique_ptr<Entity> e1 = std::make_unique<Entity>();
		// std::unique_ptr<Entity> e2 = e1; // 错误！禁止复制
		std::unique_ptr<Entity> e2 = std::move(e1); // 允许移动所有权，e1 现在为空
	} // e2 离开作用域，Entity 在这里被销毁

	std::cout << "-----------------" << std::endl;

	{
		// --- shared_ptr 示例 ---
		std::shared_ptr<Entity> sharedOuter;
		{
			//std::shared_ptr对象实例内部有一个引用计数，简单记录有多少个共享指针指向内部Entity对象的实例
			std::shared_ptr<Entity> sharedInner = std::make_shared<Entity>();

			sharedOuter = sharedInner; // 允许复制（拷贝赋值函数），引用计数变为 2
			std::cout << "Inner scope ending1..." << std::endl;
			std::shared_ptr<Entity> sharedInner1 = std::move(sharedOuter);//这里把sharedInner的所有权移走了，计数减一，但是本身又导致计数加一，所以目前是2 

			std::cout << "Inner scope ending2..." << std::endl;
		} // sharedInner1 离开作用域，sharedOuter所有权被移走，所以没有任何共享指针指向Entity了， Entity 被销毁 

		std::cout << "Outer scope still holds Entity？" << std::endl;
	} //作用域结束，sharedOuter 离开作用域，Entity 最终在这里被销毁

	std::cin.get();
}
/*
Entity Created
Entity Destroyed
-----------------
Entity Created
Inner scope ending1...
Inner scope ending2...
Entity Destroyed
Outer scope still holds Entity？
*/
#endif

共享指针、强引用，能防止对象销毁，也被称作具名引用。即他们对一个对象各自都拥有所有权

100cpp映射容器

Wed, 11 Mar 2026 16:22:01 +0800

简介#

什么是 Map？#

Map 是一种容器，用于存储键值对。它允许你通过一个“键”（Key）来快速查找对应的“值”（Value）。
类比：就像一本字典，单词是键，定义是值。

std::map vs std::unordered_map#

std::map (有序映射)：
- 底层结构：红黑树（一种自平衡二叉搜索树）。
- 特点：元素按键的顺序自动排序。
- 复杂度：查找、插入、删除均为 O(logn)。
std::unordered_map (无序映射)：
- 底层结构：哈希表（Hash Table）。
- 特点：元素没有特定顺序。
- 复杂度：平均情况下查找速度为 O(1)，通常比 std::map 快，除非哈希冲突严重。

代码演示：基础用法#

展示如何定义 std::map<std::string, CityRecord>。
使用 operator[] 进行赋值：map["Berlin"] = CityRecord { ... };。
注意：如果访问一个不存在的键，operator[] 会自动创建一个默认构造的对象并插入。

迭代与访问#

演示如何使用 for (auto& [key, value] : map)（C++17 结构化绑定）遍历 Map。
解释了老式迭代器用法：it->first 是键，it->second 是值。

性能取舍与选择建议#

优先选择 std::unordered_map：如果你只需要快速查找，不需要元素有序，那么无序映射通常性能更优。
选择 std::map 的场景：当你需要遍历时保持特定顺序，或者需要使用类似 lower_bound 的区间查找功能时。

复杂键的处理#

讲解了如果使用自定义类作为键，std::map 需要该类重载 < 运算符，而 std::unordered_map 则需要提供哈希函数。

#ifdef LY_EP100

#include <iostream> 
#include <map>
#include <unordered_map>
#include <string>

struct CityRecord
{
	std::string Name;
	uint64_t Population;
	double Latitude, Longitude;

};

 std::ostream& operator<<(std::ostream& stream,
	const CityRecord& cityRecord)
{ 
	std::cout << "Name: " << cityRecord.Name << ","
		<< "Population: " << cityRecord.Population << ","
		<< "Latitude: " << cityRecord.Latitude << ","
		<< "Longitude: " << cityRecord.Longitude << std::endl;
	return stream;
}

namespace std {

	template<>
	struct hash<CityRecord>
	{
		size_t operator()(const CityRecord& key)
		{
			//hash<std::string>()这是调用构造函数，
			//然后构造了std::hash<CityRecord> 类型的对象，
			//之后调用了该对象的()重载方法
			return hash<std::string>()(key.Name);
		}
	};
}
int main()
{

	//计算City
	CityRecord cityRecord = { "name1",10000,2.3,4.5 };
	auto hashcode=std::hash<CityRecord>()(cityRecord);
	if (hashcode)
	{
		std::cout << "hashcode: " << hashcode << std::endl;
		std::cout << cityRecord << std::endl;
	}
	std::cin.get();
	return 0;
}

#endif

模板特化#

1. 什么是普通模板？（工厂的模具）#

模板就像一个通用的模具。比如你想写一个 print 函数，不管是 int、float 还是 string 都能用：

102如何正确搭建cpp项目

Wed, 11 Mar 2026 15:46:26 +0800

创建项目并克隆#

https://github.com/TheCherno/ProjectTemplate ，到这个地址 UseThisTemplate -> CreateNewRepository

在本地windows克隆下来

git clone git@github.com:lwmfjc/ChernoTemplateProject.git

之后我把项目删掉.git文件夹后放到了另一个自己的备份gitRepository中

使用#

双击Setup-Windows.bat 运行

在visual studio中，File-Open-Solution，选择 NewProject.sln

打开之后直接F5运行

==这集先跳过，貌似有点不太常用 ~~注：看到00:07:34~~ ==

95如何真正学好cpp

Wed, 11 Mar 2026 09:32:28 +0800

核心问题：学完基础后该做什么？#

现状：许多人看完了视频、读完了教科书、甚至通过了大学考试，但依然觉得不会自由地编写代码，无法“流利”地使用 C++。
核心建议：沉浸在开源项目（Open Source Projects）中。

真实世界的代码 vs. 教科书#

差异：教科书和作业里的代码（如实现一个 Vector 或 List）是教学性质的，而现实世界的代码规模更大、逻辑更复杂。
面试视角：雇主想看到的是你理解软件是如何构建的，以及你是否见过并能处理真实代码库中的复杂性。

“语言学习”的类比#

学习环境：学习编程就像学外语（德语或日语）。只看语法书和做练习是不够的，你必须开始看电视、电影，甚至搬到那个国家居住。
编程沉浸：对于 C++，这意味着你需要阅读、运行并尝试修改别人的代码，让自己置身于那个语言环境中。

如何开始？选择你感兴趣的项目#

兴趣导向：
- 喜欢游戏？去 GitHub 找简单的开源游戏（如 Mario 克隆版或 80 年代街机游戏）。
- 喜欢引擎？研究 Unreal Engine、Godot 或 Cherno 自己的 Hazel 引擎。
Bug 赏金计划：参与寻找 C++ 代码中的 bug，这不仅能锻炼能力，有时还能获得报酬。

什么时候可以开始“沉浸”？#

结论：随时。即使你觉得还太早，也不必担心。就像没学多少日语就去日本一样，虽然痛苦，但那是进步最快的方式。

实战演示：分析 OpenCV 源码#

流程：从 GitHub 克隆项目 -> 使用 CMake 生成 VS 工程 -> 编译并运行。
工具辅助（PVS-Studio）：Cherno 演示了使用静态分析工具查看 OpenCV 源码中的潜在错误。
学习点：例如通过分析宏定义中的 if 语句冗余问题，你可以学到更深层的编码经验，这些是只看语法书学不到的。

总结：超越代码本身的收获#

通过阅读开源项目，你不仅学会了写 C++，还学会了：

94编写迭代器

Tue, 10 Mar 2026 12:59:30 +0800

迭代器是用来遍历某种数据结构的容器的
迭代器统一了接口，所以通过同样的接口不同的实现来迭代不同的容器
迭代器：记录一个指针，然后遍历就像移动指针一样，直到末尾

Vector类#

为Vector添加部分代码

class Vector
{
public:

	//Vector的值类型
	using ValueType = T;
	//public 类型别名 (using/typedef)：属于类（Class/Type）。它是一个“类型标签”，就像 Vector<int> 内部定义的一个子类型。
	using Iterator = VectorIterator<Vector<T>>;

	Iterator begin()
	{
		return Iterator(m_Data);
	}


	Iterator end()
	{
		return Iterator(m_Data + m_Size);
	}
}

Vector类完整代码

#pragma once
#ifdef LY_EP94
#include <memory>
#include <iostream>

//为某种类型(Vector)写迭代器
template<typename Vector>
class VectorIterator
{
public:
	//Vector的值的类型
	using ValueType = typename Vector::ValueType;
	using PointerType = ValueType*;
	using ReferenceType = ValueType&;


	VectorIterator(PointerType ptr)
		:m_Ptr(ptr)
	{

	}

	//前缀运算符
	VectorIterator& operator++()
	{
		m_Ptr++;
		return *this;
	}

	//前缀运算符
	VectorIterator& operator--()
	{
		m_Ptr--;
		return *this;
	}

	//后缀运算符
	//编译器用来区分前缀和后缀的唯一手段，int
	//是语法占位符
	VectorIterator& operator++(int)
	{
		//这里是复制，由于成员只有一个指针，代价可以接受
		VectorIterator iterator = *this;
		//前缀运算符
		++(*this);
		return iterator;
	}

	//后缀运算符
	VectorIterator& operator--(int)
	{
		//这里是复制，由于成员只有一个指针，代价可以接受
		VectorIterator iterator = *this;
		//前缀运算符
		--(*this);
		return iterator;
	}

	ReferenceType operator[](int index)
	{
		return *(m_Ptr + index);
	}

	//C++ 对 -> 有特殊处理。当你使用 it->Method() 时，它会调用 it.operator->() 得到 m_Ptr，然后再次对结果应用 ->。所以最终执行的是 m_Ptr->Method()。
	//所以这里需要返回一个指针
	PointerType operator->()
	{
		return m_Ptr;
	}


	ReferenceType operator*()
	{
		return *m_Ptr;
	}

	bool operator==(const VectorIterator& other) const
	{
		return m_Ptr == other.m_Ptr;
	}
	bool operator!=(const VectorIterator& other) const
	{
		return !(*this == other);
	}

private:
	PointerType m_Ptr;
};

template<typename T>
class Vector
{
public:

	//Vector的值类型
	using ValueType = T;
	//public 类型别名 (using/typedef)：属于类（Class/Type）。它是一个“类型标签”，就像 Vector<int> 内部定义的一个子类型。
	using Iterator = VectorIterator<Vector<T>>;

	Iterator begin()
	{
		return Iterator(m_Data);
	}


	Iterator end()
	{
		return Iterator(m_Data + m_Size);
	}

public:

	Vector()
	{
		//allocate 2 elements
		ReAlloc(2);
		std::cout << "====构造器中初始化容量2======" << std::endl;
	}

	void PushBack(const T& value)
	{
		//如果当前数量量已经大于等于容量
		if (m_Size >= m_Capacity)
		{
			//如果增长，容量扩大为1.5倍
			ReAlloc(m_Capacity + m_Capacity / 2);
		}

		//m_Data[m_Size] 是一个已经存在的对象，所以
		//这里调用的是拷贝赋值函数
		//m_Data[m_Size] = value;

		// new (&地址) 类型(参数)
		new(&m_Data[m_Size]) T(value);

		m_Size++;
		std::cout << "添加元素:" << value << std::endl;
		std::cout << "==================" << std::endl;
	}

	//1. PushBack的push右值引用的版本
	//2. value 的类型始终是 Vector3&&（右值引用），
	// 但它在函数体内的表现（属性）是一个左值
	void PushBack(T&& value)
	{
		//如果当前数量量已经大于等于容量
		if (m_Size >= m_Capacity)
		{
			//如果增长，容量扩大为1.5倍
			ReAlloc(m_Capacity + m_Capacity / 2);
		}

		//1. m_Data[m_Size] 是一个已经存在的对象，所以
		//这里调用的是移动赋值函数
		//2. value 传入时是右值引用，但在函数内部它有了名
		// 字，就变成了左值。为了触发移动赋值，
		// 必须用 std::move 把它重新转回右值。
		//3. 如果没有移动赋值函数，会去调用拷贝赋值函数
		//m_Data[m_Size] = std::move(value);

		// 使用移动构造函数在原始内存上创建对象
		new(&m_Data[m_Size]) T(std::move(value));

		m_Size++;
		std::cout << "添加元素:" << value << std::endl;
		std::cout << "==================" << std::endl;
	}

	//变长参数模板，三个点 ... 表示它可以接收
	// 任意数量、任意类型的参数
	template<typename... Args>
	//&& 配合模板参数 Args 使用时，不再仅仅是
	// 右值引用，它被称为万能引用，既能接收左值
	// ，也能接收右值
	T& EmplaceBack(Args&&... args)
	{

		//如果当前数量量已经大于等于容量
		if (m_Size >= m_Capacity)
		{
			//如果增长，容量扩大为1.5倍
			ReAlloc(m_Capacity + m_Capacity / 2);
		}
		//1. 参数一旦有了名字 args，它在函数内部就会变成左值。
		//2. 解决：std::forward 的作用是：如果你传进来时是右值，
		// 它就把它恢复成右值；如果你传进来时是左值，它就保持左
		// 值。
		//3. T(std::forward<Args>(args)...)这个是右值，调用移动
		// 赋值函数后，马上destroy了

		//m_Data[m_Size] = T(std::forward<Args>(args)...); 

		//使用placement new运算符，原地构造，就不会有对临时对象move以及destroy的操作了
		new(&m_Data[m_Size]) T(std::forward<Args>(args)...);

		std::cout << "添加元素:" << m_Data[m_Size] << std::endl;
		std::cout << "==================" << std::endl;

		//1. 取值（Evaluate）：首先取出 m_Size 当前的值（比如现在是 0）。
		//2. 定位（Access）：利用这个旧值 0 找到 m_Data[0] 的引用，作为函数的返回值准备好。
		//3. 自增（Increment）：在这一行语句的逻辑完成，“返回”动作即将发生前（但还在函数体内），将 m_Size 的值加 1 变成 1。
		return m_Data[m_Size++];
	}

	void PopBack()
	{
		if (m_Size > 0)
		{
			m_Size--;
			//手动调用析构函数
			m_Data[m_Size].~T();
		}
	}

	void Clear()
	{
		for (size_t i = 0; i < m_Size; i++)
			m_Data[i].~T();
		m_Size = 0;
	}

	T& operator[](size_t index)
	{
		if (index >= m_Size)
		{
			//assert
		}
		return m_Data[index];
	}

	const T& operator[](size_t index) const
	{
		if (index >= m_Size)
		{
			//assert被设计为一种调试期工具,在发布版本会被去掉
			//assert
		}
		return m_Data[index];
	}

	size_t Size() const { return m_Size; }

	~Vector()
	{
		//会依次调用m_Data指向的所有对象的析构函数（
		// 但是PopBack及Clear()已经调用过并已经释放了
		// Vector3的m_MemoryBlock

		Clear();
		//		delete[] m_Data;

		::operator delete(m_Data, m_Capacity * sizeof(T));

	}
private:
	void ReAlloc(size_t newCapacity) {
		// 1. allocate a new block of memory
		// 2. copy/move old elements into new block
		// 3. delete

		//1. 尽可能低层次的访问内存，而不是智能指针
		//2. 在堆上申请了一块连续(物理连续)的内存空间
		//3. 在堆上创建了 newCapacity 个对象，并调用了它们
		//的默认构造函数。也就是说，此时内存里已经存在了一
		//堆“空”的 Vector3 对象
		//T* newBlock = new T[newCapacity];

		//分配原始字节内存，不调用任何构造函数
		T* newBlock = (T*)::operator new(newCapacity * sizeof(T));

		//如果新容量小于当前大小，即缩小容量
		if (newCapacity < m_Size)
		{
			// 当前大小设置为新容量大小
			m_Size = newCapacity;
			std::cout << "缩小容量--" << std::endl;
		}
		else
		{

			std::cout << "增大容量--" << m_Capacity << "->" << newCapacity << std::endl;
		}

		for (size_t i = 0; i < m_Size; i++)
		{
			//不会触发复制构造函数
			//memcpy(newBlock, m_Data, i * sizeof(T);

			//复制,会触发复制构造函数
			//newBlock[i] = std::move(m_Data[i]);

			// 在 newBlock 的位置上，“构造”一个新对象，其内容移动自旧对象
			new(&newBlock[i]) T(std::move(m_Data[i]));
		}

		//手动释放原来的对象
		for (size_t i = 0; i < m_Size; i++)
		{
			m_Data[i].~T();
		}

		//1. 逐一析构：编译器会根据该内存块记录的大小信息（通常存储在数组头部的隐藏偏移量中），从后往前（或从前往后，取决于实现）调用每一个 Vector3 对象的析构函数。
		//2. 释放内存：在所有对象的析构函数执行完毕后，才会一次性将整块堆内存归还给操作系统。
		//delete[] m_Data;//释放原来指向的内存块

		::operator delete(m_Data, m_Capacity * sizeof(T));

		//delete m_Data;只会触发第一个元素的析构函数

		m_Data = newBlock;//指向新的那个内存块
		m_Capacity = newCapacity;

	}



	T* m_Data = nullptr;
	//实际数组个数
	size_t m_Size = 0;
	//可分配存储的元素个数
	size_t m_Capacity = 0;
};
#endif

Main使用#

#ifdef LY_EP94

#include <iostream> 
#include <vector>
#include "94_01_vector.h"

int main()
{ 
	Vector<int> values;
	values.EmplaceBack(1);
	values.EmplaceBack(2);
	values.EmplaceBack(3);
	values.EmplaceBack(4);
	values.EmplaceBack(5);

	std::cout << "Not using iterators:\n";
	for (int i = 0; i < values.Size(); i++)
	{
		std::cout << values[i] << std::endl;
	}

	std::cout << "Range-based for loop" << std::endl;
	for (int value : values)
	{
		std::cout << value << std::endl;

	}

	std::cout << "Iterator:\n";
	for (Vector<int>::Iterator it = values.begin();
		it != values.end(); it++)
	{
		std::cout << *it << std::endl;
	}

	std::cin.get();
	return 0;
}
#endif;

92动态数组实现

Mon, 09 Mar 2026 13:03:14 +0800

涉及到了手动内存管理、堆分配以及模板类的深层逻辑。

简要概述#

核心目标：实现动态扩容
- 作者明确了本集的目标：创建一个可以根据需要自动增长内存空间的容器，模拟 std::vector 的核心行为。
成员变量的改变：从栈到堆
- 不再使用 T m_Data[S]，而是改为 T* m_Data 指针。
- 引入两个关键计数器：m_Size（当前元素个数）和 m_Capacity（当前分配的总空间）。
构造函数与析构函数
- 在构造函数中预分配一小块初始内存。
- 强调了析构函数的重要性：必须使用 delete[] m_Data 释放堆内存，否则会导致内存泄漏。
实现 PushBack 方法（核心逻辑）
- 这是本集最精彩的部分：当 m_Size >= m_Capacity 时，触发“重新分配（Reallocation）”。
- 扩容策略：作者演示了将容量翻倍（m_Capacity * 2）的常用工程策略。
手动执行内存迁移
- 详细步骤：申请一块更大的新内存 -> 将旧数据拷贝到新内存 -> 释放旧内存 -> 指针重定向。
模板化的挑战
- 讨论了为什么 Vector 需要模板化，以及在处理非简单类型（如 std::string）时，简单的拷贝可能会失效（引出对后续移动语义的思考）。
性能测试与优化预告
- 对比了自定义 Vector 与标准库 std::vector 的性能。
- 提到目前的实现虽然可用，但频繁的拷贝开销巨大，引出后续关于 emplace_back 的话题。

代码`vector.h`#

//91_01_vector.h
#pragma once
#ifdef LY_EP92
#include <memory>

template<typename T>
class Vector
{
public:
	Vector()
	{
		//allocate 2 elements
		ReAlloc(2);
		std::cout << "====构造器中初始化容量2======" << std::endl;
	}

	void PushBack(const T& value)
	{
		//如果当前数量量已经大于等于容量
		if (m_Size >= m_Capacity)
		{
			//如果增长，容量扩大为1.5倍
			ReAlloc(m_Capacity + m_Capacity / 2);
		}

		//m_Data[m_Size] 是一个已经存在的对象，所以
		//这里调用的是拷贝赋值函数
		m_Data[m_Size] = value;
		m_Size++;
		std::cout << "添加元素:" << value << std::endl;
		std::cout << "==================" << std::endl;
	}

	T& operator[](size_t index)
	{
		if (index >= m_Size)
		{
			//assert
		}
		return m_Data[index];
	}

	const T& operator[](size_t index) const
	{
		if (index >= m_Size)
		{
			//assert被设计为一种调试期工具,在发布版本会被去掉
			//assert
		}
		return m_Data[index];
	}

	size_t Size() const { return m_Size; }

	~Vector()
	{
		delete[] m_Data; 
	}
private:
	void ReAlloc(size_t newCapacity) {
		// 1. allocate a new block of memory
		// 2. copy/move old elements into new block
		// 3. delete

		//1. 尽可能低层次的访问内存，而不是智能指针
		//2. 在堆上申请了一块连续(物理连续)的内存空间
		//3. 在堆上创建了 newCapacity 个对象，并调用了它们
		//的默认构造函数。也就是说，此时内存里已经存在了一
		//堆“空”的 Vector3 对象
		T* newBlock = new T[newCapacity];

		//如果新容量小于当前大小，即缩小容量
		if (newCapacity < m_Size)
		{
			// 当前大小设置为新容量大小
			m_Size = newCapacity;
			std::cout << "缩小容量--" << std::endl;
		}
		else
		{

			std::cout << "增大容量--" << m_Capacity << "->" << newCapacity << std::endl;
		}

		for (size_t i = 0; i < m_Size; i++)
		{
			//不会触发复制构造函数
			//memcpy(newBlock, m_Data, i * sizeof(T);

			//复制,会触发复制构造函数
			newBlock[i] = m_Data[i];
		}

		//1. 逐一析构：编译器会根据该内存块记录的大小信息（通常存储在数组头部的隐藏偏移量中），从后往前（或从前往后，取决于实现）调用每一个 Vector3 对象的析构函数。
		//2. 释放内存：在所有对象的析构函数执行完毕后，才会一次性将整块堆内存归还给操作系统。
		delete[] m_Data;//释放原来指向的内存块

		//delete m_Data;只会触发第一个元素的析构函数

		m_Data = newBlock;//指向新的那个内存块
		m_Capacity = newCapacity;

	}



	T* m_Data = nullptr;
	//实际数组个数
	size_t m_Size = 0;
	//可分配存储的元素个数
	size_t m_Capacity = 0;
};
#endif

应用：添加`std::string`元素#

#ifdef LY_EP92
//在堆上分配内存，创建动态数组
//需要一个指向堆分配内存(数据缓冲区)的指针,随着不断
//添加，当元素越来越多会达到临界点，没有足够空间存储新元素时，
//分配一个新的内存块使它有足够空间容纳这个新元素，将内存块中所有元素
//复制到新内存块，然后删除旧内存块

#include <iostream> 
#include <string>
#include "92_01_vector.h"

template<typename T>
void PrintVector(const Vector<T>& vector)
{
	for (size_t i = 0; i < vector.Size(); i++)
	{
		std::cout << vector[i] << std::endl;
	}

	std::cout << "==================" << std::endl;
}

int main()
{
	Vector<std::string> vector;
	vector.PushBack("Cherno");
	vector.PushBack("C++");
	vector.PushBack("Vector01");
	vector.PushBack("Vector02");
	vector.PushBack("Vector03");
	vector.PushBack("Vector04");
	vector.PushBack("Vector05");
	vector.PushBack("Vector06");
	vector.PushBack("Vector07");

	PrintVector(vector);
	std::cin.get();
	return 0;
}
/*
增大容量--0->2
====构造器中初始化容量2======
添加元素:Cherno
==================
添加元素:C++
==================
增大容量--2->3
添加元素:Vector01
==================
增大容量--3->4
添加元素:Vector02
==================
增大容量--4->6
添加元素:Vector03
==================
添加元素:Vector04
==================
增大容量--6->9
添加元素:Vector05
==================
添加元素:Vector06
==================
添加元素:Vector07
==================
Cherno
C++
Vector01
Vector02
Vector03
Vector04
Vector05
Vector06
Vector07
==================

*/

#endif

应用添加自定义类元素#

#ifdef LY_EP92

#include <iostream> 
#include <string>
#include "92_01_vector.h"


struct Vector3
{
	float x = 0.0f, y = 0.0f, z = 0.0f;

	Vector3() {}
	Vector3(float scalar)
		: x(scalar), y(scalar), z(scalar) {
	}
	Vector3(float x, float y, float z)
		: x(x), y(y), z(z) {
	}

	// 拷贝构造函数 (Copy Constructor)
	Vector3(const Vector3& other)
		: x(other.x), y(other.y), z(other.z)
	{
		std::cout << "Copy\n";
	}


	//移动构造函数 (move Constructor)
	Vector3(Vector3&& other)
		: x(other.x), y(other.y), z(other.z)
	{
		std::cout << "Move\n";
	}

	//拷贝赋值
	Vector3& operator=(const Vector3& other)
	{
		std::cout << "copy=\n";
		x = other.x;
		y = other.y;
		z = other.z;
		return *this;
	}

	//移动赋值
	Vector3& operator=(Vector3&& other)
	{
		std::cout << "move=\n";
		x = other.x;
		y = other.y;
		z = other.z;
		return *this;
	}

	~Vector3()
	{
		std::cout << "Destroy\n";
	}
};

//全局重载函数，C++ 规定：对于二元运算符（有两个操作数的运算符），如果写成全局函数，第一个参数对应运算符左边的对象，第二个参数对应右边的对象
std::ostream& operator<<(std::ostream& stream, const Vector3& v)
{
	stream << v.x << ", " << v.y << ", " << v.z;
	return stream;
}

void PrintVector(const Vector<Vector3>& vector)
{
	for (size_t i = 0; i < vector.Size(); i++)
	{
		std::cout << vector[i] << std::endl;
	}

	std::cout << "==================" << std::endl;
}

int main()
{
	Vector<Vector3> vector;

	//Vector3(1.0f)->创建一个匿名临时对象
	//临时对象会在包含它的那个“完整表达式（Full-expression）”结束时被销毁。即这行代码结束后该临时对象被析构
	vector.PushBack(Vector3(1.0f));

	vector.PushBack(Vector3{ 2,3,4 });
	vector.PushBack(Vector3{});


	PrintVector(vector);

	std::cin.get();
	return 0;
}
/*
增大容量--0->2
====构造器中初始化容量2======
copy=
添加元素:1, 1, 1
==================
Destroy
copy=
添加元素:2, 3, 4
==================
Destroy
增大容量--2->3
copy=
copy=
Destroy
Destroy
copy=
添加元素:0, 0, 0
==================
Destroy
1, 1, 1
2, 3, 4
0, 0, 0
==================
*/
#endif

如上，每次添加元素，以及扩容时的搬运原元素，都触发了复制赋值函数

91静态数组实现

Sun, 08 Mar 2026 23:11:54 +0800

为什么要手写数据结构？
- 作者解释说，虽然 std::array 很好用，但作为底层程序员，你应该了解它在堆栈（Stack）上是如何分配内存的。这有助于你理解内存布局和模板编程。
模板类（Template Class）的声明
- 开始编写 Array<T, S>。
- 重点：这里的 T 是元素类型，S 是编译期常量（数组大小）。作者解释了为什么在 C++ 中通过模板传递数组大小比通过构造函数传递更高效（因为它在编译时就确定了内存空间）。
内存分配的核心：原始数组
- 在类内部定义 T m_Data[S]。
- 关键点：这证明了 Array 是分配在栈上的，其生命周期由作用域决定。
实现 Size() 方法
- 定义一个简单的 constexpr size_t Size() const { return S; }。
- 强调了 constexpr 的作用，让这个大小在编译阶段就能被其他代码使用。
运算符重载：实现 operator[]
- 为了像使用普通数组一样使用它（例如 data[0]），作者演示了如何编写两个版本的下标运算符：
  1. 普通版本：T& operator[](size_t index)。
  2. Const 版本：const T& operator[](size_t index) const（为了处理 const Array 对象）。
内存布局验证
- 作者通过调试器（Debugger）展示了 Array 在内存中的连续排布情况。
总结与后续预告
- 这集完成了一个静态的由栈分配的数组 ~~连续存储一定数量数据元素~~ 。作者提到，下一集（92 集）将在此基础上引入堆（Heap）内存分配，实现动态扩容的 Vector。

用C++编写一个固定大小，基于栈分配的数组数据结构

91静态数组实现#

栈分配和堆分配#

#ifdef LY_EP91

#include <iostream> 
#include <array>

int main()
{
	int k = 3;
	const int const_k = 5; //常量表达式，编译时可确定

	//栈分配
	//int myarray[k];//编译出错
	//const_k必须是编译时已知的常量
	int myarray[const_k];
	for(int i=0;i<const_k;i++)
	{ 
		//未初始化，值为栈上的垃圾值
		std::cout << myarray[i] << std::endl;
	}
	//myarray在栈帧弹出时自动释放


	//堆分配，且用指针寻址
	//动态分配，大小无需在编译时确定
	int* heapArray = new int[k];

	delete[] heapArray; //释放堆内存

	//c++11提供的标准数组，大小必须在编译时确定
	//这是个模板类，通过模板指定类型和大小
	// _EXPORT_STD template <class _Ty, size_t _Size>
	std::array<int, 5> collection;

	collection.size();//成员函数，返回数组大小

	for (int i = 0; i < collection.size(); i++)
	{
		std::cout << collection[i] << std::endl;
	}

	//要让 for (int i : collection) 运行，C++ 编译器会寻找两个特定的函数：begin() 和 end()。
	for (int i : collection)
	{

	}

	std::cin.get();
	return 0;
} 
#endif

使用alloca函数在栈上分配内存#

#ifdef LY_EP91

#include <iostream> 

class Array
{
public:
	Array(int size)
	{
		//alloca函数在栈上分配内存，分配的内存在当前函数返回时自动释放
		m_Data = (int*)alloca(size * sizeof(int));
	}
private:
	int* m_Data;
};

int main()
{
	int size = 5;
	Array arr(size);


	std::cin.get();
	return 0;
}

#endif

代码示例#

#ifdef LY_EP91

#include <iostream> 

//size_t 的使命是“能够表示内存中最大的对象”，
//在几位的机器上运行就是几位大小
template<typename T, size_t S>
class Array
{
public:

	//编译期常量
	constexpr size_t Size() const
	{
		return S;
	}

	//这样会导致取出数组元素后会被复制，且也无法修改
	//T operator[] (int index)

	//返回引用，是能修改的左值
	//1. 普通版本：允许读写
	T& operator[] (size_t index)
	{
		return m_Data[index];
	}


	//2：只允许读,而且返回const引用
	//通过这个返回的普通引用，别人依然可以修改 m_Data 里的内容，这违背了函数末尾 const 的初衷
	 //T& operator[] (int index) const

	//2：只允许读,而且返回const引用
	//取决于你调用该函数的对象本身是否是 const,是const
	//对象则调用该重载版本
	const T& operator[] (size_t index) const
	{
		return m_Data[index];
	}

	T* Data()
	{
		return m_Data;
	}

	//常量版本
	const T* Data() const
	{
		return m_Data;
	}

private:
	T m_Data[S];
};

int main()
{
	//每次创建新类，编译器都会根据模板参数生成一个新的类
	Array<int, 5> data;


	//每个字节都是 1
	memset(&data, 1, data.Size() * sizeof(int));

	//每个字节都是 2
	memset(data.Data(), 2, data.Size() * sizeof(int));

	//把数组中每个字节设为0
	memset(&data[0], 0, data.Size() * sizeof(int));

	//编译期的断言检查。让编译器在把代码编译成程序之前，先检查一下你的逻辑对不对，如果条件不满足，编译器会直接报错并拒绝生成程序 
	static_assert(data.Size() < 10, "Size is too large!");

	//因为data.Size()是编译期常量
	Array<std::string, data.Size()> a;

	//
	const auto& arrayReference = data;

	//arrayReference[2] = 3; //

	//arrayReference是const修饰的，编译器只能调用带有 const 后缀的版本
	std::cout << arrayReference[2] << std::endl;

	for (size_t i = 0; i < data.Size(); i++)
	{
		//data[i] = i;
		std::cout << data[i] << std::endl;
	}

	Array<std::string, 3> data1;
	data1[0] = "hello";
	data1[1] = "world";
	for (size_t i = 0; i < data1.Size(); i++)
	{
		//data[i] = i;
		std::cout << data1[i] << std::endl;
	}

	std::cin.get();
	return 0;
}
/*
0
0
0
0
0
0
hello
world

*/
#endif

93迭代器详解

Sun, 08 Mar 2026 19:58:54 +0800

迭代器的基本定义迭代器是一个对象，其行为类似于指针，用于遍历容器中的元素。它提供了一种统一的方法来访问不同类型容器（如数组、链表、树）中的数据，而无需了解容器的底层实现。
==为什么需要迭代器？==不同的容器有不同的存储结构（内存连续或不连续）。迭代器将“遍历数据”这一行为抽象化，使得开发者可以使用相同的语法（如 ++ 或 *）来处理各种复杂的集合。
核心概念：begin() 与 end()
- begin()：返回指向容器中第一个元素的迭代器。
- end()：返回指向容器中最后一个元素之后位置的迭代器（即“越界”位置）。这用于标记遍历的结束。
迭代器的基本操作演示了如何使用迭代器进行手动遍历：
- 使用 *it（解引用）获取当前元素的值。
- 使用 ++it 将迭代器移动到下一个元素。
- 使用 it != map.end() 作为循环终止条件。
==现代 C++ 中的简化写法 (Range-based for loop)==解释了基于范围的 for 循环（如 for (auto& v : values)）在底层其实就是通过调用容器的 begin() 和 end() 迭代器来实现的。
==在不同容器中的应用（以 std::map 为例）==演示了由于 std::map 不是连续内存空间，不能使用下标 [i] 遍历，此时迭代器是访问元素的唯一标准方式。对于 map，迭代器指向的是 std::pair 类型。

简单例子#

std::vector有几种迭代器：

#ifdef LY_EP86

#include <iostream> 
#include <vector>

//无序映射（哈希表）
#include <unordered_map>

int main()
{
	std::vector<int> values = { 1,2,3,4,5 };
	for (int i = 0; i < values.size(); i++)
	{
		//没有索引系统的集合类型，无法使用下标访问元素
		std::cout << values[i] << std::endl;
	}
	std::cout << "====0===" << std::endl;

	//基于范围的for循环
	for (int value : values)
	{
		std::cout << value << std::endl;
	}
	std::cout << "====1===" << std::endl;

	//values.end()返回一个超出可接受范围的迭代器对象，是个无效迭代器，是最后一个元素的下一个元素，所以不能访问它指向的元素
	//当你修改容器（添加、删除或重新分配内存）时，指向该容器元素的迭代器可能会变得像“野指针”一样，指向错误的内存地址。
	for (std::vector<int>::iterator it = values.begin(); it != values.end(); it++)
	{
		//像对待指针那样，进行解引用
		//因为实际的迭代器类里实现了类似星号的解引用操作符重载 
		std::cout << *it << std::endl;
	}
	std::cout << "====2===" << std::endl;
	using ScoreMap = std::unordered_map<std::string, int>;
	ScoreMap map;
	using ScoreMapConstIter = ScoreMap::const_iterator;
	map["Cherno"] = 5;
	map["c++"] = 2;

	//不修改容器中的元素时，使用const_iterator
	for (ScoreMapConstIter it = map.begin(); it != map.end(); it++)
	{
		//*it是一个pair对象，first成员是key，second成员是value
		//auto&，引用，不会实际复制值
		//迭代器指向的是 std::pair 类型
		auto& key = it->first;
		auto& value = it->second;
		std::cout << key << " " << value << std::endl;
	}
	std::cout << "====3===" << std::endl;
	//kv的类型: std::pair<const std:;string,int> &kv
	for (auto& kv : map)
	{
		auto& key = kv.first;
		auto& value = kv.second;
		std::cout << key << " " << value << std::endl;

	}
	std::cout << "====4===" << std::endl;

	//c++17才支持
	//C++17 的结构化绑定 (Structured Bindings)
	for (const auto& [key,value] : map)
	{ 
		std::cout << key << " " << value << std::endl;

	}

	std::cin.get();
	return 0;;
}
/*
1
2
3
4
5
====0===
1
2
3
4
5
====1===
1
2
3
4
5
====2===
Cherno 5
c++ 2
====3===
Cherno 5
c++ 2
====4===
Cherno 5
c++ 2
*/
#endif

86类型转换运算符

Sun, 08 Mar 2026 00:20:54 +0800

核心概念#

这一集主要讲解了如何定义用户自定义类型转换运算符（User-Defined Conversion Operators），允许你将一个类或结构体的对象隐式或显式地转换为另一种类型（如 int、float 或其他自定义类）。

什么是转换运算符#

背景：通常我们使用构造函数来进行类型转换（例如 Entity(int x) 可以将 int 转为 Entity）。而转换运算符则是反过来的：它定义了如何将你的对象转换为其他类型。
语法：operator type() const { ... }。注意它没有返回类型，因为返回类型已经包含在函数名中了。

代码示例#

假设有一个 Entity 类，包含 std::string Name 和 int Age。
如果你希望将 Entity 对象直接赋值给一个 int（代表 Age），可以写：

operator int() const { return Age; }

这样在调用 int a = entity; 时，编译器会自动调用该运算符。

简单代码#

#ifdef LY_EP86
 
#include <iostream> 
struct Orange
{
	operator float() const
	{
		return 3.14f;
	}
};

void PrintFloat(float value)
{
	std::cout << "PrintFloat(): " << value << std::endl;
}
 
int main()
{ 
	Orange orange;
	float f = orange; //隐式转换，调用 operator float()

	std::cout << f << std::endl; // 输出 3.14
	std::cout << (float)orange << std::endl; // 输出 3.14
	PrintFloat(f);//orange先隐式转换成float

	std::cin.get();
	return 0;
}

#endif

(例子)作用域指针-bool转换符#

#ifdef LY_EP86

#include <iostream> 

template<typename T>
class ScopedPtr
{
public:
	ScopedPtr() = default;
	ScopedPtr(T* ptr) : m_Ptr(ptr) {}
	~ScopedPtr() { delete m_Ptr; }

	//指针是否有效
	bool IsValid() const { return m_Ptr != nullptr; }

	//把对象实例转为bool类型，判断指针是否有效
	/*explicit*/ operator bool() const { return IsValid(); }

	T* Get() { return m_Ptr; }
	const T* Get() const { return m_Ptr; }

private:
	T* m_Ptr = nullptr;
};

struct Entity
{
	float X = 0.0f, Y = 0.0f;
};

void ProcessEntity(const ScopedPtr<Entity>& entity)
{
	if (entity) //隐式调用 operator bool()
	{
		std::cout << "Entity position: (" << (*(entity.Get())).X << ", " << (*(entity.Get())).Y << ")" << std::endl;
	}
	else
	{
		std::cout << "Invalid entity pointer." << std::endl;
	}
}

int main()
{
	//隐式调用ScopedPtr(T* ptr)构造函数创建ScopedPtr对象
	ScopedPtr<Entity> e = new Entity();
	ProcessEntity(e); //输出 Entity position: (0, 0)

	/* std::unique_ptr源码 
	 explicit operator bool() const noexcept {
 return get() != nullptr;
 }
	*/
	std::unique_ptr<Entity> e(new Entity());
	//因为独占指针也可以转换为bool类型 
	ProcessEntity(e);

	std::cin.get();
	return 0;
}
#endif

(例子)定时器#

直接转成双精度（总定时时间）

90stdmove与移动运算符

Sat, 07 Mar 2026 16:53:59 +0800

`std::move` 到底是什么？#

核心真相：std::move 并不移动任何东西。它只是一个简单的类型转换（Casting）。
底层逻辑：它把一个左值（Lvalue）强制转换为右值引用（Rvalue Reference）。它的作用仅仅是告诉编译器：“嘿，我知道这个变量原本是个持久的对象，但现在我不再需要它了，请把它当成一个临时对象，允许别人‘偷’走它的资源。”
代码本质：std::move(x) 基本上等同于 static_cast<T&&>(x)。

移动赋值运算符 (Move Assignment Operator)#

场景引入：第 89 集讲的是构造新对象，而这一集讲的是给已有对象重新赋值。

String dest = "Hello";

//如果你只写了移动构造，没写移动赋值：编译器会“退而求其
//次”，去调用拷贝赋值运算符 operator=(const String& other)。
dest = String("World"); // 这里会涉及移动赋值

手写实现步骤：
1. 清理旧资源：在接管别人的资源前，必须先 delete[] m_Data 释放自己当前的内存（否则会内存泄漏）。
2. 接管资源：像移动构造函数一样，把对方的指针和大小拷过来。
3. 置空对方：将源对象的指针设为 nullptr。
4. 返回自身：return *this; 以支持链式赋值。

为什么 `std::move` 是必需的？#

实战演示：Cherno 展示了当你想把一个已命名的变量移动到另一个地方时，必须显式使用 std::move。
原因：即使一个变量的类型是 String&&，只要它有名字，它就是一个左值。
安全性：这种设计是为了防止你无意中移动了以后还要用到的数据。使用 std::move 是一种显式的“主权放弃”。

常见的错误用法与陷阱#

不要移动 const 对象：如果你尝试 std::move 一个 const 对象，它会默默地退化回拷贝。因为移动语义需要修改原对象（将其置空），而 const 禁止修改。
自赋值检查：在移动赋值运算符中，通常建议检查 if (this != &other)，防止自己移动给自己导致资源被意外提前释放。

(例子1)移动构造函数与移动赋值函数#

#ifdef LY_EP90

//c++11才引入了右值引用
#include <iostream> 
#include <utility> // std::move 在这个头文件里

class String
{
public:

	String() = default;

	//构造函数
	String(const char* string)
	{
		printf("Created!\n");
		//不包括\0
		m_Size = strlen(string);
		m_Data = new char[m_Size];
		memcpy(m_Data, string, m_Size);
		std::cout << "String(const char* string)" << std::endl;
	}

	//复制构造函数
	String(const String& other)
	{
		printf("Copied!\n");
		//不包括\0
		m_Size = other.m_Size;
		m_Data = new char[m_Size];

		//在 C++ 中，访问控制（public/private）是基于“类（Class）”层面的，而不是基于“对象（Object）”层面的。
		//简单来说：只要是在 String 类的成员函数内部，你就可以访问任何 String 对象的私有成员。
		memcpy(m_Data, other.m_Data, m_Size);

		std::cout << "String(const String& other)" << std::endl;
	}


	//移动构造函数
	//接收一个右值引用参数，表示可以从一个将要被销毁的临时对象中“窃取”资源，而不是复制资源。
	//如果手动定义了“移动构造函数”，编译器就不再为你自动生成“默认赋值运算符”了。
	String(String&& other) noexcept
	{
		printf("Moved!\n");
		//不包括\0
		m_Size = other.m_Size;
		m_Data = other.m_Data;

		other.m_Size = 0;//将原对象的大小置为0，表示它不再拥有资源

		//把被接管控制权的资源指针置空，防止原对象的析构函数删除已经被移动的资源
		other.m_Data = nullptr;


		std::cout << "String(String&& other)" << std::endl;
	}

	~String()
	{
		delete[] m_Data;
		printf("Destroyed!\n");
		std::cout << "~String()" << std::endl;
	}

	// 移动赋值运算符
	String& operator=(String&& other) noexcept
	{
		printf("Move Assigned!\n");

		// 1. 自赋值检查 (防止自己移动给自己，如 a = std::move(a))
		if (this != &other)
		{
			// 2. 释放旧资源 (dest 已经有内存了，必须先删掉，否则内存泄漏)
			delete[] m_Data;

			// 3. 窃取资源
			m_Size = other.m_Size;
			m_Data = other.m_Data;

			// 4. 将原对象置空 (让它变成空壳)
			other.m_Data = nullptr;
			other.m_Size = 0;
		}

		return *this;
	}

	//拷贝赋值运算符
	String& operator=(const String& other)
	{
		printf("Copy Assigned!\n");
		if (this != &other)
		{
			delete[] m_Data;
			m_Size = other.m_Size;
			m_Data = new char[m_Size]; // 必须申请新内存
			memcpy(m_Data, other.m_Data, m_Size);
		}
		return *this;
	}

	void Print()
	{
		for (uint32_t i = 0; i < m_Size; i++)
			printf("%c", m_Data[i]);
		printf("\n");
	}
private:
	char* m_Data;

	//这是一个通过 typedef 或 using 定义的类型，表示
	//无符号整型32位数。
	// int 在某些古老的 16 位系统上可能是 2 字节，在现代系统上通常是 4 字节，uint32_t 强制规定在任何符合标准的编译器上，它永远是 32 位（4 字节）
	uint32_t m_Size;
};

class Entity
{
public:


	Entity(const String& name)
		:m_Name(name)
	{
		std::cout << "Entity(const String& name)" << std::endl;
	}



	//Entity(String&& name)
	//	//一旦右值引用有了名字，它在后续表达式中就变成了左值。
	//	//编译器会想：“这个 name 虽然是引用进来的，但它现在是有名有姓的变量，为了安全起见，我必须调用 复制构造函数 来保护它。
	//	:m_Name(name)
	//{
	//	std::cout << "Entity( String&& name)" << std::endl;
	//}



	//接收一个临时对象作为参数，使用移动语义来构造 Entity 对象，避免不必要的复制，提高性能。
	Entity(String&& name)
		//强转为右值引用，告诉编译器：我知道 name 是一个左值，但我想把它当作一个将要被销毁的临时对象来处理，所以请调用 移动构造函数 来构造 m_Name。
		//:m_Name((String&&)name) //这种写法也行
		:m_Name(std::move(name)) // 将左值 name 强行转回右值
	{
		std::cout << "Entity( String&& name)" << std::endl;
	}

	void PrintName()
	{
		m_Name.Print();
	}

private:
	String m_Name;
};

int main()
{
	//这里将"Cherno"隐式调用构造函数构造了一个String
	//之后move给了Entity（Entity内部的m_Name接管了这个临时String指针指向的堆内存）
	Entity entity("Cherno");
	entity.PrintName();
	std::cout << "===0==" << std::endl;
	String string = "Hello";
	std::cout << "===1==" << std::endl;
	String dest = string;//这是复制
	std::cout << "===2==" << std::endl;
	String dest1 = std::move(string);//调用移动构造函数
	dest1.Print();
	std::cout << "===3==" << std::endl;
	//如果没写移动赋值,编译器会“退而求其次”，去调用拷贝赋值运算符 operator=(const String & other)
	dest = "abc";
	std::cout << "===4==" << std::endl;
	 
	dest = std::move(string);
	dest.Print();//string已经被移动了，变成了空壳，所以dest打印出来是空的

	std::cin.get();
	return 0;
}
/*
Created!
String(const char* string)
Moved!
String(String&& other)
Entity( String&& name)
Destroyed!
~String()
Cherno
===0==
Created!
String(const char* string)
===1==
Copied!
String(const String& other)
===2==
Moved!
String(String&& other)
Hello
===3==
Created!
String(const char* string)
Move Assigned!
Destroyed!
~String()
===4==
Move Assigned!

*/
#endif

(例子2)详细解释#

#ifdef LY_EP90

//c++11才引入了右值引用
#include <iostream> 
#include <utility> // std::move 在这个头文件里

class String
{
public:

	String() = default;

	//构造函数
	String(const char* string)
	{
		printf("Created!\n");
		//不包括\0
		m_Size = strlen(string);
		m_Data = new char[m_Size];
		memcpy(m_Data, string, m_Size);
		std::cout << "String(const char* string)" << std::endl;
	}

	//复制构造函数
	String(const String& other)
	{
		printf("Copied!\n");
		//不包括\0
		m_Size = other.m_Size;
		m_Data = new char[m_Size];

		//在 C++ 中，访问控制（public/private）是基于“类（Class）”层面的，而不是基于“对象（Object）”层面的。
		//简单来说：只要是在 String 类的成员函数内部，你就可以访问任何 String 对象的私有成员。
		memcpy(m_Data, other.m_Data, m_Size);

		std::cout << "String(const String& other)" << std::endl;
	}


	//移动构造函数
	//接收一个右值引用参数，表示可以从一个将要被销毁的临时对象中“窃取”资源，而不是复制资源。
	//如果手动定义了“移动构造函数”，编译器就不再为你自动生成“默认赋值运算符”了。
	String(String&& other) noexcept
	{
		printf("Moved!\n");
		//不包括\0
		m_Size = other.m_Size;
		m_Data = other.m_Data;

		other.m_Size = 0;//将原对象的大小置为0，表示它不再拥有资源

		//把被接管控制权的资源指针置空，防止原对象的析构函数删除已经被移动的资源
		other.m_Data = nullptr;


		std::cout << "String(String&& other)" << std::endl;
	}

	~String()
	{
		delete[] m_Data;
		printf("Destroyed!\n");
		std::cout << "~String()" << std::endl;
	}

	// 移动赋值运算符：将另一个对象，移入当前这个对象自身
	//语义契约（Semantic Contract）。	C++ 的设计哲学是：让自定义类型的行为表现得像内置类型（如 int）一样。标准做法始终是返回非 const 的 *this 引用
	String& operator=(String&& other) noexcept
	{
		printf("Move Assigned!\n");

		// 1. 自赋值检查 (防止自己移动给自己，如 a = std::move(a)，
		// 因为如下是会释放旧资源的，所以移动给自己就什么都没有了)
		if (this != &other)
		{
			// 2. 释放旧资源 (dest[当前对象] 已经有内存了，必须先删掉，否则内存泄漏)
			delete[] m_Data;

			// 3. 窃取资源
			m_Size = other.m_Size;
			m_Data = other.m_Data;

			// 4. 将原对象置空 (让它变成空壳)
			other.m_Data = nullptr;
			other.m_Size = 0;
		}

		//找到 this 指向的对象，返回它的引用（别名），
		// 而不是创建一个新的副本
		return *this;
	}

	//拷贝赋值运算符
	String& operator=(const String& other)
	{
		printf("Copy Assigned!\n");
		if (this != &other)
		{
			delete[] m_Data;
			m_Size = other.m_Size;
			m_Data = new char[m_Size]; // 必须申请新内存
			memcpy(m_Data, other.m_Data, m_Size);
		}
		return *this;
	}

	void Print()
	{
		for (uint32_t i = 0; i < m_Size; i++)
			printf("%c", m_Data[i]);
		printf("\n");
	}
private:
	char* m_Data;

	//这是一个通过 typedef 或 using 定义的类型，表示
	//无符号整型32位数。
	// int 在某些古老的 16 位系统上可能是 2 字节，在现代系统上通常是 4 字节，uint32_t 强制规定在任何符合标准的编译器上，它永远是 32 位（4 字节）
	uint32_t m_Size;
};

class Entity
{
public:


	Entity(const String& name)
		:m_Name(name)
	{
		std::cout << "Entity(const String& name)" << std::endl;
	}



	//Entity(String&& name)
	//	//一旦右值引用有了名字，它在后续表达式中就变成了左值。
	//	//编译器会想：“这个 name 虽然是引用进来的，但它现在是有名有姓的变量，为了安全起见，我必须调用 复制构造函数 来保护它。
	//	:m_Name(name)
	//{
	//	std::cout << "Entity( String&& name)" << std::endl;
	//}



	//接收一个临时对象作为参数，使用移动语义来构造 Entity 对象，避免不必要的复制，提高性能。
	Entity(String&& name)
		//强转为右值引用，告诉编译器：我知道 name 是一个左值，但我想把它当作一个将要被销毁的临时对象来处理，所以请调用 移动构造函数 来构造 m_Name。
		//:m_Name((String&&)name) //这种写法也行
		:m_Name(std::move(name)) // 将左值 name 强行转回右值
	{
		std::cout << "Entity( String&& name)" << std::endl;
	}

	void PrintName()
	{
		m_Name.Print();
	}

private:
	String m_Name;
};

int main()
{
	//临时对象经历了:Created! -> Moved! -> Destroyed!
	Entity entity("Cherno");
	//打印字符串
	entity.PrintName();
	std::cout << "=====0=====" << std::endl;

	//隐式调用构造函数String(const char* string)，Created! 
	String string = "Hello";
	std::cout << "=====1=====" << std::endl;

	//隐式调用(复制)构造函数， 本质上就是“通过复制一个已有的对象来创建一个新对象”，这就是所谓的“复制构造”。
	String dest = string;
	std::cout << "=====2.1=====" << std::endl;
	//使用接受字符串右值引用的构造函数，来构造一个String
	String dest1 = (String&&)string;
	std::cout << "=====2.2=====" << std::endl;
	String dest2((String&&)string);//这个string内部的指针已经被dest1接管了，所以dest2构造的时候，string已经是空壳了，所以dest2也是空的
	std::cout << "=====2.3=====" << std::endl;

	//这样写无需知道string是什么类型的
	//remove_reference_t<_Ty>&& move(_Ty&& _Arg) ，查看源码可知返回的是右值引用
	//这里是移动构造，而非移动赋值，因为dest3是第一次定义并使用
	String dest3 = std::move(string);
	std::cout << "=====3=====" << std::endl;

	//当将一个变量(数值、表达式)赋给一个已有变量时，使用的是赋值
	//就像这里是移动赋值
	dest = std::move(string);


	std::cin.get();
	return 0;
}
/*
Created!
String(const char* string)
Moved!
String(String&& other)
Entity( String&& name)
Destroyed!
~String()
Cherno
=====0=====
Created!
String(const char* string)
=====1=====
Copied!
String(const String& other)
=====2.1=====
Moved!
String(String&& other)
=====2.2=====
Moved!
String(String&& other)
=====2.3=====
Moved!
String(String&& other)
=====3=====
Move Assigned!
*/
#endif

(例子3)视频举的#

#ifdef LY_EP90

//c++11才引入了右值引用
#include <iostream> 
#include <utility> // std::move 在这个头文件里

class String
{
public:

	String() = default;

	//构造函数
	String(const char* string)
	{
		printf("Created!\n");
		//不包括\0
		m_Size = strlen(string);
		m_Data = new char[m_Size];
		memcpy(m_Data, string, m_Size);
		std::cout << "String(const char* string)" << std::endl;
	}

	//复制构造函数
	String(const String& other)
	{
		printf("Copied!\n");
		//不包括\0
		m_Size = other.m_Size;
		m_Data = new char[m_Size];

		//在 C++ 中，访问控制（public/private）是基于“类（Class）”层面的，而不是基于“对象（Object）”层面的。
		//简单来说：只要是在 String 类的成员函数内部，你就可以访问任何 String 对象的私有成员。
		memcpy(m_Data, other.m_Data, m_Size);

		std::cout << "String(const String& other)" << std::endl;
	}


	//移动构造函数
	//接收一个右值引用参数，表示可以从一个将要被销毁的临时对象中“窃取”资源，而不是复制资源。
	//如果手动定义了“移动构造函数”，编译器就不再为你自动生成“默认赋值运算符”了。
	String(String&& other) noexcept
	{
		printf("Moved!\n");
		//不包括\0
		m_Size = other.m_Size;
		m_Data = other.m_Data;

		other.m_Size = 0;//将原对象的大小置为0，表示它不再拥有资源

		//把被接管控制权的资源指针置空，防止原对象的析构函数删除已经被移动的资源
		other.m_Data = nullptr;


		std::cout << "String(String&& other)" << std::endl;
	}

	~String()
	{
		delete[] m_Data;
		printf("Destroyed!\n");
		std::cout << "~String()" << std::endl;
	}

	// 移动赋值运算符：将另一个对象，移入当前这个对象自身
	//语义契约（Semantic Contract）。	C++ 的设计哲学是：让自定义类型的行为表现得像内置类型（如 int）一样。标准做法始终是返回非 const 的 *this 引用
	String& operator=(String&& other) noexcept
	{
		printf("Move Assigned!\n");

		// 1. 自赋值检查 (防止自己移动给自己，如 a = std::move(a)，
		// 因为如下是会释放旧资源的，所以移动给自己就什么都没有了)
		if (this != &other)
		{
			// 2. 释放旧资源 (dest[当前对象] 已经有内存了，必须先删掉，否则内存泄漏)
			delete[] m_Data;

			// 3. 窃取资源
			m_Size = other.m_Size;
			m_Data = other.m_Data;

			// 4. 将原对象置空 (让它变成空壳)
			other.m_Data = nullptr;
			other.m_Size = 0;
		}

		//找到 this 指向的对象，返回它的引用（别名），
		// 而不是创建一个新的副本
		return *this;
	}

	//拷贝赋值运算符
	String& operator=(const String& other)
	{
		printf("Copy Assigned!\n");
		if (this != &other)
		{
			delete[] m_Data;
			m_Size = other.m_Size;
			m_Data = new char[m_Size]; // 必须申请新内存
			memcpy(m_Data, other.m_Data, m_Size);
		}
		return *this;
	}

	void Print()
	{
		for (uint32_t i = 0; i < m_Size; i++)
			printf("%c", m_Data[i]);
		printf("\n");
	}
private:
	char* m_Data;

	//这是一个通过 typedef 或 using 定义的类型，表示
	//无符号整型32位数。
	// int 在某些古老的 16 位系统上可能是 2 字节，在现代系统上通常是 4 字节，uint32_t 强制规定在任何符合标准的编译器上，它永远是 32 位（4 字节）
	uint32_t m_Size;
};

class Entity
{
public:


	Entity(const String& name)
		:m_Name(name)
	{
		std::cout << "Entity(const String& name)" << std::endl;
	}



	//Entity(String&& name)
	//	//一旦右值引用有了名字，它在后续表达式中就变成了左值。
	//	//编译器会想：“这个 name 虽然是引用进来的，但它现在是有名有姓的变量，为了安全起见，我必须调用 复制构造函数 来保护它。
	//	:m_Name(name)
	//{
	//	std::cout << "Entity( String&& name)" << std::endl;
	//}



	//接收一个临时对象作为参数，使用移动语义来构造 Entity 对象，避免不必要的复制，提高性能。
	Entity(String&& name)
		//强转为右值引用，告诉编译器：我知道 name 是一个左值，但我想把它当作一个将要被销毁的临时对象来处理，所以请调用 移动构造函数 来构造 m_Name。
		//:m_Name((String&&)name) //这种写法也行
		:m_Name(std::move(name)) // 将左值 name 强行转回右值
	{
		std::cout << "Entity( String&& name)" << std::endl;
	}

	void PrintName()
	{
		m_Name.Print();
	}

private:
	String m_Name;
};

int main()
{ 
	{
		std::cout << "=====0=====" << std::endl;


		//使用String(const char* string)构造String对象，Created!
		String apple = "Apple";
		//使用默认构造函数构造String对象
		String dest;

		std::cout << "=====1=====" << std::endl;
		std::cout << "Apple: ";
		apple.Print();
		std::cout << "Dest: ";
		dest.Print();
		std::cout << "=====1=====" << std::endl;

		//使用移动赋值运算符将apple的资源移入dest，Move Assigned!
		//相当于dest.operator=(std::move(apple));
		dest = std::move(apple);

		std::cout << "=====2=====" << std::endl;
		std::cout << "Apple: ";
		apple.Print();
		std::cout << "Dest: ";
		dest.Print();
		std::cout << "=====2=====" << std::endl;

		//综上，没有任何复制就移动了整个字符数组的所有权，交换了两个
		//变量
	}
	

	std::cin.get();
	return 0;
}
/* 
=====0=====
Created!
String(const char* string)
=====1=====
Apple: Apple
Dest:
=====1=====
Move Assigned!
=====2=====
Apple:
Dest: Apple
=====2=====
Destroyed!
~String()
Destroyed!
~String()
*/
#endif

结尾 | 总结：拷贝 vs 移动#

拷贝 (Copy)：两份独立的资源，安全但慢。
移动 (Move)：一份资源的所有权转移，极快。
金句：如果你希望你的 C++ 程序拥有极致性能，学会何时及如何使用 std::move 是必修课。
当包含移动构造函数时，应该也包含移动赋值函数

89移动语义

Sat, 07 Mar 2026 12:53:20 +0800

为什么要引入移动语义？#

核心痛点：在 C++11 之前，将对象从一处转移到另一处通常只能通过“拷贝”。
- 向一个函数传递一个对象
- 从函数返回一个对象
  - 如果有返回值优化RVO (Return Value Optimization)。编译器直接在调用者（Caller）的栈帧中构造该对象，而不是在函数内部构造再拷贝出来。结果：既没有拷贝构造，也没有移动构造，性能损耗为零。
  - 当编译器因为逻辑复杂（例如根据条件返回不同的局部变量）而无法进行 RVO 时，移动语义就成了“二号救兵”。
    - 旧时代 (C++11 之前)：如果 RVO 失效，必须调用拷贝构造函数，这涉及昂贵的深拷贝。
    - 现代 C++ (C++11 之后)：编译器会尝试调用移动构造函数。1. 因为返回的对象是一个即将销毁的右值，它可以被“掠夺”。2. 你不需要手动写 return std::move(obj);，编译器会自动处理局部变量的返回。
性能代价：如果对象持有堆内存（如字符串或数组），拷贝意味着：申请新内存 -> 复制所有数据 -> 销毁旧对象。这在处理临时对象（扔掉的对象）时是非常巨大的浪费。
解决方案：如果我们可以直接“移动”对象——即把旧对象的内存指针直接交给新对象，就能省去内存分配和数据复制的开销。

基础：构建实验用的 `String` 类#

模拟场景：Cherno 编写了一个简易的 String 类，包含一个 char* 指针和 size。
可视化调试：在构造函数中加入 printf("Created")，在拷贝构造函数中加入 printf("Copied")，以便观察内存分配发生的时机。

拷贝的代价演示#

实验代码：创建一个 Entity 类，它拥有一个 String 成员。当通过构造函数传入一个字符串字面量时，会发现控制台打印了 “Created” 然后是 “Copied”。
问题分析：即便传入的是一个临时字符串（右值），Entity 仍然会调用拷贝构造函数进行深拷贝。明明临时对象马上就要销毁了，我们却还要复制它，这很不科学。

#ifdef LY_EP89

//c++11才引入了右值引用
#include <iostream> 

class String
{
public:
	String() = default;

	//构造函数
	String(const char* string)
	{
		printf("Created!\n");
		//不包括\0
		m_Size = strlen(string);
		m_Data = new char[m_Size];
		memcpy(m_Data, string, m_Size);
		std::cout << "String(const char* string)" << std::endl;
	}
	
	//复制构造函数
	String(const String& other)
	{
		printf("Copied!\n");
		//不包括\0
		m_Size = other.m_Size;
		m_Data = new char[m_Size];

		//在 C++ 中，访问控制（public/private）是基于“类（Class）”层面的，而不是基于“对象（Object）”层面的。
		//简单来说：只要是在 String 类的成员函数内部，你就可以访问任何 String 对象的私有成员。
		memcpy(m_Data, other.m_Data, m_Size);

		std::cout << "String(const String& other)" << std::endl;
	}
	 

	~String()
	{
		delete[] m_Data;
		printf("Destroyed!\n");
		std::cout << "~String()" << std::endl;
	}

	void Print()
	{
		for (uint32_t i = 0; i < m_Size; i++)
			printf("%c", m_Data[i]);
		printf("\n");
	}
private:
	char* m_Data;

	//这是一个通过 typedef 或 using 定义的类型，表示
	//无符号整型32位数。
	// int 在某些古老的 16 位系统上可能是 2 字节，在现代系统上通常是 4 字节，uint32_t 强制规定在任何符合标准的编译器上，它永远是 32 位（4 字节）
	uint32_t m_Size;
};

class Entity
{
public:
	Entity(const String& name)
		:m_Name(name)
	{
		std::cout << "Entity(const String& name)" << std::endl;
	} 

	void PrintName()
	{
		m_Name.Print();
	}

private:
	String m_Name;
};

int main()
{
	//隐式构造函数构造String对象，调用String(const char* string)构造函数
	//Entity entity("Cherno");

	//临时对象String("Cherno")的生命周期直到支持它的那个“完整表达式”计算完成为止，即该行代码分号结束时
	//!!现在main函数创建这个(临时)对象后，传(复制)给Entity构造函数的当参数使用，又马上销毁了这个临时对象(只留下复制的)
	Entity entity(String("Cherno"));

	entity.PrintName();

	std::cin.get();
	return 0;
}
/*
Created!
String(const char* string)
Copied!
String(const String& other)
Entity(const String& name)
Destroyed!
~String()
Cherno
*/
#endif

编写移动构造函数 (Move Constructor)#

核心语法：使用右值引用 String(String&& other)。注意要加上 noexcept 关键字。
实现逻辑（偷走资源）：
1. 直接将 this->m_Data 指向 other.m_Data（浅拷贝指针）。
2. 将 this->m_Size 设为 other.m_Size。
关键的一步（置空原对象）：必须将 other.m_Data 设为 nullptr，并将 other.m_Size 设为 0。
原理：这把旧对象变成了一个“空壳”。当旧对象析构时，delete nullptr 不会做任何事，从而保证了内存所有权的完美转移。

#ifdef LY_EP89

//c++11才引入了右值引用
#include <iostream> 
#include <utility> // std::move 在这个头文件里

class String
{
public:
	String() = default;

	//构造函数
	String(const char* string)
	{
		printf("Created!\n");
		//不包括\0
		m_Size = strlen(string);
		m_Data = new char[m_Size];
		memcpy(m_Data, string, m_Size);
		std::cout << "String(const char* string)" << std::endl;
	}

	//复制构造函数
	String(const String& other)
	{
		printf("Copied!\n");
		//不包括\0
		m_Size = other.m_Size;
		m_Data = new char[m_Size];

		//在 C++ 中，访问控制（public/private）是基于“类（Class）”层面的，而不是基于“对象（Object）”层面的。
		//简单来说：只要是在 String 类的成员函数内部，你就可以访问任何 String 对象的私有成员。
		memcpy(m_Data, other.m_Data, m_Size);

		std::cout << "String(const String& other)" << std::endl;
	}


	//移动构造函数
	//接收一个右值引用参数，表示可以从一个将要被销毁的临时对象中“窃取”资源，而不是复制资源。
	String(String&& other) noexcept
	{
		printf("Moved!\n");
		//不包括\0
		m_Size = other.m_Size;
		m_Data = other.m_Data;

		other.m_Size = 0;//将原对象的大小置为0，表示它不再拥有资源

		//把被接管控制权的资源指针置空，防止原对象的析构函数删除已经被移动的资源
		other.m_Data = nullptr;


		std::cout << "String(String&& other)" << std::endl;
	}

	~String()
	{
		delete[] m_Data;
		printf("Destroyed!\n");
		std::cout << "~String()" << std::endl;
	}

	void Print()
	{
		for (uint32_t i = 0; i < m_Size; i++)
			printf("%c", m_Data[i]);
		printf("\n");
	}
private:
	char* m_Data;

	//这是一个通过 typedef 或 using 定义的类型，表示
	//无符号整型32位数。
	// int 在某些古老的 16 位系统上可能是 2 字节，在现代系统上通常是 4 字节，uint32_t 强制规定在任何符合标准的编译器上，它永远是 32 位（4 字节）
	uint32_t m_Size;
};

class Entity
{
public:


	Entity(const String& name) 
		:m_Name(name)
	{
		std::cout << "Entity(const String& name)" << std::endl;
	}



	//Entity(String&& name)
	//	//一旦右值引用有了名字，它在后续表达式中就变成了左值。
	//	//编译器会想：“这个 name 虽然是引用进来的，但它现在是有名有姓的变量，为了安全起见，我必须调用 复制构造函数 来保护它。
	//	:m_Name(name)
	//{
	//	std::cout << "Entity( String&& name)" << std::endl;
	//}
	


	//接收一个临时对象作为参数，使用移动语义来构造 Entity 对象，避免不必要的复制，提高性能。
	Entity(String&& name)
		//强转为右值引用，告诉编译器：我知道 name 是一个左值，但我想把它当作一个将要被销毁的临时对象来处理，所以请调用 移动构造函数 来构造 m_Name。
		//:m_Name((String&&)name) //这种写法也行
		:m_Name(std::move(name)) // 将左值 name 强行转回右值
	{
		std::cout << "Entity( String&& name)" << std::endl;
	}

	void PrintName()
	{
		m_Name.Print();
	}

private:
	String m_Name;
};

int main()
{
	//隐式构造函数构造String对象，调用String(const char* string)构造函数
	//Entity entity("Cherno");

	//临时对象String("Cherno")的生命周期直到支持它的那个“完整表达式”计算完成为止，即该行代码分号结束时
	//!!现在main函数创建这个(临时)对象后，传(复制)给Entity构造函数的当参数使用，又马上销毁了这个临时对象(只留下复制的)
	Entity entity(String("Cherno"));

	entity.PrintName();

	std::cin.get();
	return 0;
}
/*
Created!
String(const char* string)
Moved!
String(String&& other)
Entity( String&& name)
Destroyed!
~String()
Cherno
*/
#endif

激活移动语义：`std::move`#

常见误区：即便写了移动构造函数，编译器在==某些情况下（如成员变量赋值）==可能仍会选择拷贝。
解决方法：在 Entity 的构造函数中使用 m_Name(std::move(name))。
效果验证：再次运行程序，你会发现 “Copied” 变成了 “Moved”。这意味着没有发生新的内存分配，程序运行得更快了。

#ifdef LY_EP89_

//#include <utility> //不加的话，std::move编译报错

int main()
{
	//int a=std::move(3);
	return 0;
}

#endif

结尾 | 总结与展望#

核心价值：移动语义让你在不损失代码可读性的前提下，极大地提升了处理大型对象和临时对象的性能。

85左值与右值

Fri, 06 Mar 2026 22:42:42 +0800

什么是左值和右值？#

核心定义：Cherno 用最简单的方式解释了两者。
- 左值 (lvalue) ~~定位值~~ ：有存储地址、有名字的变量。你可以给它赋值，它通常存在于表达式的左侧。
- 右值 (rvalue)：临时值，没有名字，通常在表达式结束后就销毁了（如字面量 10 或临时函数返回值）。
直观判定法：如果你能取这个东西的地址（使用 & 运算符），它通常就是左值。

左值引用 (lvalue references)#

回顾：这就是我们常用的 int& a = b;。
规则限制：左值引用不能绑定到右值上。
- int& a = 10; 会报错，因为 10 是右值。
- 例外情况：const int& a = 10; 是合法的。编译器会产生一个临时变量来存放 10，然后让引用绑定它。这在函数参数传递中非常常见。

例子#

#ifdef LY_EP85

#include <iostream> 



void SetValueConst(const int& value)
{

}

void SetValue1(int& value)
{

}
void SetValue(int value)
{

}

int GetValue()
{
	return 10;//10是一个右值
}

int& GetRefValue()
{
	static int i=10;
	std::cout << "GetRefValue():" << i << std::endl; 
	return i;
}

int main()
{
	int i = 10;//i为左值，10为右值
	//10 = 3;//表达式必须为左值，10是右值，不能作为表达式的左边
	int a = i;//讲一个左值(a)设置为另一个左值(i)
	int i1 = GetValue();//GetValue()是一个右值，i是一个左值
	//GetValue() = 5;//GetValue()是一个右值，不能作为表达式的左边，而表达式必须是一个可修改的左值

	for (int i = 0; i < 3; i++)
	{
		GetRefValue()++;//GetRefValue()是一个左值，可以作为表达式的左边 

	}
	/*
GetRefValue():10
GetRefValue():11
GetRefValue():12
	*/

	SetValue(i);//i是一个左值，可以作为表达式的右边，用左值创建一个临时对象，并将其作为实参传递给函数
	SetValue(10);//10是一个右值，可以作为表达式的右边,即用右值创建一个临时对象，并将其作为实参传递给函数

	SetValue1(i);//从左值创建一个左值引用，所以可以将左值i作为实参传递给函数SetValue1(int& value)，编译器会将i作为实参传递给函数

	//SetValue1(10); //编译出错：不能从右值创建一个左值引用，所以不能将右值10作为实参传递给函数SetValue1(int& value)，编译器会报错 //非const的引用，必须通过左值来初始化

	SetValueConst(i);//从左值创建一个const左值引用 

	SetValueConst(10);//从右值创建一个const左值引用 
	//int& a1 = 10;//非const的引用，必须通过左值来初始化

	//编译器可能创建了一个带实际存储的临时变量(比如temp=10)，然后
	//const int& b1=temp;
	const int& b1 = 11;//const的引用，还可以通过右值来初始化

	std::cin.get();
	return 0;
}
 
#endif

右值引用 (rvalue references) —— `&&`#

新语法：C++11 引入了 int&&。
作用：它专门用来绑定右值。
- int&& a = 10; 是合法的。
- 它允许我们“拦截”那些即将销毁的临时对象。
意义何在？：这是为了性能优化。既然右值是临时的，我们与其拷贝它的数据，不如直接“偷”走它的资源（这就是移动语义的基础）。

实际应用：函数重载#

场景演示：Cherno 展示了如何通过重载同一函数名，分别处理左值和右值：

void PrintName(const std::string& name); // 接收左值和 const 右值
void PrintName(std::string&& name); // 专门接收右值（临时对象）

解释

84跟踪内存的分配与释放

Fri, 06 Mar 2026 17:08:25 +0800

核心原理：重载全局 `new`#

原理：在 C++ 中，当你写 new Object() 时，它实际上调用了一个名为 operator new 的全局函数。
自定义拦截：你可以重写这个函数。编译器会优先使用你的自定义版本，而不是标准库提供的版本。
代码演示：

void* operator new(size_t size) {
 std::cout << "Allocating " << size << " bytes\n";
 return malloc(size); // 最终还是要调用底层的内存分配
}

对应的 `delete` 重载#

对称性：重载了 new 就必须重载 delete，否则可能会导致内存管理逻辑不一致。
代码实现：

 void operator delete(void* memory, size_t size) {
 std::cout << "Freeing " << size << " bytes\n";
 free(memory);
 }

注意：Cherno 提到现代 C++ 建议使用带 size 参数的 delete 版本，以便更精准地追踪。

实战：追踪总分配量 (The Tracker)#

引入单例/全局状态：为了统计数据，Cherno 定义了一个简单的结构体来存储 TotalAllocated 和 TotalFreed。
逻辑：在 new 里面让计数器增加，在 delete 里面减少。
演示：通过创建一个 std::string 或自己的 Entity 类，观察控制台实时打印出的分配字节数。

完整代码#

#ifdef LY_EP84

#include <iostream> 
#include <memory>

struct AllocationMetrics
{
	uint32_t TotalAllocated = 0;
	uint32_t TotalFreed = 0;
	
	uint32_t CurrentUsage()
	{
		return TotalAllocated - TotalFreed;
	}
};

static AllocationMetrics s_AllocationMetrics;

//重写operator new 的全局函数，
//链接器会转而链接这个函数
void* operator new(size_t size)
{
	s_AllocationMetrics.TotalAllocated += size;
	std::cout << "Allocating " << size << " bytes\n";
	return malloc(size);
}

//重写特定函数签名来获取特定的释放大小的信息
void operator delete(void* memory, size_t size)
{

	s_AllocationMetrics.TotalFreed += size;
	std::cout << "Freeing " << size << " bytes\n";
	free(memory);
}

struct Object
{
	int x, y, z;
};

/*
内存使用情况
*/
static void PrintMemoryUsage()
{
	std::cout << "Memory Usage: " << s_AllocationMetrics.CurrentUsage() << " bytes.\n";
}


int main()
{
	PrintMemoryUsage();
	Object* obj = new Object;

	//正好12字节，在 C++ 中，类/结构体本身不包含任何运行时开销。
	std::cout << "Size of Object: " << sizeof(Object) << std::endl;

	PrintMemoryUsage();
	std::string s = "Cherno";

	PrintMemoryUsage();
	std::cout << "=========" << std::endl;

	//这行代码仍会分配12字节
	std::unique_ptr<Object> obj1 = std::make_unique<Object>();
	PrintMemoryUsage();
	std::cout << "**********" << std::endl;

	{
		std::unique_ptr<Object> obj =
			std::make_unique<Object>();
		PrintMemoryUsage();
	}

	PrintMemoryUsage();

	std::cin.get();
	return 0;
}

/*
Memory Usage: 0 bytes.
Allocating 12 bytes
Size of Object: 12
Memory Usage: 12 bytes.
Allocating 8 bytes
Memory Usage: 20 bytes.
=========
Allocating 12 bytes
Memory Usage: 32 bytes.
**********
Allocating 12 bytes
Memory Usage: 44 bytes.
Freeing 12 bytes
Memory Usage: 32 bytes.
*/
#endif

new#

设置断点在operator new函数里面的return malloc(size);
（Debug模式下）第二次进入断点，即std::string s = "Cherno";后进去，调用栈如下（从下往上）

82单例模式详解

Fri, 06 Mar 2026 13:40:48 +0800

单例模式 (Singleton)。单例的核心思想是：在整个应用程序的生命周期中，某个类只存在一个实例。

什么是单例？ (The Concept)#

核心定义：单例是只有单一实例的类。
应用场景：当你需要一个全局访问点来管理某些资源时（如随机数生成器、渲染器、数据库连接等）非常有用。
争议性：单例本质上是“披着类外壳的全局变量”，在某些开发者眼中这被视为一种“反模式”，但 Cherno 认为在特定场景下它非常高效。 ~~把类当做命名空间来调用某些函数~~
如果你只有一个实例，你那实际有的就只是一组数据，以及一些配套功能
替代单例：属于某个命名空间的函数、全局变量、某个与源文件关联的静态变量、特定的C++源文件
单例的生命周期和应用程序的一样

基础实现逻辑 (Basic Implementation)#

单例模式主要依靠以下三个步骤实现：

私有化构造函数：通过 private 构造函数防止外部通过 new 或直接声明来创建新实例。
禁用拷贝构造：删除拷贝构造函数（ClassName(const ClassName&) = delete;），确保无法通过复制来产生第二个实例。
静态访问点：提供一个静态方法（通常命名为 Get()），返回那个唯一的静态实例。

#ifdef LY_EP82

#include <iostream> 


class Singleton
{
public:
	Singleton(const Singleton&) = delete;//禁止拷贝
	static Singleton& Get()
	{
		return s_Instance;
	}
	void Function() {
		std::cout << "Function" << std::endl;
	}
private:
	float m_Member = 3.4f;
	Singleton() {}

	static Singleton s_Instance;
};


//定义 
//1. 在全局/静态内存区分配 sizeof(Singleton) 字节的空间。
//2. 在程序启动时，自动调用 Singleton 的构造函数来初始化这块空间。
//由于你使用了作用域解析符 Singleton::，编译器认为这行代码依然属于 Singleton 类的范畴
Singleton Singleton::s_Instance;

int main()
{
	//这种写法，调用了Singleton类的复制构造函数，
	//拷贝了所有成员，并创建了一个新的实例（违背单例本意）
	//类定义中Singleton(const Singleton&) = delete;//禁止拷贝
	//Singleton instance = Singleton::Get();

	auto& instantce = Singleton::Get();
	Singleton::Get().Function();

	std::cin.get();
	return 0;
}
#endif

现代 C++ 的最佳实践 (The Best Way)#

Cherno 演示了最简洁且线程安全的单例写法（C++11 及更高版本）：

80加速字符串操作

Fri, 06 Mar 2026 10:16:18 +0800

附：常量字符串#

	std::string name = "Yan Chernikov";

关于空字符#

右侧的字面量 “Yan Chernikov”(13个看得见的字符) 在内存（常量区）中以 \0 结尾。
左侧的 std::string 对象会在堆上申请空间，并把这 13 个字符拷贝过去。
关键点：std::string 内部实现总是会额外多分配一个字节来存储这个 \0。这是为了确保当你调用 name.c_str() 时，能返回一个符合 C 语言标准的、以空字符结尾的字符串。

关于赋值#

字面量字符串是一个const char[N]类型的数组

数组退化 (Array-to-pointer decay)：字符串字面量首先从 const char[14] 退化为指向首元素的指针 const char* 。
调用构造函数(Implicit Constructor Call)： std::string 类有一个接收 const char* 参数的构造函数。由于该构造函数没有被标记为 explicit，编译器会自动调用它来创建一个临时的 std::string 对象。
内存分配(The “Cost”)：正如 Cherno 在第 80 集中强调的，这个隐式转换并不只是“换个名字”，它会在堆（Heap）上分配内存，并将字符串内容拷贝进去。

name.size()：返回 13（不计入 \0）。
name[13]：在 C++11 及以后的标准中，访问这个位置是合法的，它会返回 \0。

调试注意#

本篇测试均在Release模式下测试，因为Debug模式下由于调试需要会有其他的内存分配

#ifdef LY_EP80

#include <iostream> 
#include <string>

static uint32_t s_AllocaCount = 0;

//重载new运算符
void* operator new(std::size_t size)
{
	s_AllocaCount++;
	printf("Allocating %zu bytes of memory.\n", size);
	return malloc(size);
} 

int main()
{ 
	
	//std::string 在栈上预留了 15 字节 的缓冲区，无需堆分配。
	std::string name = "Yan Chernikov";//13个字符 
	
	//Debug模式下输出Allocating 8 bytes of memory.（调试代理、迭代器调试需要的8字节）
	//Release模式下没有输出
	std::string name1 = "012345678901234567891";//21个字符 

	/*现代 CPU 处理内存时，如果地址是 16 或 32 的倍数，效率最高。以下是输出
	Allocating 32 bytes of memory.
	*/
	 
	std::cin.get();
	return 0;
} 
#endif

1. 问题所在：不必要的内存分配#

传统的 std::string 在进行截取、传递或操作时，往往会触发动态内存分配（Heap Allocation）。

79通过多线程提升性能

Thu, 05 Mar 2026 23:03:01 +0800

如何利用 std::async 让 C++ 运行更快

这一集的核心在于展示如何通过多线程异步处理来优化原本串行执行的耗时操作，主要讲解了 std::async 的用法及其与 std::future 的配合。

1. 问题背景与性能现状#

串行执行的局限性：Cherno 首先展示了一个简单的示例程序（通常是加载资源或执行大量计算）。在单线程环境下，这些任务必须一个接一个地完成，导致总耗时是所有任务时间的总和。
性能瓶颈：如果其中一个任务（如 LoadFunction）非常耗时，整个程序就会被阻塞，无法利用现代 CPU 的多核优势。

如今的游戏加载非常长，原因是需要加载的资源太多，加载过程不仅仅是从磁盘读取文件，涉及解压文件、将其发送到图形处理器、根据特定情况特定转换，但每一项资源、纹理、模型通常相互独立，即它们是多线程的理想选择

2. 引入 `std::async`#

什么是 std::async：它是 C++11 引入的一个高级 API，用于启动异步任务。它比手动创建 std::thread 更简单，因为它能自动处理线程的创建和管理。
std::launch 策略：
- std::launch::async：强制在不同线程中异步运行。
- std::launch::deferred：延迟执行，直到调用 get() 或 wait() 时才在当前线程运行。
基本语法：展示如何将普通函数调用包装进 std::async 中。

#ifdef LY_EP79

#include <iostream> 
#include <thread>
#include <chrono>
#include <future> 

static std::mutex mtx;
static std::vector<int> meshes;

static void LoadMesh(int i)
{
	std::cout << "Loading mesh...[" << i << "]\n";

	//加锁->互斥锁
	//该锁在当前作用域结束时自动释放 
	std::lock_guard<std::mutex> lock(mtx);

	//模拟：将加载的网格ID添加到共享资源中
	meshes.push_back(i);
	std::cout << "Mesh Added: " << i << "\n";


}

void LoadMeshes()
{
	//因为这里的异步任务，即LoadMesh函数返回void，所以我们使用std::future<void>来存储这些异步任务的结果。
	std::vector<std::future<void>> futures;

	for (int i = 10; i < 15; i++)
	{
		// std::async ：立即在后台开启一个新的线程，去执行 LoadMesh(i) 这个函数，不要阻塞我当前的进度。
		
		//1. 但是，因为它返回的 std::future 没有赋值给任何变量，它会在这一行结束时立刻析构。
		//2. std::future 的析构函数逻辑是：“等一下！任务还没跑完，我不能死，我要阻塞主线程直到子线程结束。”
		//3. 所以，最终导致主线程在每次调用 std::async 后都被阻塞，等待子线程完成，才继续下一次循环。
		//std::async(std::launch::async, LoadMesh, i);

		// 将 future 存入 vector，防止它立即析构
		//在单独线程中加载网格
		futures.push_back(std::async(std::launch::async, LoadMesh, i));
	}


}


void LoadMeshesSync()
{
	for (int i = 10; i < 15; i++)
	{
		LoadMesh(i);
	}


}

int main()
{
#define ASYNC 1
#if ASYNC 
	LoadMeshes();
#else
	LoadMeshesSync();
#endif
	std::cin.get();
	return 0;
}
/* Mesh Added:顺序是随机的，因为可能某线程执行std::lock_guard<std::mutex> lock(mtx);这行代码前，被其他线程抢先
Loading mesh...[10Loading mesh...[11]
]
Loading mesh...[12]
Loading mesh...[13]
Loading mesh...[14]
Mesh Added: 11
Mesh Added: 10
Mesh Added: 12
Mesh Added: 13
Mesh Added: 14
*/
#endif

通过parallel Stacks查看不同线程栈信息

78存储任意类型数据

Wed, 04 Mar 2026 23:14:28 +0800

介绍了 C++17 引入的 std::any。它是一个可以存储绝对任何类型变量的容器（本质上是一个类型安全的 void*），但与 void* 不同的是，它会处理对象的构造和析构。

1. 基本用法#

包含头文件：#include <any>
赋值：你可以随意给它赋值，不需要预先定义类型。

2. 如何提取数据：std::any_cast#

由于 any 可以是任何东西，你必须使用 std::any_cast 并指定类型来取回数据：

按值取回：std::any_cast<int>(data)。如果类型不匹配，会抛出 std::bad_any_cast 异常。
按引用取回：为了性能，通常建议取引用或指针，避免拷贝。

例子#

#ifdef LY_EP78

#include <iostream> 
#include <any>
#include <string>
#include <variant>

int main()
{
	std::any data;
	{
		char name[] = "Cherno";
		data = (const char*)name;// 将 name 数组的地址存储在 data 中

	} // name 数组在这里被销毁了

	// 此时 data 内部存储的指针指向了一个已经失效的内存地址（野指针）

	data = 3.45;

	//1. 构造临时对象：std::string 首先根据 "Cherno" 构造自己（这次会有一次内存分配和拷贝）。
	//2. 调用 operator=：这个临时对象被传给 std::any::operator=。
	//3. 内部转换：std::any 内部会检测到这是一个右值（临时对象），它会调用 std::string 的移动构造函数，在自己的内部空间（或它在堆上新开辟的空间）重建这个 string。
	//4. 释放临时对象：原本的临时对象变成“空壳”，随后被销毁。
	data = std::string("Cherno");// 现在 data 内部存储的是一个 std::string 对象，之前的指针已经被覆盖了

	// 这种方式直接在 data 的内部空间构造 string，效率最高
	data = std::make_any<std::string>("Cherno");

	//获取值
	std::string string = std::any_cast<std::string>(data);
	std::cout << string << std::endl;

	data = "haha";

	//运行时报错,data此时是一个const char*，不是std::string
	//std::string string2 = std::any_cast<std::string>(data);
	//std::cout << string2 << std::endl;

	std::variant<int, std::string> var;
	var = 3;
	var = "Hello";

	std::string string3 = std::get<std::string>(var);
	std::cout << string3 << std::endl;//运行正常，输出"Hello"

	std::cin.get();
	return 0;
}
#endif

3. 工作原理与性能开销#

这是本集的重点，Cherno 解释了为什么不能滥用 std::any：

77在单变量中存储多种类型数据

Wed, 04 Mar 2026 19:48:33 +0800

核心概念#

本集介绍了 C++17 引入的 std::variant。它是一个类型安全的联合体 (Type-safe Union)，允许一个变量在不同时间存储预定义的一组类型中的任意一种 ~~比如我接收一个参数可能是字符串或者整数–因为也许我接受的参数来自命令行参数~~ 。

1. 为什么需要 std::variant？#

在 C++17 之前，如果你想让一个变量既能存 string 也能存 int：

使用 union：传统的 union 不够安全，它不会追踪当前存储的是哪种类型，且处理复杂类型（如 std::string）时非常麻烦。
使用 std::variant：它解决了这些问题。它知道自己当前存的是什么，并且会自动处理复杂类型的构造和析构。

2. 基本用法#

包含头文件：#include <variant>
声明与赋值：

	//列出可能的数据类型
 std::variant<std::string, int> data; 
 data = "Cherno"; // 存储 string
 data = 24; // 存储 int

注意：variant 的大小等于其最大候选类型的大小加上一些存储索引的开销（类似于 struct），这与 union 共享内存的特性类似。

3. 如何读取数据#

由于 variant 是类型安全的，你不能直接访问，有几种主要方式：

std::get<T>(var)：指定类型获取。如果类型不匹配，会抛出 std::bad_variant_access 异常。
std::get_if<T>(&var)：（推荐方式）传入地址。如果类型匹配则返回指针，否则返回 nullptr。这种方式不会抛出异常，适合配合 if 使用。
std::variant::index()：返回当前存储类型的索引（从 0 开始）。

例子#

#ifdef LY_EP77

#include <iostream>
#include <variant>

int main()
{
	std::variant<std::string, int> data;
	data = "Cherno";
	std::cout << std::get<std::string>(data) << std::endl;
	data = 2;
	//data = 3.45;//编译报错，不通过
	std::cout << std::get<int>(data) << std::endl;
	//std::cout << std::get<std::string>(data) << std::endl;//运行时抛出异常
	data = true;//隐式转换，true转为1
	std::cout << std::get<int>(data) << std::endl;//1

	//运行时抛出异常
	//Unhandled exception at 0x763A2CA4 in HelloWorld62.exe: Microsoft C++ exception: std::bad_variant_access at memory location 0x012FFA2C.
	//std::cout << std::get<std::string>(data) << std::endl;

	//如上定义该变量时,std::string对应的索引映射为0，int对应的索引映射为1
	std::cout << data.index() << std::endl;

	//get_if函数接受一个地址，返回一个指针
	//如果当前 variant 存的数据类型匹配，它返回指向该数据的指针。
	//如果类型不匹配，它返回 nullptr（空指针），而不会让程序崩溃。
	if (auto value = std::get_if<std::string>(&data))
	{
		std::string& v = *value;
		std::cout << "it's a string:" << v << std::endl;
	}
	else if (auto value = std::get_if<int>(&data))
	{
		int& v = *value;
		std::cout << "it's an int:" << v << std::endl;

	}

	//union 的特点是所有成员共享同一块内存。如果你给 age 赋值，就会覆盖掉 name 的内存。如果此时 name 原本存有字符串，它的析构函数将无法正确释放内存，导致内存泄漏或崩溃。
	//注意：在现代 C++ 中，如果你要在 union 里放 std::string，你必须手动定义 union 的构造和析构函数。
	union TestS
	{
		std::string name;//28字节
		int age;//4字节
	};
	std::cout << "union======size===" << std::endl;
	std::cout << sizeof(std::string) << std::endl;//28字节
	std::cout << sizeof(int) << std::endl;//4字节
	std::cout << sizeof(TestS) << std::endl;//28字节
	std::cout << "variant======size===" << std::endl;

	//32=28+4，所以基本上创建了struct，或者说用于存储两种数据类型的空间；所以union更高效，而variant安全性更高
	std::cout << sizeof(data) << std::endl;//32


	std::cin.get();
	return 0;
}
#endif
#endif

`data = false;`分析#

当执行 data = false; 时，发生了隐式类型转换（Implicit Conversion）。

76可选数据处理

Wed, 04 Mar 2026 13:25:37 +0800

核心概念#

本集主要讨论 C++17 引入的 std::optional。它提供了一种优雅的方式来处理==“值可能存在，也可能不存在”==的情况，避免了使用魔术数字（如 -1）、空字符串或布尔标志位等不直观的方法。

1. 传统处理方式的弊端#

在没有 std::optional 之前，如果一个函数可能无法返回有效数据，程序员通常会：

返回特殊值：例如找不到文件时返回空字符串 ""。但问题是，有时空字符串本身可能也是合法的返回结果，导致二义性。
使用布尔标记：通过引用的方式传出数据，函数返回 bool 表示是否成功。这种方式虽然可行，但代码写起来比较琐碎。
- 函数返回一个布尔值（true 或 false）来表示操作是否成功，而实际的数据通过“输出参数”（通常是引用或指针）来传递。

2. std::optional 的基本用法#

std::optional 像是一个容器，它要么包含一个指定类型的值，要么为空（std::nullopt）。

包含头文件：#include <optional>
读取文件示例：

 std::optional<std::string> ReadFileAsString(const std::string& filepath) {
 std::ifstream stream(filepath);
 if (stream) {
 std::string result;
 // 读取文件内容...
 return result;
 }
 //return {};// ai提示return std::nullopt; // 显式表示没有值 [00:05:00]
 }

完整代码#

//同文件夹下：data.txt
Data!Hello!

#ifdef LY_EP76

#include <iostream> 
#include <fstream>
//C++17引入了std::optional类型，可以用来表示一个值可能存在也可能不存在的情况。它提供了一种更安全和更清晰的方式来处理函数返回值，避免了使用引用参数来传递成功与否的信息。
#include <optional>
#include <sstream> //读取文件内容需要使用std::stringstream


//方法1：通过引用参数返回成功与否
//std::string ReadFileAsString(const std::string& filePath,
//bool& outSuccess)
std::optional<std::string> ReadFileAsString(const std::string& filePath)
{
	std::ifstream stream(filePath);
	if (stream)
	{
		std::stringstream result;
		result << stream.rdbuf();
		//read file
		stream.close();
		return result.str();
	} 
	return {};
}

int main()
{

	//在内存中，std::optional<T> 通常包含两个主要部分：
	//1. 一块足够大的内存空间：用来存放类型为 T 的值（在你的例子中是 std::string）。
	//2. 一个布尔标记（bool flag）：记录这个盒子现在是“满的”还是“空的”
	std::optional<std::string> data = ReadFileAsString("data.txt");
	std::optional<std::string> data1 = ReadFileAsString("data1.txt");

	//如果是读取参数，那就是指定默认值
	//std::string value = data.value_or("default value");

	//或者if(data)
	if(data.has_value())
	{
		//数据读取
		std::string& string = *data;
		std::cout << "File content: " << data.value() << std::endl;
		std::cout << "File content: " << string << std::endl;
	}
	else
	{
		std::cout << "Failed to read file." << std::endl;
	}


	if (data1.has_value())
	{
		//数据读取
		std::string& string = *data1;
		std::cout << "File content: " << data1.value() << std::endl;
		std::cout << "File content: " << string << std::endl;
	}
	else
	{
		std::cout << "Failed to read file(data1.txt)." << std::endl;
	}
	std::cin.get();

} 
/*
File content: Data!Hello!
File content: Data!Hello!
Failed to read file(data1.txt).
*/
#endif

3. 如何检查与获取值#

调用返回 std::optional 的函数后，有几种处理方式：

74性能基准测试指南

Tue, 03 Mar 2026 13:47:24 +0800

利用 C++ 对象的生命周期（析构函数）来自动化测量任务。
处理一个对性能要求很高的部分时，或者测试刚学到的新技术，此时想比较性能
本章节讲解如何实际测量C++代码的性能

测试循环所需时间#

#ifdef LY_EP74

#include <iostream> 
#include <chrono>

class Timer
{
public:
	Timer()
	{
		std::chrono::high_resolution_clock::now();
	}

	~Timer()
	{
		auto endTimepoint = std::chrono::high_resolution_clock::now();
		//算出起始时间的微秒数 
		auto start = std::chrono::time_point_cast<std::chrono::microseconds>(m_StartTimepoint).time_since_epoch().count();
		//算出结束时间的微秒数
		auto end = std::chrono::time_point_cast<std::chrono::microseconds>(endTimepoint).time_since_epoch().count();
		//算出持续时间
		auto duration = end - start;
		//将持续时间转换为毫秒并输出
		double ms = duration * 0.001;
		std::cout << duration << "us (" << ms << "ms)" << std::endl;
	}

private:
	std::chrono::time_point<std::chrono::high_resolution_clock> m_StartTimepoint;
};

int main()
{
	int value = 0;
	{
		Timer timer; // 创建一个 Timer 对象，开始计时

		for (int i = 0; i < 1000000; i++)
			value += 2;
	}

	std::cout << value << std::endl;

	//__debugbreak() 是 MSVC (Windows) 特有的编译器内置函数，会在这里中断程序，进入调试器，方便我们查看变量的值
	//正式运行程序时也会中断甚至发生异常
	__debugbreak();

}
#endif

先设置断点，然后进入反汇编查看

73动态类型转换(dynamic_cast)

Tue, 03 Mar 2026 11:09:49 +0800

引入：什么是 Casting？#

背景：在 C++ 中，我们经常需要在父类和子类指针之间转换。
痛点：传统的 C 风格转换 (Player*)entity 或 static_cast 是“强行”转换。编译器完全信任你，即使你把一个“敌人”对象强行转成“玩家”对象，它也不会报错，但这会导致程序在运行时崩溃。

Dynamic Cast 的特殊性#

一针见血的定义：dynamic_cast 是专门用于继承体系中的安全转换。
运行时检查 (RTTI ~~运行时类型信息~~ )：它不像其他转换在编译时完成，而是在程序运行时去检查这个对象“到底是不是”你要转的那个类型。
返回值逻辑
- 如果转换成功：返回有效的指针。
- 如果转换失败（类型不匹配）：返回 NULL (或 nullptr)。

核心前置条件：虚函数表#

关键约束：要使用 dynamic_cast，你的类必须是多态的 (Polymorphic)。
原理：这意味着基类必须至少有一个虚函数 (Virtual Function)。
底层逻辑：dynamic_cast 依赖于 RTTI (Run-Time Type Information)，而 RTTI 信息存储在虚函数表 (vtable) 中。如果类没有虚函数，就没有 RTTI，编译器会直接报错。

代码实战演练#

Cherno 演示了一个经典的场景：

基类：Entity
子类：Player 和 Enemy
场景：你有一个 Entity* 指针，你想知道它指向的到底是Player 还是 Enemy。
写法：

#ifdef LY_EP73

#include <iostream> 

class Entity
{
public:
	virtual void PrintName() {}
};

class Player : public Entity
{
};

class Enemy : public Entity
{
};


int main()
{ 
	Player* player = new Player();
	Entity* e = player;//隐式转换，Player* 转换为 Entity*

	Entity* actuallyEnemy = new Enemy();
	Entity* actuallyPlayer = new Player();

	//Player* p = e;//错误，Entity* 转换为 Player*，需要显示转换

	Player* p = (Player*)actuallyEnemy;//不安全的转换，Enemy* 转换为 Player*，编译器允许，但运行时会出问题；如果访问Player和Entity共有的成员，可能不会出问题，但如果访问Player特有的成员，就会出问题，因为actuallyEnemy实际上是一个Enemy对象，而不是Player对象。

	Player* p1 = static_cast<Player*>(actuallyEnemy);//和上面的显示转换一样，属于不安全的转换 

	//actuallyEnemy指向的类必须是多态的，在 C++ 的设计哲学里，非多态类确实没有存储运行时的类型信息。
	Player* p2 = dynamic_cast<Player*>(actuallyEnemy);//安全的转换，运行时会检查actuallyEnemy是否实际上是一个Player对象，如果是，则返回指向Player对象的指针；如果不是，则返回nullptr。由于actuallyEnemy实际上是一个Enemy对象，所以p2将被赋值为nullptr。


	Player* p3 = dynamic_cast<Player*>(actuallyPlayer);

	if (p2)
	{
		std::cout << "actuallyEnemy is a Player." << std::endl;
	}
	else
	{
		std::cout << "actuallyEnemy is NOT a Player." << std::endl;
	}

	if(p3)
	{
		std::cout << "actuallyPlayer is a Player." << std::endl;
	}
	else
	{
		std::cout << "actuallyPlayer is NOT a Player." << std::endl;
	}

	std::cin.get();
}

/*
actuallyEnemy is NOT a Player.
actuallyPlayer is a Player.
*/
#endif

性能代价 (The Cost)#

Cherno 给出了一针见血的职业警告：

72预编译头文件详解

Sun, 01 Mar 2026 12:16:57 +0800

预编译头文件的作用是将大量稳定的头文件提前编译成二进制缓存。这样编译器在处理每个源文件时，直接读取该缓存，而无需重新解析成千上万行重复的代码，从而极大地缩短编译时间。

比如常用的标准模版库：比如向量、字符串、标准输出之类，假设我们每次（在每个.cpp文件）都要包含vector，需要读取vector.h头文件并编译，而且vector本身也包含其他一系列头文件，所有其他头文件被复制到vector.h中，再把vector.h复制到.cpp中（大约十万行代码），还要进行解析和标记化，并以某种形式进行编译

如果项目中有多个cpp文件，很多地方都包括vector.h，他们会被逐个包含在每个文件中 ~~每个翻译单元（.cpp）都会被单独编译，然后链接器将它们链接起来~~
且每次对那个cpp文件 ~~包含了vector.h的~~ 重新更改时，整个 ~~这里是说要把vector.h复制进来然后再编译~~ 都得重新编译

建议

改用预编译头文件，它会获取一堆头文件（要包含的那些），然后它编译一次，并将起转换为二进制格式。这对编译器来说处理起来比纯文件快得多 ~~因为它以处于解析状态，而且是二进制文件，随时可以，不用再重新编译~~
- 举个例子，可能本来要1分钟，使用预编译头文件后，编译可能只需8秒钟
预编译头文件其实就是一个头文件，且包含一系列其他头文件
- 不可以把所有头文件都放进去，因为如果一个头文件经常变化，那么每次改动都需要重新编译整个预编译头文件
- 不需要在项目的每个cpp都包含日志文件，只需要包含含有日志的预编译头文件
C库、标准模板库、WindowsAPI调用库，建议把这些都放进预编译头文件 ~~每次编译可能他的代码量比实际代码还多~~ 。这样就能从每个C文件中获取所有内容，如果要用只能指针，就不用实际直接包含memory头文件，因为他在预编译头文件中，它会包含在实际编写的每个C++文件中
因为把所有文件都放进了pch.h ~~也可以叫其他名字~~ ，所以不能一眼看出实际include了什么，且pch.h中包含了所有的，所以也不清楚实际它只依赖哪些头文件
如果编写游戏引擎，可能只有一个cpp文件需要包含GLFW ~~编译一起就搞定~~ ，那么可以把GLFW放入pch.h中，因为其他内容都被抽象放在自己的api中；而其他的标准库、vector、标准输入输出之类的，很多都会用的，也可以让它编译一次就搞定

例子#

//Main.cpp
#include "pch.h"

int main()
{
	std::cout << "Hello World!" << std::endl;
}

//pch.h
#pragma once

#include <iostream>
#include <algorithm>
#include <functional>
#include <memory>
#include <thread>
#include <utility>

// Data structures
#include <string>
#include <stack>
#include <deque>
#include <array>
#include <vector>
#include <set>
#include <map>
#include <unordered_set>
#include <unordered_map>

//Windows API
#include <windows.h>

做个测试

然后ctrl+f7编译Main.cpp，查看生成的Main.i文件

71现代CPP的安全性和教学理念

Sun, 01 Mar 2026 11:37:08 +0800

重点围绕原始指针（Raw Pointers）与智能指针（Smart Pointers）的长期争论，以及为什么坚持从底层原理开始教学

视频看过一遍了，全程没有讲到代码例子，所以这里用了ai总结这个视频

The Cherno 在本集中讨论了“安全编程”在 C++ 中的定义，重点围绕原始指针（Raw Pointers）与智能指针（Smart Pointers）的长期争论，以及他为什么坚持从底层原理开始教学。

时间线总结

话题引入#

讨论 C++ 社区中关于“现代 C++”与“安全性”的激烈争论。
两种极端观点：
- 现代派：只应使用现代 C++，永远不碰原始指针。
- 传统派：智能指针有性能开销，真男人就该手动管理内存。

什么是 C++ 中的“安全性”？#

安全编程的核心目标是：减少崩溃、内存泄漏和非法访问（Access Violations）。
从 C++11 开始，社区转向智能指针，主要是为了解决堆内存分配中的人为错误。

内存管理的两大痛点#

忘记释放内存：导致内存泄漏，可能导致程序最终因内存不足而崩溃。
所有权问题（Ownership）：当一个指针在多个函数或类之间传递时，不清楚由谁负责销毁它。

智能指针的本质#

智能指针本质上只是对一两行代码的自动化：自动调用 delete 或释放内存。
它们通过自动化来减少人为疏忽，提高代码的健壮性。

他的立场：你应该使用智能指针#

在实际的生产代码或大型框架中，100% 应该使用智能指针。
不使用它们会极大地增加代码维护的难度和出错的风险。

为什么他还在视频里用原始指针？#

简洁性：在简单的 Sandbox（沙盒）测试或只有 100 行左右的小样板代码中，原始指针写起来更快、读起来更直观。
环境区别：学习阶段的小程序不需要像生产环境那样严谨地考虑所有权转移。

教学责任与影响#

反思作为拥有大量订阅者的博主，使用原始指针是否会给初学者带来不良示范（类似于红灯穿马路）。
但他认为，如果不教原始指针，学生就无法真正理解 C++ 的工作原理。

核心教学哲学：理解底层（非常重要）#

智能指针只是原始指针的封装（Wrapper）。
如果你不理解原始指针和内存是如何运作的，你就无法成为一名优秀的 C++ 程序员，尤其是处理高性能或实时系统的开发。
==学习“旧东西”==是为了更好地掌握“新工具”。

核心结论#

在项目开发中：推荐使用智能指针，为了安全和效率。
在学习过程中：必须掌握原始指针，为了理解底层和内存真相。

Cherno 的观点：避开底层原理而只学“安全”的做法，无法培养出真正顶尖的开发者。

70条件断点与操作断点设置

Wed, 25 Feb 2026 18:43:34 +0800

本节介绍visual studio 快速小技巧，也是一个适用于开发和调试的通用技巧，围绕断点展开
围绕条件展开，以及一些可应用于断点的操作
- 条件断点 ~~断点在特定条件下触发~~
- 动作断点 ~~断点触发时进行一些操作在控制台打印内容并继续/或暂停执行程序~~

断点在代码里也可以实现

写if语句并（手动）设置断点 ~~也可以直接debug break;之类的编译器内部函数~~

调试中发现问题的情况下，如果使用ide的调试断点功能，就能省去重编译、编写代码再调试运行

添加Action和Condition#

#ifdef LY_EP70
#include <iostream>

int main()
{ 
	int a = 2, b = 3;
	for (int i = 0; i < 5; i++) {
		std::cout << "i:" << i << std::endl;
	}
	std::cout << a << std::endl;
	std::cout << b << std::endl;
	std::cin.get();
	return 0;
}
#endif

先添加断点，然后再点击Action，最后添加打印内容i is {i} ,values of a,b is : {(float)a}, {(float)b}
然后设置Condition，设置为i == 3，即只有在i == 3时才触发断点

这个contine code execution如果勾上了，则调试时不会停止，会直接跳过该断点

69类型转换

Tue, 24 Feb 2026 16:59:48 +0800

类型转换（Type Casting）是在 C++ 强类型系统中进行类型间转换的过程。
cpp作为一种强类型语言，意味着有一个类型系统，且类型是强制规定的
- 如果一个东西是整型，不能突然把它拿来当双精度数，除非有简单的==隐式转换 ~~意味着cpp知道如何在这两种类型之间转换且不丢失数据~~ ==
- 可以使用显示转换
类型转换包括C风格转换和C++风格转换

基本的显示/隐式转换#

#ifdef LY_EP69
#include <iostream>

int main()
{
	int a = 5;
	double value = a;//隐式转换

	double value1 = 5.25;
	int a1 = value1;//隐式转换

	int a2 = (int)value1;//显示转换

	std::cout << "a:" << a << std::endl;//5
	std::cout << "value:" << value << std::endl;//5
	std::cout << "value1:" << value1 << std::endl;//5.25
	std::cout << "a1:" << a1 << std::endl;//5
	std::cout << "a2:" << a2 << std::endl;//5


	std::cin.get();
	//成功的情况只有一种（0），而失败的原因
	//可以有成千上万种（1, 2, 3...）。
	return 0;
}
#endif

类型转换例子#

#ifdef LY_EP69
#include <iostream>

class Base
{
public:
	Base() {}

	//这里应该把析构函数设为vitual，我只是为了演示
	//只要有虚函数就能用动态转换转换成功，而这个虚函数
	//不一定非得是析构函数
	~Base() {} 

	virtual void test() {}
};

//public Base中 <public> 决定：基类（Base）中的成员在
//派生类（Derived）中保持什么样的访问权限。（public则成员
//的最高权限是public）
class Derived : public Base
{
public:
	Derived() {}
	~Derived() {}
};

class AnotherClass : public Base
{
public:
	AnotherClass() {}
	~AnotherClass() {}
};

int main()
{
	//C风格转换
	double value = 5.25;
	double a1 = value + 5.3;//10.55
	double a2 = (int)value + 5.3;//强制截断，10.3 
	double a3 = (int)(value + 5.3);//强制截断，10 
	std::cout << a1 << std::endl;
	std::cout << a2 << std::endl;
	std::cout << a3 << std::endl;

	// C++风格转换（以下C风格转换都能做到，但是C++风格还会做点
	// 额外的事情）
	double s = static_cast<int>(value) + 5.3;//1 静态转换，会有编译时检查

	//double s1 = static_cast<AnotherClass>(value) + 5.3;//编译失败,没有哪个构造函数支持，即没有 AnotherClass(int)这样的构造函数先隐式转换成AnotherClass

	//AnotherClass s11 = static_cast<AnotherClass*>(value) ;//编译失败，无效的类型转换
	//AnotherClass s12 = static_cast<AnotherClass*>(&value) ;;//编译失败，无效的类型转换


	//2 重新解释转换 //类似类型双关
	AnotherClass* a = reinterpret_cast<AnotherClass*>(&value);//“重新解释转换”，编译通过，即指向该值的指针，解释成：指向另一个类实例的指针


	//3 动态类型转换 //多态时用到
	Derived* derived = new Derived();
	Base* base = derived;
	//检查基类指针是否是(某个)派生类实例 
	//静态转换，但很明显这会出问题(base是指向Derived实例而非AnotherClass)
	AnotherClass* ac1 = static_cast<AnotherClass*>(base);
	AnotherClass* ac1_1 = (AnotherClass*)(base);

	Derived* ac3 = dynamic_cast<Derived*>(base);//编译通过

	AnotherClass* ac2 = dynamic_cast<AnotherClass*>(base);//编译通过，但是返回null
	if (ac3)
	{
		std::cout << "ac3转换成功" << std::endl;//ac3转换成功
	}
	if (ac2)
	{
		std::cout << "ac2转换成功" << std::endl;//没成功
	}

	//4 常量解释转换：移除或添加常量
	//视频没说到

	std::cin.get();
	//成功的情况只有一种（0），而失败的原因
	//可以有成千上万种（1, 2, 3...）。
	return 0;
}
#endif

dynamic_cast 是在==运行时（Runtime）==通过查询虚函数表（vtable）来确认对象的实际类型的。
- 规则：只有当类中至少包含一个==虚函数（virtual function）==时，编译器才会为该类生成类型信息（RTTI）。
- 所以如果被转换的实例类中完全没有虚函数，那么使用dynamic_cast时在编译阶段就报错了
RTTI (运行时类型识别)：当类包含虚函数时，编译器会在对象内存布局中增加一个指向“虚函数表”的指针。表中包含了该类的 type_info。
安全性检查：执行 dynamic_cast 时，程序会检查内存中对象的实际 type_info。如果 Base* base 实际上指向的是 Derived，转换成功；如果指向的是其他不相关的类，则返回 NULL。

常量转换#

#ifdef LY_EP69
#include <iostream>

void IncreaseValue(const int* val_ptr) {
	// 编译失败：不能修改 const 指针指向的内容
	//*val_ptr = 10; 

	// 使用 const_cast 去掉 const 属性
	int* modifiable_ptr = const_cast<int*>(val_ptr);
	*modifiable_ptr += 5;
}

int main() {

	//number 是一个普通的非 const 变量 
	int number = 10;

	std::cout << "修改前: " << number << std::endl;

	// 传入 number 的地址
	IncreaseValue(&number);

	std::cout << "修改后: " << number << std::endl; // 输出 15


	//=====演示有问题情况=====
	const int constant_var = 100; // 原始变量就是常量
	const int* ptr = &constant_var;

	int* naughty_ptr = const_cast<int*>(ptr);
	*naughty_ptr = 200; // 危险！这是“未定义行为”
	std::cout << "constant_var修改后: " << constant_var << std::endl;

	// 此时打印 constant_var，结果可能还是 100，也可能是 200，取决于编译器优化

	std::cin.get();
	return 0;
}
#endif

为什么number修改成功，而constant_var修改失败

68虚析构函数

Mon, 23 Feb 2026 08:51:18 +0800

虚析构函数对处理多态性而言非常重要
如果类B从类A派生而来，A a=new B()，现在如果决定detele a ，此时希望运行的不仅是A的析构函数，还有B的析构函数。这本质上就是虚析构函数的作用

虚函数的核心作用与机制#

在 C++ 中，虚函数（Virtual Function）是实现多态性（Polymorphism）的核心机制。它允许程序在运行期间（Runtime）根据对象的实际类型来调用相应的函数，而不是在编译期间（Compile time）就固定死。

1. 实现动态绑定 (Dynamic Binding)#

这是虚函数最直接的作用。在基类指针或引用指向派生类对象时，调用虚函数会执行“子类版本”而非“基类版本”。

非虚函数：编译器根据指针的类型决定调用哪个函数（静态绑定）。
虚函数：编译器根据指针指向的实际对象决定调用哪个函数（动态绑定）。

2. 支持接口复用与扩展 (Extensibility)#

通过虚函数，你可以编写通用的代码来处理不同类型的对象，而无需知道它们的具体类别。

特性	说明
一致性	基类定义接口规范，所有子类必须遵循。
可扩展性	增加新的子类时，不需要修改原有的基类或调用方的逻辑。
重写 (Override)	子类可以根据自身需求，重新定义基类的行为。

3. 虚析构函数的重要性 (Virtual Destructor)#

在多态场景下，基类的析构函数必须声明为 virtual。

原因：如果基类析构函数不是虚函数，当删除一个指向派生类对象的基类指针时，只会调用基类的析构函数，导致派生类特有的成员变量无法被正确释放，从而产生内存泄漏 (Memory Leak)。

4. 底层实现：虚函数表 (Vtable)#

虚函数是通过虚函数表 (Virtual Table, vtbl) 和虚函数表指针 (vptr) 实现的：

vptr：每个含有虚函数的对象内部都有一个隐藏指针。
vtbl：存储了该类所有虚函数的地址。
调用过程：程序运行阶段，通过对象的 vptr 找到 vtbl，再从中找到对应的函数地址。这虽然比普通函数调用稍微多了一点点开销，但换取了极大的灵活性。

简短代码示例#

class Animal {
public:
 virtual void speak() { cout << "Animal speaks"; } // 虚函数
 virtual ~Animal() {} // 虚析构函数
};

class Dog : public Animal {
public:
 void speak() override { cout << "Woof!"; } // 重写
};

void makeItSpeak(Animal* a) {
 a->speak(); // 运行阶段根据 a 指向的具体对象决定调用哪个 speak()
}

类继承时构造与析构的顺序#

#ifdef LY_EP68
#include <iostream>

class Base
{
public:
	Base() { std::cout << "Base constructor\n"; }
	~Base() { std::cout << "Base destructor\n"; }
};

class Derived : public Base
{
public:
	Derived() { std::cout << "Derived constructor\n"; }
	~Derived() { std::cout << "Derived destructor\n"; }
};

int main()
{
	Base* base = new Base();
	delete base;
	std::cout << "------------------\n";
	Derived* derived = new Derived();
	delete derived;
	std::cout << "------------------\n";
	Base* poly = new Derived();
	delete poly;

	std::cin.get();
}
#endif
/*输出
Base constructor
Base destructor
------------------
Base constructor
Base destructor
------------------
Base constructor
Derived constructor
Derived destructor
Base destructor
------------------
Base constructor
Derived constructor
====================> 输出没有这行：Derived destructor，没有调用子类析构函数，即内存泄露，没有释放m_array
Base destructor
*/

第一部分：new Base() 这是最基础的情况：

66类型双关

Tue, 17 Feb 2026 08:59:40 +0800

类型双关指的是，C绕过类型系统的一种方式，C是强类型语言，不会把所有东西都设置为auto（可以，但不推荐）
C++中类型在一定程度上由编译器强制限定，但你可以直接访问内存
本章节实例会访问某个int数值的内存，并把它当做双精度数来处理（轻易绕过类型系统）
- 假设有一个类（基本类型结构体），我们想把它写成字节流，它没有其他指针指向它，那么我们可以直接解释整个结构体、类、或者其他东西，这里会视为字节数组：只要我们知道任何大小，就可以直接访问数据

转换#

#ifdef LY_EP66
#include <iostream>

int main()
{ 
	//小端法，低字节的数据存储在内存的低地址处，
	// 高字节的数据存储在内存的高地址处
	//Ox00000032
	int a = 50;// 32 00 00 00 
	 
	//隐式转换，a隐式转换成了double类型
	//相当于 double value =(double)a
	//Ox404900000000000000，double数值50
	//的16进制表示为0x4049000000000000
	double value = a;// 00 00 00 00 00 00 49 40 
	std::cout << value << std::endl;

	std::cin.get();
}
#endif

转换后内存中的数值变了

类型双关-不同方式读取同一内存#

#ifdef LY_EP66
#include <iostream>

int main()
{
	int a = 50;
	//把a(内存处）的内存以double类型的方式进行访问
	//将整型进行类型双关变成双精度型
	//* 操作符会尝试从该地址开始，一口气往后读 8 个字节，这里是
	//32 00 00 00 cc cc cc cc （小端法）
	double value = *(double*)&a;
	std::cout << a << std::endl;
	std::cout << value << std::endl;

	//不想创建全新变量，只是想把这个整数当成双精度数来访问，
	//那么可以在这个双精度数后面加&，这样就能引用他
	//强行让 value1 成为 &a 处那块 8 字节内存的别名。通过
	// value1 修改数据会直接破坏 a 及其相邻内存。
	double& value1 = *(double*)&a;
	//这里会把8个字节(a和a后面的4个字节)都写入0
	value1 = 0;
	std::cin.get();
}
#endif

65排序

Mon, 16 Feb 2026 23:31:44 +0800

数据结构决定了数据的存储方式
本节主要讲解如何对现有数据进行排序
当使用C及其内置集合类型,如std::vector时,优先用C内置的函数排序:能根据你提供的任何迭代器进行实际排序

cppreference中的解释#

//std::sort
//Defined in header <algorithm>
template< class RandomIt >
void sort( RandomIt first, RandomIt last ); (1)(constexpr since C++20)

template< class ExecutionPolicy, class RandomIt >
void sort( ExecutionPolicy&& policy,
 RandomIt first, RandomIt last ); (2)(since C++17)
 
template< class RandomIt, class Compare >
void sort( RandomIt first, RandomIt last, Compare comp ); (3)(constexpr since C++20)

template< class ExecutionPolicy, class RandomIt, class Compare >
void sort( ExecutionPolicy&& policy, RandomIt first, RandomIt last, Compare comp ); (4)(since C++17)

可以传入迭代器、谓词（非必须）

迭代器：存储了原数据的地址。可以利用迭代器迭代原数据，存储了地址所以可以方便的交换数据

没有返回值，时间复杂度为O(N·log(N))

Given N as last - first:

1,2) O(N·log(N)) comparisons using operator<(until C++20)std::less{}(since C++20).
3,4) O(N·log(N)) applications of the comparator comp.

例子#

algorithm：英[ˈælɡərɪðəm]

64多维数组

Sat, 14 Feb 2026 11:22:55 +0800

多维数组,其实就是由数组作为元素,构成的数组

二维数组与三维数组#

#include <iostream>

int main()
{
	//存储50个整数, 指针存储这50个整数的第一个数的地址
	//50*4=200字节
	int* array = new int[50];

	//A2D, 2D数组,50个[整数指针]
	//分配50个[整数指针]; 32位系统，一个指针4字节
	//50*4=200字节
	int** a2d = new int*[50];

	//都是分配了200个字节,4个字节一组,总共50组

	//类型,其实就是在设置处理这些属性的语法,比如 int* array,
	//int** a2d等等
	array[0] = 0;//处理的是整数
	a2d[0] = nullptr;//处理的是指针

	//有空间存储50个指针,这些指针共占200字节,之后我们可以遍历
	//它们,并将每个指针都设置为指向一个数组. 其实最终得到的就是50个数组
	//二维数组: 有一个数组,包含着(50个)[数组的内存地址] 
	for (int i = 0; i < 50; i++)
	//为50个数组元素(指针)处理操作
	{
		//让每一个数组元素(指针)的值,等于new(50个元素)出来的数组的首地址
		a2d[i] = new int[50];
	}


	//分配50个(二维数组)
	int*** a3d = new int**[50];
	//遍历每一个二维数组
	for (int i = 0; i < 50; i++)
	{
		//初始化二维数组
		a3d[i] = new int* [50];
		//遍历a3d[i]这个数组的50个元素
		for (int j = 0; j < 50; j++)
		{
			int** ptr = a3d[i];
			//让每个元素指向new出的50个元素的数组
			ptr[j] = new int[50];
		}
	}
	//a3d[0]:得到一个二级指针数组
	//a3d[0][0]:得到一个指针数组
	//a3d[0][0][0]:得到整数
	a3d[0][0][0] = 0;

	std::cin.get();
}

详解二维数组#

#ifdef LY_EP64
#include <iostream>

int main()
{
	//创建一个数组,每个数组元素是指针
	int** a2d = new int* [50];

	//对50个元素赋值
	for (int i = 0; i < 50; i++)
	{
		//对第i个指针元素赋值,每个指针元素
		//指向新创建的数组
		a2d[i] = new int[50];

	}
	//第1个数组的第一个元素赋值为0
	//左边的0是指针的索引
	//右边的0,1,2是整数的索引
	a2d[0][0] = 0;
	a2d[0][1] = 0;
	a2d[0][2] = 0;

	//没有这种语法,编译报错
	//delete[][] a2d;


	for (int i = 0; i < 50; i++)
	{
		//删除所有内部的数组
		delete[] a2d[i];
	}
	//这个删除的是,保存指针元素的那个数组(最外层)
	delete[] a2d;

	std::cin.get();
}
#endif

内存碎片化#

#ifdef LY_EP64
#include <iostream>

int main()
{ 
	//包含5个指针元素的数组
	int** a2d = new int* [5];
	 
	for (int i = 0; i < 5; i++)
	{ 
		//每个元素都包含五个数组
		a2d[i] = new int[5];
	} 

	//设置元素的值
	for (int y = 0; y < 5; y++)
	{
		for (int x = 0; x < 5; x++)
		{
			a2d[y][x] = 2;
		}
	}

	//这25个元素并不是一个连续的能
	//容纳25个整数的缓冲区,而是5个独立
	//的缓冲区,每个缓冲区能容纳5个整数
	//这5个缓冲区,被分配到内存中的随机位置

	for (int i = 0; i < 5; i++)
	{
		//删除所有内部的数组
		delete[] a2d[i];
	}

	//这个删除的是,保存指针元素的那个数组(最外层)
	delete[] a2d;

	std::cin.get();
}

#endif;

如果我们必须遍历,每次遍历5个整数后(访问25个整数中的每一组),然后转到数组的下一行(下一个整数数组),到内存中的另一个位置读取/写入数据,这可能会导致缓存未命中,这意味着从内存中获取数据时会浪费时间(如果他们分配得很近可能不会缓存未命中)
- 如上所示,这样遍历这25个整数,比在内存中连续分配一个25个整数的一维数组慢很多,因为那段内存是连续的
- 当你编程优化时,当你处理内存时,优化时最重要的一件事就是优化内存访问
- 如果能够在内存中紧凑存储要访问的内存,并且通过某种方式摆放,以获得更多的缓存命中,使程序运行更快
缓存学习包括:CPU缓存如何工作

代替二维数组#

#ifdef LY_EP64
#include <iostream>

int main()
{
	//这是一个栈上的原生二维数组,且内存中连续(对比int** a2d = new int* [5];方式)
	//物理形态：[ 1, 2, 3, 4, 5, 6, 7, ... 25 ] 
	//特点：编译器通过公式 Address + (row x 5 + col) x 4 直接定位。没有额外的寻址操作。(字节定位)
	int a[5][5] = { 1,2,3,4,5,6,7,8,9,10, 11,12,13,14,15,16,17,18,19,20, 21, 22, 23, 24, 25 };
	for (int i = 0; i < 5; i++)
		for (int j = 0; j < 5; j++)
			std::cout << a[i][j] << std::endl;


	//使用一维数组(连续的一块内存)完成二维数组5 * 5 的数组功能
	int* array = new int[5 * 5];
	for (int y = 0; y < 5; y++)
	{
		for (int x = 0; x < 5; x++)
		{
			array[x + y * 5] = 2;
		}
	}

	std::cin.get();
}

#endif;

建议#

避免使用二维数组,如果存储一个位图,有一幅图像的所有元素,会把图像(正方形或长方形)看成二维的,但不代表要把它存为二维数组,建议存为一维数组

为什么推荐“平铺的一维数组”而不是`int a[5][5]`？#

动态需求：实际开发中（如加载一张图片），你往往在运行时才知道宽度和高度。这时你无法使用 int a[W][H] (W和H如果是动态则编译失败)，只能用 new。
统一性：如果你习惯了 array[y * width + x]，那么无论数组是在栈上(int array[25];)还是堆上(int* array = new int[width * height];)，你的逻辑 ~~底层逻辑~~ 都是统一的。
- 对比：如果你用原生语法，栈上是 a[y][x]，堆上如果你用 int** 也是 a[y][x] ~~如果用int* array = new int[width * height];就没办法用这种形式. 和前者甚至不🙆‍♀️~~ ，但它们的底层指令完全不同（一个计算偏移，一个跳转指针），且不能互相传递。
传递方便：将 int a[5][5] 作为参数传递给函数很麻烦（必须指定列数，如 void func(int arr[][5])），而传递一个 int* 则非常简单通用。
- 编译器必须知道“每一行有多少个元素”，否则它无法计算出a[i][j]的内存地址。

63计时

Thu, 12 Feb 2026 19:39:48 +0800

计时：完成某项操作或执行特定代码所需的时间
c++17加入了 chrono

计时简单例子#

#ifdef LY_EP63

#include <iostream> 
//引入了本节所需要的大部分内容
//跨平台计时
#include <chrono>
//线程相关
#include <thread>

int main()
{
	//为了使用1s表示1秒的用法
	using namespace std::literals::chrono_literals;

	//获取当前时间
	//auto--> std::chrono::steady_clock::time_point
	auto start = std::chrono::high_resolution_clock::now();

	//模拟耗时
	//指定大概睡眠1秒，会有其他开销
	std::this_thread::sleep_for(1s);
	auto end = std::chrono::high_resolution_clock::now();
	
	//算出实际时长
	//也可以用auto
	std::chrono::duration<float> duration = end - start;
	std::cout << duration.count() << "s" << std::endl;
	
	std::cin.get();
}
#endif

解释字面量`1s`#

1s 被称为用户定义字面量 (User-defined literals)，代表一个 std::chrono::seconds 对象，其值为 1。字面量本质上是调用了一个特殊的运算符函数

// 编译器实际执行的操作（示意）
operator""s(1);

在c++的标准库的头文件中，它的定义大致如下：

// 简化后的底层实现
constexpr chrono::seconds operator""s(unsigned long long _Val) noexcept {
 return chrono::seconds(_Val);
}

operator""：这是定义字面量的关键字。
s：这是后缀名称。
constexpr：意味着这个转换在编译期就能完成，没有任何运行时开销（Runtime overhead）。

给函数计时#

#ifdef LY_EP63

#include <iostream> 
//引入了本节所需要的大部分内容
//跨平台计时
#include <chrono>
//线程相关
#include <thread>

struct Timer
{
	std::chrono::time_point<std::chrono::steady_clock> start, end;
	std::chrono::duration<float> duration;


	Timer()
	{
		start = std::chrono::high_resolution_clock::now();
	}

	~Timer()
	{
		end = std::chrono::high_resolution_clock::now();
		duration = end - start;//可以省略不存储结束值

		//1000.0f不是重载，而是编译器硬编码的，1000f会编译报错
		float ms = duration.count() * 1000.0f;
		//24ms
		//std::cout << "Timer took " << ms << "ms" << std:: endl;
		//21ms
		std::cout << "Timer took " << ms << "ms\n";// << std::endl;
	}
};

void Function()
{
	//作用域(函数)内创建Timer对象,整个(函数)作用域(结束后)都会被计时
	Timer timer;
	for (int i = 0; i < 100; i++)
		std::cout << "Hello" << std::endl;
}

int main()
{ 
	Function();
	std::cin.get();
}
#endif

其他#

visual studio也自带分析工具
或者其他任何集成开发环境也许自带分析工具
可以在源代码中修改使其具有类似的计时(分析)工具
还可以用来展示每个函数运行时长的图表,以及那个函数调用了哪个函数

62多线程

Thu, 12 Feb 2026 16:16:06 +0800

std::cin.get() 等待用户输入的那段时间，什么也做不了。此时就可以在后台开另一个线程做其他事

从这篇开始，代码都会写在同一个项目中，使用Mainxx_yy.cpp的类似名字。由于同一个项目有多个main函数（同一篇都好几个），所以文件最顶端添加宏进行判断，visual studio中对项目配置如下

函数声明与类创建`[区别]`#

#ifdef LY_EP62

#include <iostream>
#include <thread>

class Test
{
public:
	Test()
	{
		std::cout << "Test()" << std::endl;
	}

	Test(int k)
	{
		std::cout << "Test(int)" << std::endl;
	}
};
void DoWork()
{

}

int main()
{
	//声明一个类Test的对象
	Test t{};

	// 这是一个函数声明，声明一个函数名
	// 为 t1，没有参数，返回类型
	// 是 Test
	Test t1();

	// 这是一个函数声明，声明一个函数名
	// 为 worker，没有参数，返回类型
	// 是 int
	std::thread worker1();
	
	//声明一个线程对象
	std::thread worker2{};

	//创建线程并立即启动DoWork内的操作
	std::thread worker(DoWork);
	worker.join();

	std::cin.get();
}
#endif

线程简单例子#

#ifdef LY_EP62

#include <iostream>
#include <thread>
 
void DoWork()
{

}

int main()
{
	// 这是一个函数声明，声明一个函数名
	// 为 worker，没有参数，返回类型
	// 是 int
	std::thread worker1();

	//创建的是一个“空”线程对象，内部没有关联
	// 任何实际的执行函数，也不启动线程
	std::thread worker2{};

	//创建线程并立即启动DoWork内的操作
	std::thread worker(DoWork);

	//...启动->到join这期间的代码并
	//不会阻塞

	//主线程会等待
	//主线程会停在 join() 这一行，像在车站等
	// 朋友一样，直到子线程这辆车“到站”并合
	// 二为一，主线程才会继续往下走。
	worker.join();

	//子线程完成前不会执行该行代码
	std::cin.get();
}
#endif

join的作用：让当前线程（通常是主线程）停下来，进入阻塞状态，直到子线程执行完毕为止。
主线程启动一个工作线程，工作线程执行任务，然后在主线程上等待工作线程完成所有任务

子线程无限循环#

#ifdef LY_EP62

#include <iostream>
#include <thread>

void DoWork()
{
	while (true)
	{
		std::cout << "working..." << std::endl;
	}
}

int main()
{ 
	std::thread worker(DoWork); 

	worker.join();

	//子线程完成前不会执行该行代码
	std::cin.get();
}
#endif

阻止无限循环#

#ifdef LY_EP62

#include <iostream>
#include <thread>

// 显式包含时间库
//cherno视频里没有却能运行，可能是有些编译器中，
// <thread> 头文件为了实现 sleep_for 等功能，
// 其内部已经写了 #include <chrono>。(ai回答)
#include <chrono> 

static bool s_Finished = false;

void DoWork()
{ 
	using namespace std::literals::chrono_literals;
	while (!s_Finished)
	{
		std::cout << "working..." << std::endl;
		std::this_thread::sleep_for(1s);
	}
}

int main()
{
	std::thread worker(DoWork);

	//主线程自己阻塞自己了
	std::cin.get();
	//用户按下回车后
	s_Finished=true;

	//按下回车后，子线程或许刚进入
	//while语句块{ ，且还没到达打印语句
	//所以可能子线程要再打印一行，之后下
	//一次循环才不会进入


	worker.join();
	std::cout << "===child thread finished~~==" << std::endl;

	//子线程完成前不会执行该行代码
	std::cin.get();
}
#endif
/* 输出
working...
working...
working...
working...
working...
		 //这就是用户按下的回车行
working...
===child thread over~==

*/

子线程配合join可以用来做清理工作，主线程等待子线程清理完毕后再退出或执行某些操作

61(60)避免使用命名空间

Thu, 12 Feb 2026 10:14:23 +0800

例子#

代码简化

也可以只在函数内部（或者其他作用域）声明

但是有个缺点，没法直接判断vector是哪来的，标准的？还是自己写的。

代码示例#

#include <iostream> 
#include <string>

namespace apple {
	void print(const std::string& text)
	{
		std::cout << text << std::endl;
	}
}

namespace orange {
	void print(const char* text)
	{
		std::string temp = text;
		std::reverse(temp.begin(), temp.end());
		std::cout << temp << std::endl;
	}
}

using namespace apple;
using namespace orange;

int main()
{
	//:: 这个是作用域解析运算符 
	apple::print("Hello");

	//寻找更为匹配的 orange::print
	print("hello");
	/*
Hello
olleh
	*/


	std::cin.get();
}

建议#

任何时候都不要在头文件(xx.h)里面放入using namespace xx;，因为没人知道它会被include到哪里
尽量只有自己的库才用它
尽量在更小的作用域内使用 ~~if、函数、最多是在文件~~

60(61)命名空间

Wed, 11 Feb 2026 23:43:16 +0800

命名空间是什么、有什么用、何时使用、何时不使用、他们有什么用
主要用途是避免命名冲突

60(61)命名空间#

#include <iostream> 
#include <string>

namespace apple {
	void print(const char* text)
	{
		std::cout << text << std::endl;
	}
}

namespace orange {
	void print(const char* text)
	{
		std::string temp = text;
		std::reverse(temp.begin(), temp.end());
		std::cout << text << std::endl;
	}
}

int main()
{
	//:: 这个是作用域解析运算符 
	apple::print("Hello");
	std::cin.get();
}

如果这段代码没有命名空间，那么就存在两个函数签名一模一样的函数，编译都过不去 ~~两个同名且相同的符号（类，函数，变量，常量），同一文件中会编译错误，不同文件则链接错误~~

C语言没有命名空间语法，所以比如glfw库中的函数都是以glfw开头（避免冲突）

如果没有命名空间#

#include <iostream> 
#include <string>

//namespace apple {
	void apple_print(const char* text)
	{
		std::cout << text << std::endl;
	}
//}

//namespace orange {
	void orange_print(const char* text)
	{
		std::string temp = text;
		std::reverse(temp.begin(), temp.end());
		std::cout << text << std::endl;
	}
//}

int main()
{ 
	apple_print("Hello");
	std::cin.get();
}

代码编写风格#

namespace apple { namespace functions {
	void print(const char* text)
	{
			std::cout << text << std::endl;
	}
}}

这么做仅仅是为了减少缩进

58_59函数指针、lambda表达式

Tue, 10 Feb 2026 23:42:53 +0800

本篇聊聊来自C语言的那种原始风格函数指针，后续会讲C++处理函数指针的方法，以及lambda表达式

函数指针，是一种把函数赋给变量的方式
函数只是个符号，并不能进行任何逻辑计算，但是可以拿来调用
可以接受传参，如果返回非void可以得到相应结果
函数可以赋值给变量，函数也可以作为参数传递给其他函数
函数是cpu指令，存储在我们的二进制文件中的某处
auto function = HelloWorld;，获取cpu指令的内存地址并赋值给function

58_59函数指针、lambda表达式#

#include <iostream> 

void HelloWorld()
{
	std::cout << "HelloWorld!" << std::endl;
}

int main()
{
	//function的类型->void (*function)()
	auto function1 = &HelloWorld;
	//&可以省略，因为有隐式转换
	auto function = HelloWorld;
	//相当于
	void (*function2)() = HelloWorld;

	function();
	(*function)();
	function1();
	(*function1)();
	function2();
	(*function2)();
	std::cin.get();
}

隐式转换#

为什么不需要 &？当你直接使用函数名 HelloWorld 时，编译器会将其视为该函数在内存中的起始地址。

auto function = HelloWorld;：编译器看到函数名，自动将其转换为函数指针。
auto function = &HelloWorld;：显式地取函数地址。

这两行代码生成的机器码通常是完全一样的。

只有一种情况“必须”注意虽然对于普通函数两者等价，但在处理类成员函数 (Member Functions) 时，规则会变严：

普通函数： & 可选。
类成员函数：必须使用 & 并且加上类名限定。

例如：auto func = &MyClass::MemberFunction;（这里不能省略 &）。

57标准数组

Tue, 10 Feb 2026 22:50:02 +0800

本篇讲解std::array，c++标准模板库中的标准数组类
这是静态数组，所谓的静态，即不会扩容缩小，数组一旦创建就要定义大小 ~~和std::vector不同~~ 、元素类型。

#include <iostream>
#include <array>
#include <algorithm>

void PrintArray1(int* array, unsigned int size)
{
	for (int i = 0; i < size;)
	{

	}
}

//如果不知道数组大小，使用模板。让编译器自己推断
template<size_t N>
void PrintArray(const std::array<int, N>& data)
{
	// 在这里，N 会根据传入的数组自动推导
	for (size_t i = 0; i < data.size(); i++)
	{
		std::cout << data[i] << std::endl;
	}
}

void PrintArray(const std::array<int,5>& data)
{
	for (int i = 0; i < data.size();)
	{

	}
}

int main()
{
	std::array<int, 5> data;
	std::cout << data.size() << std::endl;
	data[0] = 2;
	data[4] = 1;
	//data[5] = 3;

	//std::array能使用迭代器
	std::sort(data.begin(), data.end());

	int data2[5];
	data[1] = 3;
}

标准数组和普通数组，都是存放在栈上 ~~标准向量是在堆上~~
有警告

`data.size()`如何得知大小#

std::array 的大小（即数字 5）并不存储在程序运行时的内存里，是通过模板推导和常量替换实现的。

56auto

Tue, 10 Feb 2026 16:59:51 +0800

让cpp自动推导新声明变量的类型
c++在一定程度上会转换为弱类型语言

简单例子#

#include <iostream> 

int main()
{
	auto x = 1;//int
	auto y = 1.0;//double
	int a = 5;
	auto b = a;//int
	auto c = y;//double
	auto d = 3L;//long
	auto e = 5.3f;//float
	auto f = "aa";//const char* //常量字符指针
	std::cout << x << std::endl;
	std::cout << y << std::endl;
	std::cout << a << std::endl;
	std::cout << b << std::endl;
	std::cout << c << std::endl;
	std::cin.get();
}

进阶例子#

#include <iostream>
#include <string>

std::string GetName1()
{
	return "Cherno";
}

//返回值应该是const，修改项目设置后才能
// 通过编译: c/c++-Language-Conformancemode-No
char* GetName2()
{
	return "Cherno";
}

int main()
{
	auto a = 'a';

	std::string name1 = GetName1();

	//string有一个可接受字符指针的隐式构造函数
	std::string name2 = GetName2();
	name2.size();

	//如果没有ide显示没办法一眼看出name3的类型
	auto name3 = GetName2(); //char*
	//name3.size();//显然这里编译会失败

	std::cout << *name3 << std::endl;//"C"

	std::cin.get();
}

补充-接收字符指针如何构造string#

#include <iostream>
#include <cstring> // 为了使用 strlen 和 strcpy

class SimpleString {
private:
 char* m_Buffer; // 指向堆内存的指针
 unsigned int m_Size; // 字符串长度

public:
 // 这就是那个“隐式构造函数”
 // 它接收一个 const char* 指针
 SimpleString(const char* string) {
 std::cout << "[Log] 调用了构造函数，接收指针: " << (void*)string << std::endl;
 
 m_Size = strlen(string); // 1. 计算长度
 m_Buffer = new char[m_Size + 1]; // 2. 在堆上申请内存（+1 是为了放 '\0'）
 memcpy(m_Buffer, string, m_Size + 1); // 3. 将内容从只读区拷贝到堆区
 }

 // 析构函数：防止内存泄漏
 ~SimpleString() {
 delete[] m_Buffer;
 }

 // 辅助函数，方便打印
 void Print() const {
 std::cout << m_Buffer << std::endl;
 }
};

char* GetName2() {
 return (char*)"Cherno"; // 字符串字面量在只读区
}

int main() {
 // 发生了隐式转换！
 // 编译器发现 GetName2() 返回 char*，而你需要 SimpleString
 // 于是它自动调用了 SimpleString("Cherno")
 SimpleString name = GetName2(); 

 name.Print();

 std::cin.get();
}

相对有用的场景#

#include <iostream>
#include <string>
#include <vector>

//返回值应该是const，修改项目设置后才能
// 通过编译: c/c++-Language-Conformancemode-No
char* GetName()
{
	return "Cherno";
}

//普通返回类型
auto GetName1()
{
	return "Cherno";
}

//后置返回类型1
auto GetName2() -> const char* {
	return "Cherno";
}

//后置返回类型2
//编译器要先看到a，b的类型，才能推断返回类型
template <typename T, typename U>
auto Multiply(T a, U b) -> decltype(a* b) {
	return a * b;
}

int main()
{
	std::vector<std::string> strings;
	strings.push_back("apple");
	strings.push_back("orange");

	//迭代器，是一个经过精心设计的类，内部最核心的成
	// 员通常就是一个指向容器中某个位置的指针
	for (std::vector<std::string>::iterator it = strings.begin();
		it != strings.end(); it++)
	{
		std::cout << *it << std::endl;
	}

	std::cout << "======1=====" << std::endl;

	//类型过于冗长，用auto替代
	for (auto it = strings.begin();
		it != strings.end(); it++)
	{
		std::cout << *it << std::endl;
	}
	std::cout << "======2=====" << std::endl;

	//类型别名 (Type Aliasing) [现代C++风格]：，支持模板别名（模板化using）
	using UIterator = std::vector<std::string>::iterator;

	//类型别名 (Type Aliasing) [传统C风格]
	typedef std::vector<std::string>::iterator TIterator;

	//类型过于冗长，用auto替代
	for (UIterator it = strings.begin();
		it != strings.end(); it++)
	{
		std::cout << *it << std::endl;
	}
	std::cout << "======3=====" << std::endl;

	//类型过于冗长，用auto替代
	for (TIterator it = strings.begin();
		it != strings.end(); it++)
	{
		std::cout << *it << std::endl;
	}
	std::cout << "======4=====" << std::endl;
	std::vector<std::string> vectors;
	vectors.push_back("hello");
	vectors.push_back("world");

	//s--->const std::string& s
	for (const auto& s : vectors) {
		std::cout << s << std::endl;
	}
	


	std::cin.get();
}

常见的使用场景：

55宏Macro

Tue, 10 Feb 2026 10:57:44 +0800

该集只是简单介绍一下

用预处理器对某些操作进行==类似宏处理~~实现自动化~~ ==
编译C++程序时，首先要进行预处理器处理
- 以#开头的都叫做预处理器指令
- 会被求值，然后处理好。再传递给编译器进行实际编译等操作—文本编辑阶段（可以控制实际输入到编译器的代码）
工作阶段：宏是在预处理（Preprocessing）阶段处理的。这意味着在编译器真正看到你的代码并进行语法分析之前，宏就已经被处理完毕了。
核心功能：宏本质上是查找与替换（Find and Replace）。预处理器会扫描你的源代码，找到宏的名称，并将其替换为你定义的代码块或值。
预处理器（Preprocessor）先处理，模板（Templates）后处理。
- 预处理器处理完后，编译器再进行模板实例化
建议：没有必要频繁的使用高级特性
宏是“翻译单元”私有的
- 在 C++ 编译过程中，每个 .cpp 文件都是独立编译的，这被称为一个翻译单元（Translation Unit）。
- 如果你想在多个 .cpp 文件中使用同一个宏，你应该把它放在一个头文件（.h）中，然后在需要的 .cpp 文件里#include它。

#include <iostream>
#include <string>
int main()
{
	//#define在改行代码之后，所以这行编译不过去
	//WAIT;

	#define WAIT std::cin.get()
	//等待从控制台读取一行 
	WAIT;
}

代码被预处理器处理后编译器看不出和普通代码有任何区别，我们用宏仅仅是改变了源代码的生成方式

例子1#

#include <iostream>
#include <string>

//等待从控制台读取一行 
//如果改行末尾带了;分号，也会被替换
#define WAIT std::cin.get()
#define OPEN_CURLY { 
#define SAY_HELLO std::cout << "Hello1" << std::endl

int main()
OPEN_CURLY

	SAY_HELLO;
	WAIT;
}

例子2#

#include <iostream>
#include <string>

#define LOG(x) std::cout << x << std::endl

int main()
{

	LOG("Hello");
	std::cin.get();
}

分别处理调试和正式发布#

Debug模式下预处理定义了 LY_DEBUG;

54栈内存和堆内存

Mon, 09 Feb 2026 22:16:40 +0800

栈和堆何时被使用，为何被使用，以及如何运作

程序运行时，操作系统会把整个程序加载到内存中，同时分配大量物理内存
栈和堆是内存中实际存在的两个区域
- 栈具有预定义的大小，通常约2兆字节
- 堆也有预定义默认值，随着应用程序运行，它会增长变化
- 我们需要一个地方存储运行程序所需的数据，如局部变量、或者从文件读取数据
请求内存，也称内存分配

接下来看看在栈上分配一个整数，和在栈上分配其他数据的差异。与实际c++代码的堆相比

代码#

#include <iostream>
#include <string>

struct Vector3
{
	float x, y, z;
	Vector3()
		:x(10), y(11), z(12)
	{

	}
};

int main()
{
	{
		//在栈上分配内存
		int value = 5;
		int array[5];
		array[0] = 1;
		array[1] = 2;
		array[2] = 3;
		array[3] = 4;
		array[4] = 5;
		Vector3 vector;

		std::cout << &value << std::endl;
		std::cout << array << std::endl;
		std::cout << &vector << std::endl;
		
	}//作用域结束后，该作用域内栈上分配所有内容都被弹出（内存被释放）
	//在栈上分配内存和释放内存都只是移动栈指针，几乎没有性能损耗

	//new关键字分配堆内存
	int* hvalue = new int;
	*hvalue = 5;
	int* harray = new int[5];
	harray[0] = 1;
	harray[1] = 2;
	harray[2] = 3;
	harray[3] = 4;
	harray[4] = 5;
	//()可以省略
	Vector3* hvector = new Vector3();

	//必须手动释放内存
	delete hvalue;
	delete[] harray;
	delete hvector;

	std::cin.get();
}

栈#

53(补充)字符串_数组_作为参数

Mon, 09 Feb 2026 17:31:49 +0800

普通数组退化 vs. 字符串字面量退化#

1. 本质上的统一：都是“数组退化” (Array Decay)#

在 C++ 编译器眼中，无论是你定义的数组还是手写的字符串，它们的原始身份都是固定长度的数组：

int arr[5] 的原始类型是：int[5]
"abc" 的原始类型是：const char[4]（包含隐藏的 \0）

退化规则：当它们作为参数传递给接收指针的函数时，会执行相同的操作——丢失长度信息，仅留下首元素的内存地址。

2. 它们的三大核心区别#

虽然底层逻辑相同，但在内存布局和使用习惯上，它们有显著差异：

维度	普通数组 (如 `int[]`)	字符串字面量 (如 `"abc"`)
结束标志	无。必须额外传递 `size` 参数。	有。自带“哨兵” `\0` (Null Terminator)。
内存区域	通常在栈 (Stack)，可读可写。	在只读数据区 (Static Data)，不可修改。
退化后的类型	`int[5]` $\rightarrow$ `int*`	`const char[4]` $\rightarrow$ `const char*`

3. 详细拆解#

区别 A：哨兵机制 (The Terminator)#

普通数组：函数拿到 int* 后，完全不知道哪里是数组的终点。如果你不传 size，函数极易越界。
字符串：虽然也退化成了 const char*，但函数可以通过不断向后寻找 \0 来确定长度（这就是 strlen 的工作原理）。

区别 B：内存安全性#

普通数组：

 int arr[] = {1, 2, 3};
 arr[0] = 9; // 完全合法，你拥有这块内存的写权限

字符串字面量：通常在只读数据区（Static/Data Segment）。它虽然退化成了 const char*，但你绝对不能尝试通过指针去修改它，否则程序会直接崩溃。

区别 C：退化后的类型#

int a[5] $\rightarrow$ 退化为 int*
"abc" (即 const char[4]) $\rightarrow$ 退化为 const char*（注意多了一个 const，因为字面量不可修改）。

string及string引用传参对比#

void test1(const std::string& s ) {}
void test2(const std::string s ) {}

int main()
{
 test1("abc");
 test2("abc");
}

特性	const std::string& s	const std::string s
内存身份	函数内部的 s 只是外部对象的别名	函数内部的 s 是一个全新的副本
拷贝次数	仅隐式转换产生的 1 次临时构造	转换构造 + 传参拷贝（共 1-2 次）
推荐程度	极高（行业标准）	不推荐（除非你打算在函数里修改它）
安全性	保证不会在函数内产生冗余副本	容易引发不必要的性能损耗

53模板

Mon, 09 Feb 2026 14:28:16 +0800

template，能让你定义一个待编译的模版 ~~让编译器用一组规则为你编译代码~~

当我写一个函数时，我在函数中使用一个模板，我实际做的事类似蓝图的东西，当我决定调用那个函数时，指定一些参数，他们决定了实际放入模板的代码。

简单例子#

#include <iostream> 

//template表明这是个编译时求值的模板，这不是实际的函数，只有在调用时才会创建并编译成源代码
//可以从实际参数中隐式获取T
template<typename T>
void Print(T value)
{
	std::cout << value << std::endl;
} 
int main()
{
	Print(5);
	//"5.5"被隐式转为const char[4]
	Print("5.5");
	Print(3.7);

	std::cin.get();
}

额外补充#

模板定义	调用 Print(“5.5”) 时 T 的类型	说明
void Print(T value)	const char*	发生退化。传递的是地址。
void Print(T& value)	const char[4]	不发生退化。传递的是数组的引用。
void Print(const T& value)	char[4]	不发生退化。T 本身是 char[4]。

// 它代表：我只接受一个含有 4个char的数组的“引用”
void Print(const char (&value)[4]) {
 // sizeof(value) == 4
 // 编译器知道这个数组刚好就是 4 个字节
}

//数组的首地址
void Print(const char* value) {
 // sizeof(value) == 8 (在64位系统上)
 // 编译器不知道这里有 4 个字符
}

例子2#

#include <iostream> 

//template表明这是个编译时求值的模板，这不是实际的函数，只有在调用时才会创建并编译成源代码(才会实际创建函数)
//可以从实际参数中隐式获取T
template<typename T>
//和上面一个意思
//template<class T>
void Print(T value)
{
	std::cout << value << std::endl;
}

int main()
{
	//显示指定T
	Print<int>(5);
	//让编译器自己推断T的类型
	Print(5);

	std::cin.get();
}

例子3#

52处理多返回值

Sun, 08 Feb 2026 23:14:14 +0800

这篇讨论的是如何在函数返回两个值

cherno推荐的方法是创建一个结构体并返回它

代码预备#

为了演示，本篇使用了string，为了顺便探讨性能（视频中没提到），我写了一个string.h 和string.cpp打印相关信息

//String.h
#pragma once // 防止头文件被重复包含
#include <iostream>

class String
{
private:
 char* m_Buffer;
 unsigned int m_Size;

public:
 // 默认构造函数
 String() : m_Buffer(nullptr), m_Size(0) {}

 // 构造函数
 String(const char* string);

 // 拷贝构造函数（深拷贝）
 //拷贝构造函数 (String a = b;)：当你在创建一个新的对象，并用已有的对象初始化它时调用。
 String(const String& other);

 // 析构函数
 ~String();

 // 运算符重载
 char& operator[](unsigned int index);

 // 赋值运算符重载 (a = b;)：当两个对象都已经存在（已经构造完毕），你只是想把其中一个的值覆盖给另一个时调用。
 String& operator=(const String& other); 

 // 友元函数：重载 << 运算符
 friend std::ostream& operator<<(std::ostream& stream, const String& string);

 // 测试函数
 unsigned int& mytest() { return m_Size; } // 简单的内联函数可以直接写在类内
};

#include "String.h"
#include <cstring> // 必须包含 cstring 才能使用 strlen 和 memcpy

// 构造函数
String::String(const char* string)
{
	m_Size = strlen(string);
	m_Buffer = new char[m_Size + 1];
	memcpy(m_Buffer, string, m_Size);
	m_Buffer[m_Size] = '\0';
}

// 拷贝构造函数
String::String(const String& other)
	: m_Size(other.m_Size)
{
	std::cout << "Copied String!" << std::endl;
	m_Buffer = new char[m_Size + 1];
	memcpy(m_Buffer, other.m_Buffer, m_Size + 1);
}

//赋值运算符 
String& String::operator=(const String& other)
{
	std::cout << "Assignment Operator Called!" << other << std::endl;

	// 1. 自赋值检查 (防止 s1 = s1 的骚操作)
	if (this == &other)
		return *this;

	// 2. 释放当前对象旧的内存，防止内存泄漏
	delete[] m_Buffer;

	// 3. 申请新空间并拷贝内容
	m_Size = other.m_Size;
	m_Buffer = new char[m_Size + 1];
	memcpy(m_Buffer, other.m_Buffer, m_Size + 1);

	// 4. 返回对象自身，支持链式赋值 (a = b = c)
	return *this;
}

// 析构函数
String::~String()
{
	delete[] m_Buffer;
}

// 下标运算符重载
char& String::operator[](unsigned int index)
{
	return m_Buffer[index];
}

// 友元函数定义（注意：定义时不需要加 String::，也不需要加 friend 关键字）
std::ostream& operator<<(std::ostream& stream, const String& string)
{
	stream << string.m_Buffer;
	return stream;
}

方法1：使用引用#

#include <iostream>
#include "String.h"

void ParseShader(String& vertexSource, String& fragmentSource)
{
	//假设vs，fs最终计算值是abc、def
	String vs = "abc";
	String fs = "def";

	//这两行代码执行的是 字符串赋值(内部会拷贝)
	vertexSource = vs;
	fragmentSource = fs;
}

int main()
{
	String vs, fs;
	ParseShader(vs, fs);
	std::cout << vs << std ::endl;
	std::cout << fs << std::endl;
	std::cin.get();
}
/*
Assignment Operator Called!abc
Assignment Operator Called!def
abc
def

*/

方法2：使用指针#

#include <iostream>
#include "String.h"

void ParseShader(String* vertexSource, String* fragmentSource)
{
	//假设vs，fs最终计算值是abc、def
	String vs = "abc";
	String fs = "def";

	//这两行代码执行的是 字符串赋值(内部会拷贝)
	if (vertexSource) {
		*vertexSource = vs;
	}
	if (fragmentSource) {
		*fragmentSource = fs;
	} 
}

int main()
{
	String vs, fs;
	ParseShader(&vs, &fs);
	//这种方式允许空指针
	//ParseShader(nullptr, &fs);
	std::cout << vs << std::endl;
	std::cout << fs << std::endl;
	std::cin.get();
}
/*
Assignment Operator Called!abc
Assignment Operator Called!def
abc
def
*/

(同类型)方法3：返回(数组)指针#

#include <iostream>
#include "String.h"

String* ParseShader()
{
	//假设vs，fs最终计算值是abc、def
	//vs,fs先在栈上创建（但String成员m_Buffer是指向堆）
	String vs = "abc";
	String fs = "def";

	//这种语法在c++20才能编译通过
	return new String[]{ vs,fs };
} 

int main()
{ 
	//这里不知道数组有多大
	String* result =ParseShader();

	std::cout << result[0] << std::endl;
	std::cout << result[1] << std::endl;
	std::cin.get();
}
/*
Assignment Operator Called!abc
Assignment Operator Called!def
abc
def
*/

分析：

51创建并使用库

Sun, 08 Feb 2026 19:02:14 +0800

如何在vs中设置多个项目，以及如何创建一个能在所有项目中使用的库

51创建并使用库#

先以Game51命名创建一个项目

文件夹查看

再新建一个项目，项目名为Engine

此时

现在确保设置Game51为应用程序

Engine项目配置为静态库

创建文件夹及文件#

show All Files

目录结构

（静态链接库）Engine项目#

//src/Engine.h
#pragma once

namespace engine {
	void PrintMessage();
}
 
//不能这么写,说明:: 被称为作用域解析运算符。它的逻辑
// 是：你只能引用一个已经存在的名字空间。而这里正在定义
//所以不存在
//void engine::PrintMessage();

///src/Engine.cpp
#include "Engine.h"
#include <iostream>

namespace engine {
	void PrintMessage()
	{
		std::cout << "Hello World!" << std::endl;
	}
}

//或者这么写
//void engine::PrintMessage()
//{
//	std::cout << "Hello World!" << std::endl;
//}

（使用静态链接库）Game51项目中#

处理头文件的两个方法#

//Application.cpp

//添加头文件-方法1
//#include "../../Engine/src/Engine.h"

//直接声明-方法0
//namespace engine {
//	void PrintMessage();
//}


int main()
{

	engine::PrintMessage();
}

处理头文件的第3个方法#

右键项目Game51属性修改

50使用动态库

Sun, 08 Feb 2026 16:02:50 +0800

动态链接是什么，以及如何使用

动态链接是在运行时发生的链接，当你实际启动可执行文件时，动态链接库加载时它并非可执行文件的一部分，此时动态链接库被载入内存。意味着运行时会动态链接另一个库，然后运行应用程序载入一个额外文件到内存。
- 这种情况下，可执行文件实际上需要某些库存在（外部文件）。比如windows系统经常出现“缺少某些dll文件无法启动”
- 可执行文件了解动态链接库，可执行文件是一个独立文件，在运行时加载的独立模块。但也可以加载动态链接库，他会在运行时查找并加载动态库，然后可以获取函数指针/动态库中任何内容
静态链接是在编译时发生的链接，当你编译一个静态库时，将它链接到可执行文件、应用程序或动态库中。即：直接获取静态库的内容，然后把它和其他二进制数据放到一起，静态库实际存在于可执行文件或动态库中，所以编译器、链接器完全清楚这些代码，并会对此进行优化

当我们说“链接到一个动态库”时，实际上是指在创建（生成）那个 DLL 的时候，把静态库的代码塞进去。

补充：动态链接包括“隐式链接” ~~需要 header (.h) 和 import library (.lib)~~ 和“显示链接” ~~编译阶段完全不认识这个 DLL，也不需要 .lib 导入库。用法：运行时使用 Windows API 函数（如 LoadLibrary 和 GetProcAddress）去手动加载。~~

50使用动态库#

复制Dependencies文件夹到根目录

λ tree Dependencies /f

CHERNOCPP\HELLOWORLD49\DEPENDENCIES
└─GLFW
 ├─include
 │ └─GLFW
 │ glfw3.h
 │ glfw3native.h
 │
 └─lib-vc2022
 glfw3.dll
 glfw3.lib
 glfw3dll.lib
 glfw3_mt.lib

静态链接和动态链接都是用同一部分的头文件

目前按ctrl+f7已经能正常编译

glw3dll.lib ~~glfw3dll.lib不存代码，只有地址~~ ，这是指向glw3.dll的一系列指针，所以我们在运行时无需实际检测所有内容的位置，这两者同时编译很重要，因为在运行时如果尝试使用不同静态库与DLL链接，你可能会遇到函数不匹配，并且函数指针会出现内存地址错误。但是这里是由glfw分发的，所以glw3.dll和glw3dll.lib是同时编译的，而且他们直接相互关联，这两者不能分开。

接下来设置库文件

右键项目并build成功。但是目前如果会提示找不到dll文件

49使用静态库

Sat, 07 Feb 2026 23:31:35 +0800

49使用静态库#

从github库或其他敌法check out代码块，在那个代码库里能直接得到编译所需的一切，并运行应用程序或项目等，无需使用包管理器
倾向于实际保留依赖项的版本，实际解决方案中二进制的版本。实际项目文件夹中有物理二进制文件的副本，或者是源码

要自己编译？或者直接链接预构建的二进制文件

建议直接添加另一个项目（依赖项的源代码），然后编译成静态库或动态库
非大型项目，可以直接链接二进制文件（无需源代码）

本篇要处理的是GLFW的库

选择二进制版本 (32位 vs 64位)，这取决于你的目标应用程序架构，而不是你的操作系统。

比如现在我要制作一个32位应用程序

//结构

//里面通常是 HTML 格式的 API 手册。
├─docs
│ └─html
│ └─search
├─include
│ └─GLFW

//含义： 针对 MinGW 编译器的版本（通常配合 GCC 使用）。
//用途： 如果你不在 Windows 上用 Visual Studio，而是用 CLion、Code::Blocks 或者直接在命令行用 g++ 编译，你需要链接这个文件夹里的库（通常是 .a 文件而非 .lib）。
├─lib-mingw-w64 
│ └─libglfw3.a //(静态库)： 如果你用 MinGW 编译器并想进行静态链接
│ └─glfw3.dll //(动态链接库)： 这是库的实体。 如果你选择动态链接，这个文件必须在运行时放在你的 .exe 旁边
│ └─libglfw3dll.a //给编译器看的“目录”。 当你选择动态链接时，你不是直接链接 .dll，而是链接这个 .a 文件。 它告诉编译器：“真正的代码在 glfw3.dll 里，你先编译通过，运行时再去调它。”

//如果你的项目配置为使用通用的 Windows 10/11 SDK 运行时，有时需要专门链接这个版本的库。
├─lib-static-ucrt

//以下是库文件 (.lib)，是给 链接器 用的。之所以有这么多，是因为 C++ 的二进制兼容性比较复杂，库的版本必须尽量与你使用的 Visual Studio 版本匹配
├─lib-vc2013
├─lib-vc2015
├─lib-vc2017
├─lib-vc2019
└─lib-vc2022

库由包含目录includes和库目录libraries组成

47优化cpp中stdvector的使用

Sat, 07 Feb 2026 07:47:28 +0800

预习

#include <iostream>
#include <string>
#include <vector>

struct Test
{

};
struct Vertex
{
	float x, y, z;

	//有了其他的构造函数，如果需要用到无参构造函数，
	//就必须手动写一个
	Vertex()
	{

	}

	//因为有构造函数了，所以Vertex 结构体不是一个聚合类型(
	// 有构造函数)，所以要使用显示构造函数
	// 使 Vertex v = { 1,2,3 }; 编译通过
	Vertex(float x, float y, float z)
	{
		this->x = x;
		this->y = y;
		this->z = z;
	}

	//参数必须是&，原因如下:
	//1. 当你尝试通过 Vertex a = b; 调用复制构造函数时，你需要将 b 传递给参数 other。
	//2. 在 C++ 中，按值传递（Pass by Value）参数本身就会触发一次复制。
	//3. 为了复制 b 到 other，编译器又需要调用复制构造函数。[死循环了]
	//因为main中使用 vector.push({1,2,3}) 需要将临时对象拷贝到vector中，所以这里的参数
	//必须是const
	Vertex(const Vertex& vertex)
	{
		std::cout << "copied constructor handled" << std::endl;
		this->x = vertex.x;
		this->y = vertex.y;
		this->z = vertex.z;
	}
	/*virtual*/ void test()
	{

	}

	~Vertex()
	{
		std::cout << "destructor handled" << std::endl;
	}
};

std::ostream& operator<<(std::ostream& stream, const Vertex& vertex)
{
	stream << vertex.x << "," << vertex.y << "," << vertex.z;
	return stream;
}

//使用引用避免复制整个数组
void Function(const std::vector<Vertex>& vertices)
{

}

int main()
{
	std::vector<Vertex> vertices;
	//vertices.push_back({ 1,2,3 });
	//std::cout << "==0===" << std::endl;
	//vertices.push_back({ 4,5,6 });

	//对上面两行代码优化
	// 1. 预先分配内存，防止搬家
	vertices.reserve(1);
	// 2. 原地构造，防止临时拷贝
	vertices.emplace_back(1, 2, 3);
	std::cout << "==0===" << std::endl;
	//超出容量，会拷贝原来的{1,2,3}到新数组，并且销毁
	// 原数组中的{1,2,3}
	vertices.emplace_back(4, 5, 6);


	std::cout << "==1===" << std::endl;
	Function(vertices);
	std::cout << "==2===" << std::endl;
	vertices.erase(vertices.begin() + 1);
	std::cout << "==3===" << std::endl;
	for (Vertex& v : vertices)
		std::cout << v << std::endl;
	std::cin.get();
}
/*
copied constructor handled //第一个临时对象复制到vector中之后，马上又销毁了
destructor handled
==0===
copied constructor handled //空间不够了，需要把第一个元素复制到新数组中。第二个元素创建临时对象，并复制到新数组中
copied constructor handled
destructor handled //旧的数组中的第一个元素被销毁了
destructor handled //第二个元素的临时对象被销毁了
==1===
==2===
destructor handled
==3===
1,2,3
*/

/*优化后不需要把临时对象复制到vector中，也不需要销毁临时对象了
==1===
==2===
destructor handled
==3===
1,2,3
*/

了解环境是优化过程中最重要的事情之一

46动态数组

Fri, 06 Feb 2026 14:21:51 +0800

动态数组，特别是讨论标准向量类
要习惯CPP的标准库（标准模版库）
标准模版库包含了各种容器、迭代器、算法、仿函数

容器的数据类型由程序员自己决定
cpp提供了一个Vector的类，在std命名空间中，可以调整大小，也可以不指定初始大小
本系列会重写C++中的数据结构，优化后比标准模版库中的快很多

std::vector 的实际工作方式：

当超出实际的分配大小时。当创建一个向量，可能会先分配10个元素大小的空间，当超出这个大小时，会在内存中创建一个比原来更大的数组，并把所有内容复制过去，然后删除旧数组。这样就有了一个更大存储空间的新数组

46动态数组#

struct Test
{

};
struct Vertex 
{ 
	float x, y, z;
	/*virtual*/ void test()
	{

	}
};

//main()中
Vertex v = { 1,2,3 };

聚合初始化（Aggregate Initialization），Vertex 结构体是一个聚合类型（Aggregate Type）。在 C++ 中，如果一个类或结构体满足以下条件：

没有显式定义的构造函数。
成员变量是公有的（public）。
没有基类（没有继承）。
没有虚函数。

那么你可以使用大括号 {} 直接按顺序为成员变量赋值。

vector的基本使用#

#include <iostream>
#include <string>
#include <vector>

struct Test
{

};
struct Vertex
{
	float x, y, z;

	//有了其他的构造函数，如果需要用到无参构造函数，
	//就必须手动写一个
	Vertex()
	{

	}

	//因为有构造函数了，所以Vertex 结构体不是一个聚合类型(
	// 有构造函数)，所以要使用显示构造函数
	// 使 Vertex v = { 1,2,3 }; 编译通过
	Vertex(float x, float y, float z)
	{
		this->x = x;
		this->y = y;
		this->z = z;
	}

	//参数必须是&，原因如下:
	//1. 当你尝试通过 Vertex a = b; 调用复制构造函数时，你需要将 b 传递给参数 other。
	//2. 在 C++ 中，按值传递（Pass by Value）参数本身就会触发一次复制。
	//3. 为了复制 b 到 other，编译器又需要调用复制构造函数。[死循环了]
	//因为main中使用 vector.push({1,2,3}) 需要将临时对象拷贝到vector中，所以这里的参数
	//必须是const
	Vertex(const Vertex& vertex)
	{
		std::cout << "copied constructor handled" << std::endl;
		this->x = vertex.x;
		this->y = vertex.y;
		this->z = vertex.z;
	}
	/*virtual*/ void test()
	{

	}

	~Vertex()
	{
		std::cout << "destructor handled" << std::endl;
	}
};

std::ostream& operator<<(std::ostream& stream, const Vertex& vertex)
{
	stream << vertex.x << "," << vertex.y << "," << vertex.z;
	return stream;
}

int main()
{
	Vertex vertices1[5];
	Vertex* vertices2 = new Vertex[5];

	std::vector<int> myarray;
	//存储Vertex对象，则动态数组的内存是连续的，
	//其中的Vertext对象会按行排列
	//问题是：实际要调整向量大小时得复制所有(类)数据，但内存连续性
	// 带来的读取速度提升通常远超扩容时的开销
	std::vector<Vertex> vertices;
	//存储Vertext指针,实际要调整向量大小是只是复制指针地址(一个数字)
	//，即实际数据的内存地址
	std::vector<Vertex*> vertices4;

	std::cout << "---1---" << std::endl;
	Vertex v = { 1,2,3 };
	//这里演示vertices的使用
	std::cout << "---2---" << std::endl;
	vertices.push_back({ 1,2,3 });
	std::cout << "---3---" << std::endl;
	vertices.push_back({ 4,5,6 });

	std::cout << "---4---" << std::endl;
	for (int i = 0; i < vertices.size(); i++)
	{
		//c++对[]进行了重载
		std::cout << vertices[i] << std::endl;
	}
	std::cout << "---5---" << std::endl;
	//这里会把每个Vertex复制到v
	for (Vertex v : vertices)
		std::cout << v << std::endl;
	std::cout << "---6---" << std::endl;
	//避免复制
	for (Vertex& v : vertices)
		std::cout << v << std::endl;

	//clear() 会移除容器中的所有元素，但通常不一定会立即释放底层内存（容量不变），它只是销毁现有的对象。
	vertices.clear();

	std::cin.get();
}

解释一下`vertices.push_back({1, 2, 3});`#

当你执行 vertices.push_back({1, 2, 3}); 时，逻辑确实是：在 vector 内部的内存中，通过调用复制构造函数来构造一个属于 vector 自己的对象。

45箭头运算符

Wed, 04 Feb 2026 11:24:32 +0800

在 C++ 中，-> 运算符有一个独特的“递归”特性。当你写下 entity->Print() 时，编译器会查看 entity 的类型：

如果 entity 是原生指针：它直接解引用并访问成员。
如果 entity 是一个对象（类实例）：
1. 编译器会调用你重载的 operator->()。
2. 这个函数必须返回两样东西之一：要么是一个原生指针，要么是另一个重载了 -> 的对象。
3. 编译器拿到返回的指针后，自动再次对它使用箭头操作，直到找到最终的成员。

箭头运算符的使用及重载#

#include <iostream>
#include <string>

class Entity
{
public:
	int x;
public:
	void Print() const
	{
		std::cout << "Hello!x=" << x << std::endl;
	}
};

//创建这个类的对象时传入一个堆上的对象，
//可以使用堆对象，且堆对象会被自动释放
class ScopePtr
{
private:
	Entity* m_Obj;
public:
	ScopePtr(Entity* entity)
		:m_Obj(entity)
	{

	}
	~ScopePtr()
	{
		std::cout << "release m_Obj" << std::endl;
		delete m_Obj;
	}

	Entity* GetObject()
	{
		return m_Obj;
	} 
};

int main()
{
	Entity e;
	e.Print();

	//取消引用后用 .函数
	Entity* ptr = &e;
	Entity& entity = *ptr;
	//entity.Print();
	//(*ptr).Print();
	ptr->x = 2;
	ptr->Print();
	{
		ScopePtr entity = new Entity();
		entity.GetObject()->Print(); 
	}

	std::cin.get();
}

重载箭头运算符#

#include <iostream>
#include <string>

class Entity
{
public:
	int x;
public:
	void Print() const
	{
		std::cout << "Hello!x=" << x << std::endl;
	}
};

//创建这个类的对象时传入一个堆上的对象，
//可以使用堆对象，且堆对象会被自动释放
class ScopePtr
{
private:
	Entity* m_Obj;
public:
	ScopePtr(Entity* entity)
		:m_Obj(entity)
	{

	}
	~ScopePtr()
	{
		std::cout << "release m_Obj" << std::endl;
		delete m_Obj;
	}

	Entity* GetObject()
	{
		return m_Obj;
	}

	//1. 告诉编译器：“我把内部的指针给你用，但你只能
	// 看，不能改指针指向的那个 Entity。”
	//2. 右边的const：“这个函数是一个‘只读’函数，它不会修改
	// ScopedPtr 对象内部的任何成员变量。”，而且，他的返回值
	//不能调用非const函数
	const Entity* operator->() const 
	{
		return m_Obj;
	}
};

int main()
{
	Entity e;
	e.Print();

	//取消引用后用 .函数
	Entity* ptr = &e;
	Entity& entity = *ptr;
	//entity.Print();
	//(*ptr).Print();
	ptr->x = 2;
	ptr->Print();
	{
		//隐式转换，编译器会寻找匹配的构造函数
		//等同于：ScopePtr entity(new Entity()); // 直接初始化
		// 或者 ScopePtr entity = ScopePtr(new Entity()); // 显式转换
		ScopePtr entity = new Entity();
		entity.GetObject()->Print();
		entity->Print();
	}

	std::cin.get();
}

对于ScopePtr entity = new Entity();，编译器的逻辑

44_1使用memcpy的注意事项

Tue, 03 Feb 2026 10:28:04 +0800

毁掉多态：篡改虚函数表指针 (vptr)#

#include <iostream>
#include <cstring>

class Entity {
public:
 virtual void SayName() { std::cout << "I am Entity" << std::endl; }
};

class Player : public Entity {
public:
 void SayName() override { std::cout << "I am Player" << std::endl; }
};

void Print(Entity* e) {
 e->SayName(); // 强制程序通过虚表查找
}

int main() {
 Entity base;
 Player p1;

 std::cout << "Before memcpy: ";
 Print(&p1); // 应该输出 I am Player

	//base复制给p1，但是p1的虚函数表却指向的是Entity的
 // 暴力覆盖！把 base 的内存（包含 Entity 的 vptr）强行塞进 p1
 std::memcpy(&p1, &base, sizeof(Entity));

 std::cout << "After memcpy: ";
 Print(&p1); // 这次，它一定会输出 I am Entity！

 std::cin.get();
}

内存错位#

#include <iostream>
#include <cstring>

struct BaseA {
 int a = 111;
};

struct BaseB {
 int b = 222;
};

// Child 同时拥有 a 和 b，继承顺序决定内存顺序，这里先BaseA-->BaseB-->自己的成员
//在内存里，Child 对象是一块连续的砖，布局如下（假设每个 int 占 4 字节）：
// 字节偏移 内容 属于谁
// 0 int a(111) BaseA的地盘
// 4 int b(222) BaseB的地盘8int c(3)Child 的地盘
struct Child : public BaseA, public BaseB {
 int c = 333;
};

int main() {
 Child p;
 BaseB sourceB;
 sourceB.b = 999; // 我们准备了一个新的 B，想把它拷进 p 里

 std::cout << "--- 拷贝前 ---" << std::endl;
 std::cout << "p.a = " << p.a << " (BaseA部分)" << std::endl;
 std::cout << "p.b = " << p.b << " (BaseB部分)" << std::endl;

 // --- 致命操作 ---
 // 程序员的意图：把 sourceB 的数据拷贝给 p
 // 程序员认为：p 既然继承了 BaseB，那我就直接拷过去
 std::memcpy(&p, &sourceB, sizeof(BaseB));

 std::cout << "\n--- 运行 memcpy(&p, &sourceB, ...) 后 ---" << std::endl;

 // 错位发生了！
 // 1. p.a 被改成了 999。因为 memcpy 从 p 的开头（BaseA的位置）开始写。
 // 2. p.b 依然是 222。因为它在内存后面，memcpy 根本没写到它。

 std::cout << "p.a = " << p.a << " (被错误覆盖了！)" << std::endl;
 std::cout << "p.b = " << p.b << " (完全没被拷进去！)" << std::endl;

 std::cin.get();

 return 0;
}

44复制和复制构造函数

Wed, 14 Jan 2026 21:56:11 +0800

了解在C++中复制的实际运作方式，以及如何让它工作，如何避免它工作（避免在不想复制时复制，因为复制对性能有影响，有时只想读取对象或者修改现有对象）

当你把变量赋值给另一个变量时，都是在使用复制。如果是指针，则是复制指针的地址（一串数字，而不是指针指向的内容）

#include <iostream>
#include <string>

struct Vector2
{
	float x, y;
};

int main()
{
	int a1 = 2;
	int b1 = a1;
	//a，b是两个不同的变量，互不影响
	b1 = 3;
	std::cout << a1 << std::endl;//2
	std::cout << b1 << std::endl;//2

	Vector2 a = { 2,3 };
	Vector2 b = a;
	b.x = 5;
	std::cout << a.x << std::endl;//2
	std::cout << b.x << std::endl;//5

	Vector2* aP = new Vector2();
	//复制了指针，没有复制实际数据，复制的是地址
	Vector2* bP = aP;
	bP->x = 2;
	std::cout << aP->x << std::endl;//2
	std::cout << bP->x << std::endl;//2

	bP++;//aP没有被影响到
	std::cout << aP << std::endl;//000002A2946D9EC0
	std::cout << bP << std::endl;//000002A2946D9EC8

	std::cin.get();
	return 0;
}

除了引用以外，其他的给变量赋值，都是使用的复制

43智能指针

Mon, 12 Jan 2026 22:13:59 +0800

智能指针，是真实原始指针被包装。使用智能指针时，将调用new并分配给你内存，这块内存在某些时候会自动释放

unique pointer 唯一指针#

在一个作用域内，同一个原始指针只能被一个 unique_ptr 管理。它禁止拷贝，这意味着你不能通过赋值来增加它的引用，只能使用 std::move() 将所有权从一个指针转移给另一个。

转让所有权-附加知识点#

#include <iostream>
#include <memory>
class Entity {};
int main() {
 // 1. 创建第一个 unique_ptr
 std::unique_ptr<Entity> entity = std::make_unique<Entity>();

 // 2. 使用 std::move 转移所有权
 // 此时，entity 原有的内存所有权交给了 e2
 std::unique_ptr<Entity> e2 = std::move(entity);

 // 3. 检查状态
 if (entity == nullptr) {
 std::cout << "entity 现在是空的 (nullptr)" << std::endl;
 }

 if (e2 != nullptr) {
 std::cout << "e2 现在拥有 Entity 的所有权" << std::endl;
 }

 std::cin.get();
 return 0;
} // e2 在这里离开作用域，Entity 被自动销毁

示例-主要知识点#

#include <iostream> 
#include <string>
#include <memory>

class Entity
{
public:

	//constructor-构造函数
	Entity()
	{
		std::cout << "Created Entity!" << std::endl;
	}


	//destructor-析构函数
	~Entity()
	{
		std::cout << "Destroyed Entity!" << std::endl;
	}

	void Print()
	{
		std::cout << "hello" << std::endl;
	}

};

int main()
{
	std::cout << "start--" << std::endl;
	{
		//不允许，禁止隐式转换
		//std::unique_ptr<Entity> entity =new Entity();
		
		//允许,直接调用构造函数，但是不建议
		//如果创建完原始对象后发生了异常，没有来得及将它放到智能指针对象
		//会导致不释放指针指向内存，导致内存泄漏
		//std::unique_ptr<Entity> entity(new Entity());
		
		//不会有这问题，因为std::make_unique保证了创建对象和将其
		// 放入智能指针是一个原子操作==，中间不会被其他逻辑插入，因
		// 此它是异常安全的。
		std::unique_ptr<Entity> entity = std::make_unique<Entity>();

		entity->Print();

		std::unique_ptr<Entity> e2 = std::move(entity);//允许
		//std::unique_ptr<Entity> e3 = entity;//不允许，编译报错
		/*查看源码
		* 复制构造函数和赋值操作符被删除
			unique_ptr(const unique_ptr&) = delete;
			unique_ptr& operator=(const unique_ptr&) = delete;		
		*/

	}
	std::cout << "end--" << std::endl;
	std::cin.get();
}
/*
start--
Created Entity!
hello
Destroyed Entity!
end--
*/

不允许std::unique_ptr<Entity> entity =new Entity(); 因为禁止隐式转换

42对象生命周期

Mon, 12 Jan 2026 17:33:52 +0800

栈中对象的生命周期

范围#

栈#

#include <iostream> 
#include <string>

class Entity
{
public:

	//constructor-构造函数
	Entity()
	{
		std::cout << "Created Entity!" << std::endl;
	}


	//destructor-析构函数
	~Entity()
	{
		std::cout << "Destroyed Entity!" << std::endl;
	}

};

int main()
{
	std::cout << "start--" << std::endl;
	{
		Entity e;
	}
	std::cout << "end--" << std::endl;
	std::cin.get();
}
/*
start--
Created Entity!
Destroyed Entity!
end--
*/

超出范围则自动销毁

堆#

#include <iostream> 
#include <string>

class Entity
{
public:

	//constructor-构造函数
	Entity()
	{
		std::cout << "Created Entity!" << std::endl;
	}


	//destructor-析构函数
	~Entity()
	{
		std::cout << "Destroyed Entity!" << std::endl;
	}

};

int main()
{
	std::cout << "start--" << std::endl;
	{
		Entity* e=new Entity();
	}
	std::cout << "end--" << std::endl;
	std::cin.get();
}
/*
start--
Created Entity!
end--
*/

返回栈内存的指针及解决办法#

#include <iostream> 
#include <string>

class Entity
{
public:

	//constructor-构造函数
	Entity()
	{
		std::cout << "Created Entity!" << std::endl;
	}


	//destructor-析构函数
	~Entity()
	{
		std::cout << "Destroyed Entity!" << std::endl;
	}

};

int* CreateArrayWrong()
{
	//在栈上声明一个数组
	//第一个元素为6，剩余49个为0
	int array[50] = { 6 };
	//返回指向该数组(栈内存)的指针
	return array;
}


int* CreateArray1()
{
	//在栈上声明一个数组
	//第一个元素为6，剩余49个为0
	int* array = new int[50] { 6 };
	//返回指向该数组(栈内存)的指针
	return array;
}
void CreateArray2(int*)
{
	//填充数组
}

int main()
{
	//错误,这里得到的数据是不可信的，
	//极有可能被其他代码拿来使用
	int* a = CreateArrayWrong();

	//方法1
	int* a1 = CreateArray1();
	//方法2
	int array[50];
	CreateArray2(array);

	std::cin.get();
}

智能指针#

这是一个包装类，构造在栈中使用指针，分配堆内存；在包装类销毁时删除指针

41this关键字

Sun, 11 Jan 2026 23:07:21 +0800

this：是一个指针，指向当前对象实例

#include <iostream> 

class Entity;//必要的，视频没有加上
void PrintEntity(Entity* e);
void PrintEntity2(const Entity& e);

class Entity
{
public:
	int x, y;

	Entity(int x, int y)
	{
		//这里会报错，this是指针常量
		//this = nullptr;
		
		//this是指针常量
		//这里如果不加const不会报错,
		//视频教程中必须加否则报错，不知道为啥
		Entity* const e = this; 
		
		//或者//(*e).x = x;
		e->x = x;

		this->x = x;
		this->y = y;

		PrintEntity(this);
		PrintEntity2(*this);
		delete e;
 	}

	int GetX() const
	{
		//没有const修饰会报错
		//Entity* e = this;
		const Entity* e = this;
		return x;
	}
};


void PrintEntity(Entity* e)
{
	//Print
}
void PrintEntity2(const Entity& e)
{
	//Print
}

int main()
{

	std::cin.get();
}

40运算符和运算符重载

Sun, 11 Jan 2026 16:24:51 +0800

重载运算符`+`#

方法1#

#include <iostream>
#include <string> 

struct Vector2
{
	float x, y;

	Vector2(float x, float y)
		:x(x), y(y) {
	}

	Vector2 Add(const Vector2& other) const
	{
		return Vector2(x + other.x, y + other.y);
	}

	Vector2 operator+(const Vector2& other) const
	{
		return Add(other);
	}

	Vector2 Multiply(const Vector2& other) const
	{
		return Vector2(x * other.x, y * other.y);
	}

};

int main()
{
	Vector2 position(4.0f, 4.0f);
	Vector2 speed(0.5f, 1.5f);
	Vector2 powerup(0.5f, 1.5f);

	Vector2 result1 = position.Add(speed.Multiply(powerup));
	Vector2 result2 = position + speed;// *powerup;

	std::cin.get();
}

方法2#

#include <iostream>
#include <string> 

struct Vector2
{
	float x, y;

	Vector2(float x, float y)
		:x(x), y(y) {
	}

	Vector2 Add(const Vector2& other) const
	{
		//this是指向自身的一个指针
		//return *this + other;

		//或者
		return operator+(other);
	}

	Vector2 operator+(const Vector2& other) const
	{
		return Vector2(x + other.x, y + other.y);
	}

	Vector2 Multiply(const Vector2& other) const
	{
		return Vector2(x * other.x, y * other.y);
	}

};

int main()
{
	Vector2 position(4.0f, 4.0f);
	Vector2 speed(0.5f, 1.5f);
	Vector2 powerup(0.5f, 1.5f);

	Vector2 result1 = position.Add(speed.Multiply(powerup));
	Vector2 result2 = position + speed;// *powerup;



	std::cin.get();
}

重载运算符 `*` 及 `==`#

#include <iostream>
#include <string> 

struct Vector2
{
	float x, y;

	Vector2(float x, float y)
		:x(x), y(y) {
	}

	Vector2 Add(const Vector2& other) const
	{
		return Vector2(x + other.x, y + other.y);
	}

	Vector2 operator+(const Vector2& other) const
	{
		return Add(other);
	}

	Vector2 Multiply(const Vector2& other) const
	{
		return Vector2(x * other.x, y * other.y);
	}

	Vector2 operator*(const Vector2& other) const
	{
		return Multiply(other);
	}

	bool operator==(const Vector2& other) const
	{
		return x == other.x && y == other.y;
	}

	bool operator!=(const Vector2& other) const
	{
		//return !(*this == other);
		//或者
		return !operator==(other);
	}

};

std::ostream& operator<<(std::ostream& stream, const Vector2& other)
{
	stream << other.x << "," << other.y;
	return stream;
}

int main()
{
	Vector2 position(4.0f, 4.0f);
	Vector2 speed(0.5f, 1.5f);
	Vector2 powerup(0.5f, 1.5f);

	Vector2 result1 = position.Add(speed.Multiply(powerup));
	Vector2 result2 = position + speed * powerup; 

	std::cout << result1 << std::endl;
	std::cout << result2 << std::endl;

	if (result1 == result2)
		std::cout << "---equals---" << std::endl;

	std::cin.get();
}

运算符重载本质上就是函数。虽然你可以自定义运算符的行为（即函数体里写什么），但你不能改变 C++ 语言定义的运算符规则，包括：

39显式转换和隐式转换

Sun, 11 Jan 2026 14:56:35 +0800

隐式转换表示你没有明确告诉他你要这么做

#include <iostream>
#include <string> 

class Entity
{
private:
	std::string m_Name;
	int m_Age;

public:

	//加上explicit则拒绝隐式转换
	/*explicit*/ Entity(const std::string& name)
		:m_Name(name), m_Age(-1) {
	}

	/*explicit*/ Entity(int age)
		:m_Name("Unknown"), m_Age(age) {
	}

};

void PrintEntity(const Entity& entity)
{

}

int main()
{
	//直接初始化，直接寻找匹配的构造函数，不属于隐式转换
	Entity a("Cherno");
	Entity b(22);

	//违反了“最多只能进行一次用户自定义转换”的原则
	//先从const char[7]转换为std::string
	//然后从std::string转换为Entity
	//Entity a1 = "Cherno";
	//PrintEntity("Cherno");

	//隐式转换
	Entity a1 = std::string("Cherno");
	Entity b2 = 22;
	//建议这样书写简单明了
	//Entity b3(22);

	//隐式转换
	PrintEntity(22);
	PrintEntity(std::string("Cherno"));

	//只进行一次转换，把 const char[7]转换为std::string
	//这里没有涉及到把xx转换为Entity，所以即使
	// explicit Entity(const std::string& name)也
	//能编译通过
	PrintEntity(Entity("Cherno"));

	//强制显式转换
	Entity a3 = (Entity)"Cherno";
	//不转换而是直接调用构造函数
	Entity a3 = Entity("Cherno");

	std::cin.get();
}

38new关键字

Sun, 11 Jan 2026 12:46:30 +0800

常见用法#

new 指定数据类型，数据类型包括类、原始类型、数组，根据数据类型确定必要的大小，以字节为单位
new int，4字节。向操作系统找到连续的4字节大小的内存，然后返回指向该内存地址的指针
有一个空闲列表维护具体可用字节的地址，不需要一个个地址扫描是否可用

#include <iostream>
#include <string> 

//类型别名 (Type Alias) 声明。
using String = std::string;

class Entity
{
private:
	String m_Name;
public:
	Entity() :m_Name("Unknown") {}
	Entity(const String& name) :m_Name(name) {}

	const String& GetName() const { return m_Name; }
};

int main()
{
	int a = 2;
	int* b = new int;
	//连续的50个元素(200个字节)
	int* b_arr = new int[50];

	Entity* e1 = new Entity;
	//和上面那句一个意思
	Entity* e2 = new Entity();

	
	//为了在执行 delete[] e_arr 时知道要调用多少次析构函数，
	// 编译器通常会在分配的内存块头部额外存储一个计数
	// 器（Cookie），记录数组的长度。
	//e_arr指向内存块的大小：50 * sizeof(Entity) + sizeof(size_t)
	//size_t是 C++ 中专门用来表示内存大小和索引的类型:64位系统中是8字节，
	//32位系统中是4字节
	//连续的50个Entity
	Entity* e_arr = new Entity[50];

	std::cin.get();
}

补充：new，delete，delete[] 其实是一个运算符

37创建对象

Sat, 10 Jan 2026 22:39:57 +0800

两种方式，取决于我们在内存的哪个位置创建对象(堆heap或栈stack)

C++ 有一条基本准则：任何不同的对象在内存中都必须有唯一的地址。所以如果创建了两个对象class Empty {};Empty e1;Empty e2;，只有他们都有1字节大小的情况下，e1和e2才会有不同的内存地址

栈上创建的对象，有自动的生命周期，由他们的作用域决定的，离开作用域则消失
堆上创建的对象，会一直在，直到你手动释放它

栈上创建对象#

#include <iostream>
#include <string> 

//类型别名 (Type Alias) 声明。
using String = std::string;

// using 声明，使用的时候只能用string(只起到了省略std::的作用)
//using std::string; 

/*
- 如果你把"using String = ... 还是 using std::string;"写
在 .h (头文件) 的全局作用域里，都会产生“污染”：
- 任何 #include 你这个头文件的人，都会被强制接受你的命名习惯。
如果别人也定义了一个 String，代码就会崩溃（冲突）。
*/

class Entity
{
private:
	String m_Name;
public:
	Entity() :m_Name("Unknown") {}
	Entity(const String& name) :m_Name(name) {}

	const String& GetName() const { return m_Name; }
};

void Function()
{
	int a = 2;
	Entity entity = Entity("Cherno");
}

int main()
{
	Function();
	Entity* e;
	{
		//在栈上创建对象（这里会默认调用默认构造函数）
		Entity entity3("Cherno");
		e = &entity3;
		std::cout << e->GetName() << std::endl;
	}

	//在栈上创建对象（这里会默认调用默认构造函数）
	Entity entity;
	std::cout << entity.GetName() << std::endl;
	//在栈上创建对象
	Entity entity1("Cherno1");
	std::cout << entity1.GetName() << std::endl;
	//在栈上创建对象
	Entity entity2 = Entity("Cherno2");
	std::cout << entity2.GetName() << std::endl;

	std::cin.get();
}

在e = &entity3;加断点，并走到下一步

36三元运算符

Sat, 10 Jan 2026 22:03:11 +0800

if-else的语法糖

初试#

#include <iostream>
#include <string>

static int s_Level = 12;
static int s_Speed = 2;

int main()
{

	if (s_Level > 5)
		s_Speed = 10;
	else
	{
		s_Speed = 5;
	}

	s_Speed = s_Level > 5 ? 10 : 5;
	//嵌套
	// 
	//s_Level > 5 && s_Level < 100 这个会先被连接在一起判断
	s_Speed = s_Level > 5 && s_Level < 100 ? s_Level > 10 ? 15 : 10 : 5;

	//如果>5的情况下，如果还>10，则15，如果不大于10则10；否则(不
	//>5)，则5
	s_Speed = s_Level > 5 ? s_Level > 10 ? 15 : 10 : 5;


	//方式1：这里没有多构造空对象其实和编译器有关，后面会说到
	std::string rank = s_Level > 10 ? "Master" : "Beginer";

	//方式2：这种声明方式，还会比上面额外多构造一个空字符串对象
	std::string otherRank;
	if (s_Level > 10)
		otherRank = "Master";
	else
		otherRank = "Beginer";

	std::cout << s_Speed << std::endl; //15

	std::cin.get();
}

解释一下方式2#

编译器并不会先创建一个临时的 std::string 之后再拷贝给 rank。它的执行逻辑如下：

35成员变量初始化

Fri, 09 Jan 2026 23:24:46 +0800

普通的初始化方法#

#include <iostream>
#include <string>

class Entity
{
private :
	std::string m_Name;
public:
	Entity()
	{
		m_Name = "Unknown";
	}

	Entity(const std::string& name)
	{
		m_Name = name;
	}
	
	const std::string& GetName() const { return m_Name; }
};

int main()
{
	Entity e0;
	std::cout << e0.GetName() << std::endl;
	Entity e1("Cherno");
	std::cout << e1.GetName() << std::endl;
	std::cin.get();
}

初始化列表#

#include <iostream>
#include <string>

class Entity
{
private:
	int m_Score;
	std::string m_Name;

public:

	//如果不是用初始化列表，就会先调用成员变量的构造函数初始化给它默认值(这里是m_Name)，然后在{}中再一次赋值
	//如果用了，那就直接使用初始化列表中的值初始化
	//第二种方式只调用了string(const char*)，而第一种方式多调用了一次string()
	Entity()
		:m_Name("Unknown"),m_Score(0) //注意不论这里的书写顺序是啥
		//都是先初始化m_Score，再m_Name
	{

	}

	Entity(const std::string& name)
		: m_Name(name)
	{

	}

	const std::string& GetName() const { return m_Name; }
};

int main()
{
	Entity e0;
	std::cout << e0.GetName() << std::endl;
	Entity e1("Cherno");
	std::cout << e1.GetName() << std::endl;


	std::cin.get();
}

构造函数的“幕后”过程#

初始化阶段：以下只针对类对象，基本类型不会被自动初始化（除非是全局变量：全局变量会被清零），它们的值是内存中残留的随机垃圾值。

33-34const、mutable关键字

Sun, 04 Jan 2026 00:44:12 +0800

常量折叠、类型强转#

#include <iostream>

int main()
{
	//当你定义 const int MAX_AGE = 90; 时，编译器通常会进行常量折叠（Constant Folding）。这意味着在编译阶段，代码中所有出现 MAX_AGE 的地方都会被直接替换为数字 90;
	//所以最下面的 std::cout << MAX_AGE << std::endl; 打印90
	const int MAX_AGE = 90;
	std::cout << MAX_AGE << std::endl;//90

	int* a = new int;

	*a = 2;
	std::cout << *a << std::endl;//2

	//如果不加 (int*)类型强转,提示 a value of type "const int *"cannot beassigned to an entity of type "int *"
	//报错原因：1. 如果你能直接把 const int* 赋值给 int*，那么你就可以通过 *a = 100; 来修改 MAX_AGE 的值。这违背了 const 的初衷。为了保证代码的健壮性，编译器禁止这种**“权限扩大”**的行为（从“只读”变成“可读写”）。
	//	2. 为什么加上(int*) 就不报错了？
	//	当你加上(int*) 时，你正在使用强制类型转换（C - style Cast）。
	//	这相当于你对编译器说：“我知道 MAX_AGE 是常数，我也知道我在把只读指针转成可读写指针，出了问题我负责，请闭嘴。” 编译器接收到了你的强制指令，于是停止报错。
	a = (int*)&MAX_AGE;
	std::cout << *a << std::endl;//90
	*a = 5;

	//如果MAX_AGE加了volatile关键字修饰，即	const volatile int MAX_AGE = 90;那
	//么不会发生常量折叠，这里应该打印的是5
	std::cout << MAX_AGE << std::endl;//90
	//MAX_AGE 对应的内存空间，通过指针非法修改成了 5
	std::cout << *a << std::endl;//5

	std::cin.get();
}

const的修饰位置#

变量中#

#include <iostream>

int main()
{
	const int MAX_AGE = 90;

	//不能修改指针指向的地址里的值(但可以修改指针指向)
	const int* a = new int;
	//int const* a = new int;//跟上一句一个意思,const都是在*前面
	//*a = 2;//报错

	//由于a已经是const int*了，
	//所以这里编译器没有像int* a时报错
	a = &MAX_AGE;

	std::cout << *a << std::endl;//90 

	//不能修改指针指向的地址里的值(但可以修改指针指向)
	int* const b = new int;
	*b = 2; //可修改地址里的值
	//不可重新分配b指向其他地址
	//b = &MAX_AGE;//报错


	const int* const c = new int;
	int const* const d = new int;
	/*以下均编译不通过*/
	//*c = 2;
	//c = &MAX_AGE;
	//*d = 2;
	//d = &MAX_AGE;
	/*以上均编译不通过*/

	std::cin.get();
}

class中#

#include <iostream>

class Entity
{
private:
	int m_X, m_Y;
	static int s_X;
	int* m_XP;
public:

	//const: 在该方法中不允许修改成员变量
	//禁止修改成员变量： 在该函数内部，你不能对任何非 static 成员变量进行赋值操作。
	//禁止调用非 const 函数
	int GetX() const
	{
		//m_X = 3;
		s_X = 5;
		//test();//会报错
		return m_X;
	}

	//返回一个int指针，且该指针不能改变所存地址
	//指向的值，也不能指向其他地址
	const int* const GetXP() const
	{

		return m_XP;
	}

	void test() //const
	{

	}
};
int main()
{

	std::cin.get();
}

形参中#

#include <iostream>

class Entity
{
private:
	int m_X, m_Y;
	int m_X1;
	mutable int var;
public:

	int GetX1() 
	{
		return m_X1;
	}

	int GetX() const
	{
		//var是一个mutable变量,在const方法中可以修改它
		var = 3;
		return m_X;
	}

	void SetX(int x)
	{
		m_X = x;
	}
};

void PrintEntity1(const Entity* e)
{
	e = nullptr;//允许编译，允许指向其他
	//(*e).SetX(2);//报错，不允许修改值
	std::cout << (*e).GetX() << std::endl;
}

void PrintEntity2(const Entity& e)
{
	//e = nullptr;//不允许编译，因为是引用，不允许重新指向其他
	//e.SetX(2);//报错，不允许修改值
	std::cout << e.GetX() << std::endl;
	//不允许调用非const修饰的函数，下面会报错,
	//因为无法保证GetX1()是否修改了e，而e是const修饰的
	//std::cout << e.GetX1() << std::endl;
}

int main()
{

	std::cin.get();
}

mutable#

class成员变量#

#include <iostream>
#include <string>

class Entity
{
private:
	std::string m_Name;

	//允许标记为const的方法修改该变量
	mutable int m_DebugCount = 0;

public:

	//1.如果是 const std::string，则返回的是一个副本
	//返回一个引用
	//2.最后的const表示该函数内部不允许修改类的非static成员变量
	const std::string& GetName() const
	{
		//m_Name = "a";//非法
		m_DebugCount++;//编译通过

		//由于返回的是引用，所以这里返回了成员变
		//量 m_Name 的一个“地址”或“别名”
		return m_Name;
	}

	void MyTest()
	{

	}
};

int main()
{
	const Entity e;
	e.GetName();//调用const方法
	//e.MyTest();//不允许调用非const方法


	Entity e1;
	e1.GetName();//调用const方法
	e1.MyTest();//调用非const方法 

	std::cin.get();
}

lambda表达式中#

#include <iostream> 

int main()
{
	//lamda表达式

	int x = 1;
	int y = 8;
	const int z = 5;

	//按引用捕获所有变量
	auto f1 = [&]()
		{
			y = 3;//合法,和原变量一样
			//z = 5;//不合法,和原变量一样是const
			std::cout << "Hello" << std::endl;
		};

	//mutable 不能直接修饰普通的局部变量或全局变量,只能
	//是类成员变量
	//mutable int m2 = 0;//没这种写法，会报错

	//按值捕获所有变量
	auto f2 = [=]()
		{
			//y = 3;//不合法,默认是const
			std::cout << "Hello" << std::endl;
		};

	//按值捕获所有变量
	//默认情况下，Lambda 内部的 operator() 是 const 的，不允
	//许修改捕获的副本。加上 mutable 后，Lambda 内部就可以修改这些副本了。
	auto f2_1 = [=]() mutable
		{
			y = 3;
			std::cout << "Lambda 内部 y = " << y << std::endl;//3
		};

	std::cout << "外部原变量 y = " << y << std::endl;//8

	//按值捕获x变量
	auto f3 = [x]()
		{
			//y = 3;//不合法,默认是const
			std::cout << "Hello" << std::endl;
		};

	f1();
	f2();
	f3();
	std::cin.get();
}

字符串字面量

Thu, 01 Jan 2026 19:26:44 +0800

特殊情况

#include <iostream>
#include <stdlib.h>
#include <string>

int main()
{
	//(const char [7])"Cherno"，7字节，因为末尾有一个空字符'\0'
	"Cherno";
	std::cout << "Cher\0no" << std::endl;//Cher

	const char name[8] = "Che\0rno";

	std::cin.get();
}

注意事项#

#include <iostream>
#include <stdlib.h>
#include <string>

int main()
{
	//(const char [7])"Cherno"，7字节，因为末尾有一个空字符'\0'
	"Cherno";
	std::cout << "Cher\0no" << std::endl;//Cher

	const char name[8] = "Che\0rno";
	std::cout << strlen(name) << std::endl;//3,不把\0算在内

	/* 错误的，某些编译器允许编译通过,但没效果
	char* name1 = "Cherno";
	name1[2] = 'a';
	std::cout << name1 << std::endl;//Cherno
	*/

	//一定要修改的话
	char name2[] = "Cherno";
	name2[2] = 'a';
	std::cout << name2 << std::endl;//Charno

	std::cin.get();
}

不同类型的字符串#

#include <iostream>

int main()
{
	const char* name = "Cherno";
	const char* name_ = u8"Cherno";

	//字符串中的每个字符都是宽字符（wchar_t 类型）,
	//通常是16位或32位，取决于系统(大小平台相关)
	//L 前缀表示这是一个宽字符字符串
	const wchar_t* name2 = L"Cherno";

	// C++11后的UTF-16字符串,固定每个字符2字节
	const char16_t* name3 = u"Cherno";

	// C++11后的UTF-32字符串,固定每个字符4字节
	const char32_t* name4 = U"Cherno";

	std::cin.get();
}

字面量运算符#

//"" 是字面量运算符名称的一部分
//它表示这个运算符处理的是字符串字面量
//其他类型的字面量有不同的前缀：
// 不同的字面量类型有不同的运算符名称：
std::string operator""s(...); // 字符串字面量
long double operator""ld(...); // 浮点数字面量
unsigned long long operator""ull(...); // 整数型字面量

#include <iostream>
#include <string>

#include <stdlib.h>

int main()
{
	//启用了 "text"s 语法，让创建 std::string 对象更加
	// 直观、类型安全，特别是在自动类型推导和复杂字符串场景下非常有用。
	using namespace std::string_literals;
	//报错
	//std::string name0 = "Cherno" + " hello";
	std::string name0 = std::string("Cherno") + " hello";

	//// 普通运算符重载：没有引号
	//std::string operator+(const std::string & a, const std::string & b);
	// 字面量运算符：必须有 "" 
	//std::string operator""s(const char* str, size_t len);

	//std::string operator""s(const char* str, size_t len);
	//下面的语句,相当于std::string name1 = operator""s("Cherno", 6) + " hello";
	std::string name1 = "Cherno"s + " hello";
	std::cout << name1 << std::endl;

	std::string name2 = u8"Cherno"s + " hello";
	std::wstring name3 = L"Cherno"s + L" hello";
	std::u32string name4 = U"Cherno"s + U" hello";
	//R 表示 Raw string literal（原始字符串字面量），括号内的内容会完全按照原样被存储，包括换行符、制表符等特殊字符。
	const char* example = R"(Line1
Line2
Line3
Line4)";
	/*
Line1
Line2
Line3
Line4
	*/
	std::cout << example << std::endl;
	const char* example1 = "Line1\n"
		"Line2\n"
		"Line3\n"
		"Line4";
	std::cout << example1 << std::endl;
	std::cin.get();
}

查看字面量汇编文件#

#include <iostream>

int main()
{
	char name[] = "Cherno";
	name[2] = 'a';
	std::cout << name << std::endl;

	std::cin.get();
}

31字符串

Thu, 01 Jan 2026 18:04:34 +0800

字符串本质上是一组字符(字符数组)，字符，即数字、字母等等
需要在计算机上以某种形式表示文本
如果想要在C++中实现字符串功能，先要了解字符的工作原理，以及字符是什么。
如果我们只用一个字节(8位)来表示一个字符，那么就有2^{8=256种可能性。但是如果考虑到字母、数字、特殊符号、中文、韩文远超过256种。所以后面才有16字符编码(UTF-16) UTF-16通常使用16位（2字节）编码一个基本字符 (65536种可能性，一开始是2字节，2}16 = 65536，后面发现65536不够用，进行了扩展，一个字符可能占：2字节或4字节，也成UTF-16。 ~~UTF-32特制固定用4字节表示一个字符的字符编码~~ )。
实际上 C++ 可以处理：ASCII，UTF-8，UTF-16，UTF-32。取决于：编译器，源文件编码，字符类型，字符串类型

本章节中，其实字符串指的是字符指针

字符串修改问题#

#include <iostream> 

int main()
{
	//C风格的定义字符串的方式
	//char* name = "Cherno";
	//正常情况下不修改字符串的值,
	//如果想要新的字符串，那么就要进行全新
	//的内存分配并删除旧字符串(这里不是new，不
	//需要手动delete)
	const char* name = "Cherno";
	char const* name1 = "Cherno";
	//const在*前面，不允许修改数据
	//name[2] = '1';//报错!
	//name1[2] = '1';//报错!

	char buffer[] = "Hello";
	char* const ptr = buffer;
	//const在*后面，不允许指向另一个字符串
	//ptr = new char[3] {'a','b','c'};//报错!

	std::cin.get();
}

字符串在内存中#

#include <iostream>

int main()
{
	//关闭编译器的安全检查来强制通过下一行代码
	//项目-属性-c++-语言:符合模式-->否,宽松模式。
	// 编译器会允许一些非标准或旧版本 C++ 的写法
	//char* name = "Charno";
	//ASCII码: 43 68 61 72 6E 6F 00
	const char* name = "Charno";
	name = new char[3] {'a', 'b','\0'};//允许
	//name[2] = 'a'; //不允许
	std::cout << name << std::endl;


	std::cin.get();
}

字符串的基本原理#

字符串在内存中

30数组

Thu, 01 Jan 2026 10:40:02 +0800

数组：一个集合，一堆元素按照特定的顺序排列起来

#include <iostream> 


int main()
{
	int example[5];
	example[0] = 2;
	example[4] = 4;

	std::cout << example[0] << std::endl;
	//无效值
	std::cout << example[2] << std::endl;
	std::cout << example[4] << std::endl;
	//编译器不检查越界
	std::cout << example[-1] << std::endl;
	std::cout << example[5] << std::endl;
	//数组内存地址
	std::cout << example << std::endl;
	/*
2
-858993460
4
-858993460
-858993460
0000006DC77EFB38
	*/
	std::cin.get();
}

循环#

#include <iostream> 


int main()
{
	int example[5];
	example[0] = 2;
	example[1] = 4;
	example[2] = 2;
	example[3] = 4;
	example[4] = 2;
	for (int i = 0; i < 5; i++)
	{
		example[i] = i;
	}
	std::cin.get();
}

如果，数组在内存中是连续的同类型数值 ~~小端法，这里1个int占用4字节，在内存中按最低有效字节到最高有效字节顺序在内存中排列 ~~

26-29继承_虚函数_接口_可见性

Wed, 31 Dec 2025 18:12:27 +0800

继承#

例子#

#include <iostream>

class Entity
{
public:
	float X, Y;
	void Move(float xa, float ya)
	{
		X += xa;
		Y += ya;
	}
};

//public表示子类继承的父类的成员变量/方法，
//最高只能是public。如果是class Player :protected Entity
//则原来父类中的public成员变量变成protected，但是原来的protected
//和private成员变量则不变
class Player :public Entity
{
public:
	const char* Name;

	void PrintName()
	{
		std::cout << Name << std::endl;
	};
};
int main()
{
	//64位系统，Entity两个float，占用了16字节
	std::cout << sizeof(float) << std::endl;//4
	std::cout << sizeof(char*) << std::endl;//8
	std::cout << sizeof(Entity) << std::endl;//4+4=8
	std::cout << sizeof(Player) << std::endl;//4+4+8=16
	Player player;
	player.Move(5, 5);
	player.X = 2;

	std::cin.get();
}

多态：如果我现在创建一个独立的函数来打印Entity对象，例如通过访问X和Y变量并将它们打印出来。那我其实也可以将Player对象传递给该函数

24-25构造函数和析构函数

Wed, 31 Dec 2025 15:31:53 +0800

构造函数#

我们每次实例化一个对象时都会运行的一个特殊函数

例子#

#ifdef LY_EP24

#include <iostream>

class Entity
{ 
public:
	//C++中不处理的话默认不初始化任何成员变量
	float X, Y;

	//默认的构造函数，什么都不做
	//不写任何构造函数是会默认添加这个
	//Entity()
	//{

	//}

	//构造函数
	Entity()
	{
		X = 0.00f;
		Y = 0.00f;
		std::cout << "Created Entity!" << std::endl;

	}

	//带参数的构造函数
	Entity(float x, float y) {
		X = x;
		Y = y;
	}


	~Entity()
	{
		std::cout << "Destroyed Entity!" << std::endl;
	}

	void Print() {
		std::cout << X << "," << Y << std::endl;
	}
};

void Function()
{
	//声明了一个函数：	函数名：e1，	返回类型：Entity，参数：无
	Entity e1();
	Entity e;//栈上分配
	Entity e2{};//栈上分配
	e.Print();
}

int main()
{
	Function();
 /*
Created Entity!
Created Entity!
0,0
Destroyed Entity!
Destroyed Entity!

 */

	std::cin.get();
}
#endif

不希望其他人使用构造函数#

class Log
{
private:
	Log()
	{
	}
	//或者
	/*
	Log() = delete;
	*/
public:
	static void Write()
	{
	
	}
}

int main(){
	
	Log l;//这里会报错
}

析构函数#

当你摧毁一个对象时，会调用析构函数，析构函数主要用来清楚任何不再需要的内存
最典型的例子，如果在构造对象时在堆上分配内存，则必须在析构函数中手动清理它

#include <iostream>

class Entity
{
public:
	//C++中不处理的话默认不初始化任何成员变量
	float X, Y;

	//默认的构造函数，什么都不做
	//不写任何构造函数是会默认添加这个
	//Entity()
	//{

	//}

	//构造函数
	Entity()
	{
		X = 0.00f;
		Y = 0.00f;
		std::cout << "Created Entity!" << std::endl;

	}

	//带参数的构造函数
	Entity(float x, float y) {
		X = x;
		Y = y;
	}


	~Entity()
	{
		std::cout << "Destroyed Entity!" << std::endl;
	}

	void Print() {
		std::cout << X << "," << Y << std::endl;
	}
};

void Function()
{
	Entity e;//栈上分配
	e.Print();
}

int main()
{
	Function();
 /*
Created Entity!
0,0
Destroyed Entity!

 */

	std::cin.get();
}

23enum

Tue, 30 Dec 2025 22:17:14 +0800

枚举，其实就是一组值
想用整数 ~~只能是整数，比如char，signed char，unsigned char，short，unsigned short，int，unsigned int，long，unsigned long，long long，unsigned long long，不能是浮点类型~~ 来表示某些状态，并且给他们命名
这里解释一下char为什么分 char 和 signed char：signed char 明确表示 -128_{127 的小整数；unsigned char 明确表示 0}255；char 是专门给字符用的类型，它的符号性由编译器决定。

#ifdef LY_EP23
#include <iostream>

//默认情况下是无符号整型unsigned int
enum Example:unsigned char
{
	//如果不指定的话，第一个
	//为0，然后逐个增加
	//只要没有指定的值，都会根据前一个指定的值逐个增加
	A,B,C
};

enum e_MyLong : long
{
	//如果不指定的话，第一个
	//为0，然后逐个增加
	//只要没有指定的值，都会根据前一个指定的值逐个增加
	A1, B1, C1
};


int a = 0;
int b = 1;
int c = 2;


int main()
{
	Example value = B;//如果e_MyLong里面也有B的话，编译器会报错
	Example value1 = Example::B;

	//if (value == 1) //也可以这么写
	if (value == B) {
		std::cout << "get" << std::endl;
	}
	std::cin.get();
}

#endif

日志系统改进#

#include <iostream>

class Log
{
public:
	enum Level
	{
		//这里不能用Error，因为下面有一个同名函数
		LevelError=0, LevelWarning, LevelInfo
	}; 
private:
	//日志实际级别
	//m开头表示类成员变量
	Level m_LogLevel = LevelInfo;
public:
	void SetLevel(Level level)
	{
		m_LogLevel = level;
	}

	//关于字符串指针，后面会讲解
	void Error(const char* message)
	{
		//因为枚举类型是整型，所以
		//这里可以比较
		if (m_LogLevel >= LevelError)
			std::cout << "[ERROR]:" << message << std::endl;
	}

	void Warn(const char* message)
	{
		if (m_LogLevel >= LevelWarning)
			std::cout << "[WARNING]:" << message << std::endl;
	}

	void Info(const char* message)
	{
		if (m_LogLevel >= LevelInfo)
			std::cout << "[INFO]:" << message << std::endl;
	}
};
 
int main()
{
	Log log;
	//警告或更严重的消息会被打印出
	log.SetLevel(Log::LevelWarning);
	log.Warn("Hello!");
	log.Error("Hello!");
	log.Info("Hello!");
	/*
	[WARNING]:Hello!
	[ERROR]:Hello!
	*/

	std::cin.get();
}

20-22面向对象

Tue, 30 Dec 2025 14:45:25 +0800

编写一个类#

#include <iostream>

class Log
{
public:
	const int LogLevelError = 0;
	const int LogLevelWarning = 1;
	const int LogLevelInfo = 2;
private:
	//日志实际级别
	//m开头表示类成员变量
	int m_LogLevel = LogLevelInfo;
public:
	void SetLevel(int level)
	{
		m_LogLevel = level;
	}

	//关于字符串指针，后面会讲解
	void Error(const char* message)
	{
		if (m_LogLevel >= LogLevelError)
			std::cout << "[ERROR]:" << message << std::endl;
	}

	void Warn(const char* message)
	{
		if (m_LogLevel >= LogLevelWarning)
			std::cout << "[WARNING]:" << message << std::endl;
	}

	void Info(const char* message)
	{
		if (m_LogLevel >= LogLevelInfo)
			std::cout << "[INFO]:" << message << std::endl;
	}
};

int main()
{
	Log log;
	//警告或更严重的消息会被打印出
	log.SetLevel(log.LogLevelWarning);
	log.Warn("Hello!");
	log.Error("Hello!");
	log.Info("Hello!");
	/*
	[WARNING]:Hello!
	[ERROR]:Hello!
	*/

	std::cin.get();
}

静态_static#

使用场景：类/结构体内部；类/结构体外部

18-19类_基础

Tue, 30 Dec 2025 00:08:25 +0800

类_基础知识#

类：将数据和功能整合在一起

类定义及函数#

//类定义
class Player
{
	//默认是私有的
	//int x, y;
//这里的public包括了speed这个成员
public:
	int x, y;
	int speed;
};

//函数
void Move(Player& player, int xa, int ya)
{
	player.x += xa*player.speed;
	player.y += ya*player.speed;
}

int main()
{
	//player:对象
	//创建(实例化)一个对象
	Player player;
	player.x = 1;
	player.y = 2;
	player.speed = 2;
	Move(player, 1, -1);
	LOG(player.x);//3
	LOG(player.y);//0
}

类定义及方法#

//类定义
class Player
{
	//默认是私有的
	//int x, y;
//这里的public包括了speed和Move这个成员
public:
	int x, y;
	int speed;
	//方法
	void Move( int xa, int ya)
	{
		x += xa * speed;
		y += ya * speed;
	}
};



int main()
{
	//player:对象
	//创建(实例化)一个对象
	Player player;
	player.x = 1;
	player.y = 2;
	player.speed = 2;
	player.Move( 1, -1);
	LOG(player.x);//3
	LOG(player.y);//0
}

C++中结构和类的区别#

类的默认成员是私有的

17引用

Mon, 29 Dec 2025 22:13:50 +0800

需要有pointer(指针)，即上一个视频的基础

引用其实是指针的扩展，只是指向指针的语法糖，让他更容易阅读。引用本质上是引用现有变量，不同于指针，你可以在其中创建新的指针变量让后将其设置为空指针或其他。引用本身实际上并不占据新变量，他们实际上没有存储空间。

	int a = 5;
	int* b = &a;

	//&符号是类型的一部分
	//使用ref就跟使用a的别名一样
	int& ref = a;
	//这里编译器编译后会直接设置a，而
	//不会再创建一个变量
	ref = 2;

	LOG(a); //5

使用地址增加#

void Increment(int* value) {
	//首先引用指针，然后增加指针处的值
	(*value)++;
}

int main()
{

	int a = 5;
	Increment(&a);
	LOG(a);

	std::cin.get();
}

使用引用实现一样的效果，但是代码更加美观

void Increment(int& value) {
	value++;
}

int main()
{

	int a = 5;
	Increment(a);
	LOG(a);

	std::cin.get();
}

引用的禁忌#

不能指向其他地方


void Increment(int& value) { 
	value++;
}

int main()
{

	int a = 5;
	int b = 8;
	//必须初始化，否则编译错误
	int& ref = a;
	
	//不会出现编译错误，但是其实没有任何效果
	ref = b;

	Increment(ref);
	LOG(b);//打印8，未改变b的值

	std::cin.get();
}

指针，则可以任意变换赋值

16指针

Tue, 23 Dec 2025 12:38:06 +0800

指针

当你写一个程序的时候，你启动他，整个应用程序就会加载到内存，告诉计算机根据代码执行的操作都被加载到内存中，这是cpu实际访问你写的变量的方式。

指针，是一个==存储内存地址 ~~表示内存地址~~ ==的数字

我们需要从内存中，读取或者写入东西，指针，就是内存的地址

忘记指针的类型

例子1-无类型指针#

void* 表示我们不关心地址指向的实际数据是什么类型的

#include <iostream>
#define LOG(x) std::cout << x << std::endl

int main(){
	void* ptr=0;//0，表示这是一个无效指针
	//void* ptr=NULL;// NULL是一个# define NULL 0，其实也是0
	//void* ptr=nullptr;// c++11引入的
	std::cin.get();
}

~~C/C++ 允许局部函数声明 ~~

void func(int); void func(void*); func(0);//调用func(int)，而不是 func(void*)，存在歧义 func(nullptr);// 明确调用 func(void*)

例子2-类型指针#

	int var = 8;
	//void* ptr = &var;
	 int* ptr=&var;
	 double* ptr1=(double*)&ptr; //我知道 ptr 是一个 int* 类型变量(一串表示地址的数字)，但我骗编译器说：ptr 这块内存里放的是一个 double。 骗编译器说 ptr 这个变量里面存放的那几个字节（也就是一个地址值）可以当成 double 来读取。
	//double* ptr=(double*)&var;
	std::cin.get();

调试查看ptr地址上的值

14-15循环

Sat, 20 Dec 2025 18:55:20 +0800

循环

for#

当需要执行某些操作多次时

	for (int i = 0; i < 5; i = i + 1) {
		Log("Hello World");
	}

先创建变量i(为零)
然后检查i<5，是的话执行下面代码块(否则退出)
然后i=i+1
然后再检查i<5，是的话执行下面代码块(否则退出)
3->4->3->4 反复循环直到退出

i的作用域仅限于for代码块

上述代码也可改为

	int i = 0;
	for (; i < 5; ) {
		Log("Hello World");
		i = i + 1;
	}

或者

	int i = 0;
	bool condition = true;
	for (; condition; ) {
		Log("Hello World");
		i = i + 1;
		if (!(i < 5))
			condition = false;
	}

死循环

for(;;)
{
	
}

while#

基本上可以和for语句互转。但是如果有已经存在的条件，优先使用while


	int i = 0;
	while (i < 5) {
		Log("Hello World");
		i++;
	}

do while#

//执行前先判断
bool condition = false;
while (condition)
{

}

//至少执行一次
do
{

} while (condition);

控制流#

continue，break（如果有多重循环，不会影响到外部的循环）

13vs用于c++项目的最佳实践

Sat, 20 Dec 2025 16:08:08 +0800

vs用于c++项目的最佳实践

创建新项目#

解决方案下有项目

MySolusion.sln是解决方案文件

项目下是源代码

Project.vcxproj 是项目相关文件 Project.vcxproj.filters 是过滤器

过滤器决定了vs IDE打开该项目时的视图(实际中不存在文件夹)

显示所有文件#

显示磁盘目录下的所有文件

移动文件位置

#include <iostream>
int main() {
	std::cout << "Hello World!" << std::endl;
	std::cin.get();
}

如图，中间文件(.obj)是放在项目文件夹里

项目编译后生成的可执行文件放在（总的）解决方案文件夹下

由来

$(Platform)\$(Configuration)\，即 x64\Debug 文件夹结构的由来

修改配置#

OutputDirectory: $(SolutionDir)bin\$(Platform)\$(Configuration)\

如果解决方案有多个项目，如果构建DLL文件或者其他需要的东西，我们需要这些在同一个文件夹中（而不用深入每个项目的文件夹）

IntermediateDirectory: $(SolutionDir)bin\intermediates\$(Platform)\$(Configuration)\

~~这里建议加上项目名，避免中间文件冲突(覆盖) $(SolutionDir)bin\intermediates\$(ProjectName)\$(Platform)\$(Configuration)\~~

之后右键项目-clean Solution

查看变量值

清理项目#

解决方案下有一个项目

12条件及分支

Fri, 19 Dec 2025 00:22:47 +0800

条件及分支

先检查一个条件，然后跳转到不同的部分并开始执行指令，意味着条件及分支都有会一点开销。如果想编写稍微快点的代码就不该使用条件语句
如果某事是真的，那么跳转到对应的代码块执行

查看汇编#

mov dword ptr [x],6意思是在内存中名为 x 的位置，写入4个字节的数值 00000006（十六进制）
- mov:移动
- cmp 比较
- jne:是否为零
不相等则跳转
并且将某个位置（代表变量comparisionResult设置为0）
其中，dword ptr [rbp+0F4h],0 表示 将0存储到内存地址rbp+0xF4处的4字节空间（双字）中 ，rbp通常指基指针寄存器（Base Pointer Register），通常是栈帧的基地址
test基本是执行 按位与 运算

补充：test eax, eax 不会改变 eax 的值，只是临时计算 eax AND eax，然后丢弃结果，唯一目的：设置CPU的标志位 ~~同时，test 指令还会强制清零溢出标志（OF = 0）和进位标志（CF = 0）~~ 为什么要自己和自己AND？因为 eax AND eax 的结果就是 eax 本身：如果 eax = 0 → 结果是 0 → ZF=1 ~~零标志位（ZF, Zero Flag）~~ ；如果 eax ≠ 0 → 结果非零 → ZF=0 ；如果 eax < 0（最高位为1） → SF=1 ~~符号标志位（SF, Sign Flag）~~

11如何调试代码

Wed, 17 Dec 2025 23:17:36 +0800

如何调试代码

断点
读取内存

光标放到要调试的行，然后鼠标移动到最前面点一下/或者按F9，即可在该行插入断点
确保是Debug模式，而且点击LocalWindowsDebugger
调试中
橘黄色指向指令指针目前的位置 stepInto(F11):进入目前行所在函数

stepOver(F10):继续执行到下一行

stepOut(shift+F11)：跳出当前函数

此时按F11进入函数(这里和视频不太一样，黄色箭头在左括号处是读不到数值的)

再按一次F10执行到第一行代码前才行

再按一次F10

再按一次F10就继续执行（这里会跳出Log函数）

按F5会继续执行，直到下一个断点

调试#

#include "iostream"
#include "Log.h" 


int main() {
	//InitLog();
	int a = 8;
	a++;
	const char* string = "Hello";
	for (int i = 0; i < 5; i++) {
		const char c = string[i];
		std::cout << c << std::endl;
	}
	Log("hello world!");
	//std::cin.get();
	std::cin.get();
}

箭头在此处，表示该行代码即将执行（未执行），所以此时a为任意可能值(未初始化的内存)

Autos(ide认为比较重要的)，Locals(本地变量)，Watch1(自己添加的监视器)

显示所有的程序内存

左边是内存地址，右边是实际数据

Memory中查看变量值(这里1个int变量占用4个字节)

08-10变量、函数

Mon, 15 Dec 2025 14:17:30 +0800

变量#

编程实际上就是在操纵数据
变量允许我们命名一个我们存储在内存中的数据
我们创建的变量存储在堆栈或堆中
原始数据是构成任何种类的基石
不同的变量类型，唯一的区别，是存储他们需要多少内存(原始数据类型有多大)

整数#

#include <iostream>

int main() {

	int variable = 8;
	std::cout << variable << std::endl;
	variable = 20;
	std::cout << variable << std::endl;
	std::cin.get();
}

int变量通常上是4字节，取决于编译器
可以不用立即赋值
大概在-20亿~+20亿之间
4字节是32位，int是有符号的，第32位存储符号位。还剩下31位存储数据。2^31=21 4748 3648 。
- 最大正数：2^31-1=21 4748 3647
- 最小负数：-(2^31)=-21 4748 3648
- 为什么负数多一个，因为多了一个"-0"但int中没有-0的 ~~浮点数中有-0.0的概念~~ 概念，二进制10000000 00000000 00000000 00000000 代表-(2^31)
unsint 表示无符号整数，能用上所有的位，即最大整数是(2^32) -1
其他：char 1字节，short 2字节，int 4字节，long 通常4字节，long long 通常8字节 ~~由于32位系统最大是4字节，所以long也是4字节。后来出了64位系统，64位windows系统中long是4字节，64位Linux/macOS中long是8字节~~ 可以给任何一个前面加unsigned表示无符号


	char cVariable = 'A';
	//char cVariable=65;
	//不管是用65还是'A'赋值，打印出来的都是A
	std::cout << cVariable << std::endl;
	
	
	short sVariable = 'A';
	//short cVariable=65;
	//不管是用65还是'A'赋值，打印出来的都是65
	std::cout << sVariable << std::endl;

小数#

	float fVariable = 8.2f;//4字节
	std::cout << fVariable << std::endl;
	double dVariable = 20.3;//8字节
	std::cout << dVariable << std::endl;

布尔值#

布尔类型只占用1个字节（只需要1位，但我们在处理内存寻址时，即我们要从那里取回我们的值时，或者将它存储在内存体重时，没有办法只处理个别位，所以只能按字节取）

07链接器

Sat, 13 Dec 2025 17:12:49 +0800

07链接器

介绍#

编译器将C++ 源文件编译成.obj目标文件后，需要进行链接：找到每个符号和函数的位置并将它们链接在一起，在这之前每个文件都已经被编译成了一个单独的目标文件作为翻译单元，它们彼此之间没有任何联系

Ctrl+F7只会编译文件，不会将文件链接；build项目会链接文件。

#include <iostream>
const char* Log(const char* message) {
	return message;
}

int Multiply(int a,int b ) { 

	Log("Multiply");
	return a * b;
}

编译实际上分为编译和链接两个阶段。如果上面代码去掉一个分号，则出现错误

1>E:\cppStudyTemp\ChernoCpp\HelloWorld01\HelloWorld01\Math.cpp(10,1): error 
C2143: syntax error: missing ';' before '}' 
1>Done building project "HelloWorld01.vcxproj" -- FAILED.
========== Build: 0 succeeded, 1 failed, 0 up-to-date, 0 skipped ==========
========== Build completed at 17:51 and took 05.115 seconds ==========

这里C2143，C开头表示是编译阶段的错误

补上后将整个项目build构建后，出现另一个错误：

1>MSVCRTD.lib(exe_main.obj) : error LNK2019: unresolved external symbol main referenced in function "int __cdecl invoke_main(void)" (?invoke_main@@YAHXZ)
1>E:\cppStudyTemp\ChernoCpp\HelloWorld01\x64\Debug\HelloWorld01.exe : fatal error LNK1120: 1 unresolved externals
1>Done building project "HelloWorld01.vcxproj" -- FAILED.

这里出现LNK1120，LNK开头表示链接阶段出现错误

06编译器

Sat, 13 Dec 2025 01:06:00 +0800

编译器的工作原理

介绍#

源文件 编译–> .obj文件 链接–> .exe可执行文件

预处理(包括标记) –> 创建一棵抽象语法树(将所有代码转换为常量数据或指令) –> 创建代码(CPU将执行的实际机器码) ~~这个有点抽象，其实就是处理代码的过程：源代码从“纯文本”蜕变为“结构化逻辑”，最终落实为“硬件机器指令”的编译全流程~~
编译器：为每个C++文件（先经过预处理成为翻译单元）生成目标文件
文件只是C++向编译器提供源代码的方式（并不需要像java那样文件名必须和类名等同）
将.cpp当做C++文件，把.c当做C文件，把.h当做头文件。(默认，也可以改变这个默认约定)
C++文件先经过预处理后成为翻译单元，之后编译器将翻译单元生成为一个目标文件，有时将CPP文件包含在其他CPP文件中并创建一个包含大量文件的大CPP文件。这种情况下只需要编译这个大的CPP文件并生成一个翻译单元，从而生成一个目标文件

hash include#

//Math.cpp
int Multiply(int a, int b) {
	int result = a * b;
	return result;
}

并编译

再添加一个文件EndBrace.h

修改Math.cpp，修改前删除结束括号，会编译出错，之后修改为：

//Math.cpp
int Multiply(int a, int b) {
	int result = a * b;
	return result;
#include "EndBrace.h"

编译成功

告诉编译器输出一个包含所有结果的文件#

简单例子#

修改配置

这个选项会导致不会生成obj文件

编译器只执行第一步：展开 #include 头文件、替换 #define 宏定义、删除注释等。

预处理完成后，它会把结果直接输出到一个后缀为 .i 的纯文本文件中（例如截图下方的 Math.i）。

中断后续编译：它不会继续构建语法树（AST），也不会生成 CPU 能执行的机器码。因此，磁盘上不会生成 .obj（或 .exe）文件。

05C++是如何工作的

Thu, 11 Dec 2025 19:56:24 +0800

C++是如何工作的

源代码 –> 程序启动文件

多个源文件 (编译器)–> 二进制(可执行)文件

分析源码#

/*试着编译单个cpp文件 ctrl+f7
会生成Main.obj文件*/

/*/①（编译器处理）include是预处理指令，会在编
译前找到iostream这个文件并插入该文件内容*/
#include <iostream>


/*②.h文件是在预编译时被处理（插入），并不会被编译；只有
.cpp文件会被编译成 .obj文件，链接器把这些合并成 .exe文件*/

/*③声明，确实有Log函数存在*/
/*④链接器，编译整个项目时，链接器链接时才会去查找这个
函数是否真是存在,如果不存在，则会提示"unresolved external
symbol"：未解析的外部符号，链接器无法找到定义
---链接器的工作是将函数体链接到其标识符(名称)
*/
//参数名message可以省略
//void Log(const char* message);


int main() {
	// << 重载运算符, 运算符可以理解成函数
	//类似下面这句：
	// std::cout.print("hello world!").print(std:endl);//!!编译无法通过
	
	std::cout << "hello world!" << std::endl;
	
	//Log("helloworld!");
	
	//等待按下回车键来移动到程序的下一行
	std::cin.get();
	//可以不写return，默认返回0，表示正确返回程序
}

编译#

项目配置：Debug/Release

平台配置：x64(windows64位系统),x86(windows32位系统)，android….

项目属性#

Release的时候，Optimization这里都是Maximize（最佳优化）

按钮添加#

01-04设置cpp

Thu, 15 May 2025 09:43:53 +0800

WelcomeToCpp#

使用c++可以控制CPU应该执行的每条指令
C++的代码编译后可以在任何平台运行，前提是有一个为对应平台生成机器代码的编译器
与C++不同，C#或JAVA，他们在虚拟机中运行，运行时将代码从“中间语言”转换为机器代码
学习新事物的关键就是对事物进行实验
将讨论如何利用C++库
C++实际上如何工作
关于内存和指针：内存区域，智能指针，移动语义，模板
宏，以及为多个平台编程
编写自己的数据结构，学习如何使他们比C++标准库中的结构更快
低级优化，与编译器和汇编相关

设置C++#

windows平台#

需要文本编辑器，将C++代码编写为文本文件，传递给编译器以生成某种可执行二进制文件，以便可以运行
或者跳过1，直接用IDE，即有一套帮助你编写和调试代码的工具。（Visual Studio，视频用的2017，我这里下载的 Visual Studio Community 2022）
安装勾选：
新建项目

不要勾选 Place solution and project in the same directory

解决方案，solution，是一组相互关联的项目，他们有各种项目类型，解决方案就像工作台，每个项目本质上是一组文件，会编译成目标二进制文件（无论是库还是实际的可执行文件）
添加新项
代码文件(Main.cpp)

#include <iostream>
int main() {
	std::cout << "hello world!" << std::endl;
	std::cin.get();
}

配置文件修改#

下载ChernoVS.vssettings文件，并放到下面的位置
C:\Users\ly\AppData\Local\Microsoft\VisualStudio\17.0_f89cedea\Settings

在vs工具栏中-tools-ImportAndExportSettings-

ImportSelectedEnvironmentSettings

选择no,just Import new，选择 ChernoVS.vssetings即可

运行#

右键，构建（项目）

文件系统查看：
双击.exe文件，结果：

按任意键终止

或者单机本地的Windows调试器来运行它

154【杂项】算竞常用_C++_STL_用法

Thu, 15 May 2025 09:43:53 +0800

C++ 标准模板库 (STL, Standard Template Library)：包含一些常用数据结构与算法的模板的 C++ 软件库。其包含四个组件——算法 (Algorithms)、容器 (Containers)、仿函数 (Functors)、迭代器 (Iterators).

示例：

算法：sort(a.begin(), a.end())
容器：priority_queue<int> pque
仿函数：greater<int>()
迭代器：vector<int>::iterator it = a.begin()

1 前言#

STL 作为一个封装良好，性能合格的 C++ 标准库，在算法竞赛中运用极其常见。灵活且正确使用 STL 可以节省非常多解题时间，这一点不仅是由于可以直接调用，还是因为它封装良好，可以让代码的可读性变高，解题思路更清晰，调试过程往往更顺利。

不过 STL 毕竟使用了很多复杂的结构来实现丰富的功能，它的效率往往是比不上自己手搓针对特定题目的数据结构与算法的。因此，STL 的使用相当于使用更长的运行时间换取更高的编程效率。因此，在实际比赛中要权衡 STL 的利弊，不过这一点就得靠经验了。

接下来，我会分享在算法竞赛中常用的 STL 容器和算法，对于函数和迭代器，就不着重展开讲了。

2 常用容器#

2.1 内容总览#

打勾的是本次将会详细讲解的，加粗的是算法竞赛中有必要学习的。

顺序容器
- array
- vector
- deque
- forward_list
- list
关联容器
- set
- map
- multiset
- multimap
无序关联容器
- unordered_set
- unordered_map
- unordered_multiset
- unordered_multimap
容器适配器

qt学习

Sat, 19 Apr 2025 15:58:12 +0800

建议版本#

Qt 4.8.7 官方推荐的 MinGW 版本为 4.4.x，但是MinGW4.4没法编译，MinGW4.5才行，然后找不到MinGW4.5，这里使用了MinGW4.8。qtCreator配套推荐3.0.1(也可以用3.5.0)

下载(视频所用版本)#

- perl--> https://strawberryperl.com/download/5.16.3.1/strawberry-perl-5.16.3.1-32bit-portable.zip
- MinGW(4.8.1): https://sourceforge.net/projects/mingw-w64/files/Toolchains%20targetting%20Win32/Personal%20Builds/mingw-builds/4.8.1/threads-posix/sjlj/i686-4.8.1-release-posix-sjlj-rt_v3-rev2.7z/download (兼容windowsXP)
- (推荐)https://sourceforge.net/projects/mingw-w64/files/Toolchains%20targetting%20Win32/Personal%20Builds/mingw-builds/4.8.2/threads-posix/dwarf/ （新版win7以上)
=====qt 4.8.7========
- qt库(带MinGW和qtCreator) ：https://download.qt.io/new_archive/qt/4.8/4.8.7/qt-opensource-windows-x86-mingw482-4.8.7.exe
- qt库(源码)： https://download.qt.io/new_archive/qt/4.8/4.8.7/qt-everywhere-opensource-src-4.8.7.zip
- qtCreator: https://qt.mirror.constant.com/archive/qtcreator/3.0/3.0.1/qt-creator-opensource-windows-x86-3.0.1.exe
===弃用===
- MinGW(4.4): https://www.123912.com/s/u5pSjv-32uAH?提取码:M27Z 
	- 要记得设置环境变量
- qt库： https://download.qt.io/archive/qt/4.7/qt-win-opensource-4.7.0-mingw.exe 
- Qt Creator： https://download.qt.io/archive/qtcreator/2.0/qt-creator-win-opensource-2.0.1.exe 
====使用5.0.2====
qt+mingw--> https://download.qt.io/archive/qt/5.0/5.0.2/qt-windows-opensource-5.0.2-mingw47_32-x86-offline.exe
源码--> https://download.qt.io/archive/qt/5.0/5.0.2/single/qt-everywhere-opensource-src-5.0.2.zip
=====在线版5.15======
https://mirrors.tuna.tsinghua.edu.cn/qt/official_releases/online_installers/qt-online-installer-windows-x64-online.exe
- .\qt-online-installer-windows-x64-online.exe --mirror https://mirrors.ustc.edu.cn/qtproject 
- Archive中选择5.15及6.8
- 安装内容：MinGW,Android,QtCharts,QtMultimedia,QtQuich3D,QtShaderTools
=====其他=======
- qt库(带MinGW和qtCreator)： https://download.qt.io/new_archive/qt/5.2/5.2.1/qt-opensource-windows-x86-mingw48_opengl-5.2.1.exe

编译静态编译的qmake#

下载源码
路径不能有奇奇怪怪的符号（.-_ 之类）
(弃)修改 E:\Qt\qtSrc\qtbase\mkspecs\win32-g++\qmake.conf,修改QMAKE_LFLAGS = -static -enable-stdcall-fixup -Wl,-enable-auto-import -Wl,-enable-runtime-pseudo-reloc(仅添加-static)

目录结构#

#mkdir "E:\Qt\qtCustom487\buildQtStatic" #/p
mkdir "E:\Qt\qtCustom\buildQtStatic" #/p
#mkdir "E:\Qt\qtCustom487\qtStatic" #/p
mkdir "E:\Qt\qtCustom\qtStatic" 
#mkdir "E:\Qt\qtCustom487\qtSrc" #/p
mkdir "E:\Qt\qtCustom\qtSrc" 
#E:\Qt\qtCustom下
				- buildQtStatic #(新建的)编译时切换到这个目录
				- qtSrc #源码
				- qtStatic #(新建的)install目录

静态编译#

我用的是视频0087集的办法，也可以用 https://www.cnblogs.com/atggg/p/16878575.html试试

Cpp on 随记

04HelloTriangle

你好，三角#

105弱指针

共享指针与唯一指针例子#

100cpp映射容器

简介#

什么是 Map？#

std::map vs std::unordered_map#

代码演示：基础用法#

迭代与访问#

性能取舍与选择建议#

复杂键的处理#

模板特化#

1. 什么是普通模板？（工厂的模具）#

102如何正确搭建cpp项目

创建项目并克隆#

使用#

95如何真正学好cpp

核心问题：学完基础后该做什么？#

真实世界的代码 vs. 教科书#

“语言学习”的类比#

如何开始？选择你感兴趣的项目#

什么时候可以开始“沉浸”？#

实战演示：分析 OpenCV 源码#

总结：超越代码本身的收获#

94编写迭代器

Vector类#

Main使用#

92动态数组实现

简要概述#

代码vector.h#

应用：添加std::string元素#

应用添加自定义类元素#

91静态数组实现

91静态数组实现#

栈分配和堆分配#

使用alloca函数在栈上分配内存#

代码示例#

93迭代器详解

简单例子#

86类型转换运算符

核心概念#

什么是转换运算符#

代码示例#

简单代码#

(例子)作用域指针-bool转换符#

(例子)定时器#

90stdmove与移动运算符

std::move 到底是什么？#

移动赋值运算符 (Move Assignment Operator)#

为什么 std::move 是必需的？#

常见的错误用法与陷阱#

(例子1)移动构造函数与移动赋值函数#

(例子2)详细解释#

(例子3)视频举的#

结尾 | 总结：拷贝 vs 移动#

89移动语义

为什么要引入移动语义？#

基础：构建实验用的 String 类#

拷贝的代价演示#

编写移动构造函数 (Move Constructor)#

激活移动语义：std::move#

结尾 | 总结与展望#

85左值与右值

什么是左值和右值？#

左值引用 (lvalue references)#

例子#

右值引用 (rvalue references) —— &&#

实际应用：函数重载#

84跟踪内存的分配与释放

核心原理：重载全局 new#

对应的 delete 重载#

实战：追踪总分配量 (The Tracker)#

完整代码#

new#

82单例模式详解

什么是单例？ (The Concept)#

基础实现逻辑 (Basic Implementation)#

现代 C++ 的最佳实践 (The Best Way)#

代码`vector.h`#

应用：添加`std::string`元素#

`std::move` 到底是什么？#

为什么 `std::move` 是必需的？#

基础：构建实验用的 `String` 类#

激活移动语义：`std::move`#

右值引用 (rvalue references) —— `&&`#

核心原理：重载全局 `new`#

对应的 `delete` 重载#

2. 引入 `std::async`#

`data = false;`分析#