C++学习笔记思维导图模板_ProcessOn思维导图、流程图

编译流程

预处理

定义

文本编辑阶段，执行一些预处理的命令，决定什么代码会喂给编译器

宏

#define

可以通过#define Axxx Bxx的方式，将代码中的Axx代码替换成Bxx

#if/#ifdef/#elif defined()/#else/#endif

可以用于控制debug模式和release模式输出不同的内容，比如日志输出之类的

#include

#include可以在编译的时候把被引用的代码包含进来。

c++没有包的概念，也就是java中的package，也无需通过import引入依赖。这点和我以前的写java和python的经验不一样。它需要先将被依赖的项目代码打包成lib文件再通过#include引用到项目中。

#pragma once

xxx.h文件中#pragma once的用法，这个#pragma once是告诉编译器该文件只会被编译一次，以防出现重复编译的问题。

编译

预编译头文件

预编译的头文件可以让我们抓取一些头文件，将他们转换成编译器可以使用的格式，而不需要一遍又一遍的读取这些头文件。

预编译头文件可以避免重复编译代码（被多次引用的），它可以接收很多要编译代码的信息，只编译一次。预编译头文件以二进制格式存储，对编译器来说比单纯的文本处理要快很多，效率也会高很多。

可以把不会经常变更的东西加到预编译头文件中。但是经常变更的就不要加进去。否则会让整个头文件不断重复编译。

预编译头文件最好不要加入比较大的依赖，而是应该加入尽可能小的依赖。避免编译的工作量过大。

汇编

链接

链接阶段在java中是没有的。这个比较有趣。结合翻译单元的概念会比较好理解。每个翻译单元都是单独编译的，然后再进行链接，把所有的代码链接到一起。

分类

静态链接

静态链接在编译阶段发生，会把直接需要链接的资源编译到可执行的exe文件，还会在全局的角度优化代码。执行代码的时候也不需要额外的操作，速度更快效率更高。

动态链接

动态链接是在执行代码的阶段进行。是需要把dll文件放入exe文件目录的。执行exe的时候cpu会把对应exe和ddl文件都加载到内存。因为必须包含这个dll，实际操作确实可能遗忘丢失这个东西。最后补充一下，静态链接和动态链接都可以被#include很好的支持。

静态链接和动态链接，这个需要实操一下才能掌握

指针

智能指针

std::shared_ptr 共享指针

它是通过引用计数的方式，决定一个对象实例是否会被回收。如果引用计数为0，对象实例就可以被销毁。讲解的时候还提到一种弱引用的指针，不会增加引用计数。java中也有这个概念。

std::unique_ptr 唯一指针

唯一指针unique_ptr，使用唯一指针获得的对象实例是无法再次被引用的。

代码

#include <iostream>
#include <memory>

//重写new操作符
void* operator new(size_t size){
std::cout << "allocating..." << size << std::endl;
return malloc(size);
}

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

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

std::string string = "cherno";

std::unique_ptr<Object> obj2 = std::make_unique<Object>();

}

普通指针

神秘的指针其实就是一个整型(int)的内存地址。

指针里存储的内存地址是big endian，大端存储，倒序的。

指针的指针

多维数组

#include <iostream>

int main(){
int** a2d = new int*[50];
for(int i=0; i<50; i++){
a2d[i] = new int[50];
}

for(int i=0; i<50; i++){
delete[] a2d[i];
}
}

多维数组中每个数组存储的地址不一定是连续的，很可能造成cache miss，所以最好通过创建一维数组（逻辑上多维数组）来代替。

模板生成代码（范型）

template<typename T>

类

std::array底层就是用这种方式创建的template<typename T, N>

方法

template<typename T>跟着方法体

缺点

编译阶段对template的代码的处理，有的编译器是不做检查的，也就是说即使在模板代码中同一个变量，前后命名的不一样这种低级的错误也发现不了，只有代码运行的时候才会发现问题

不过Cherno也说因为怕有些程序员过度沉迷于此，写别人很难读懂的代码，所以很多游戏工作室和大公司是禁用模板写代码的。

优点

在编译时期会把T，也就是泛型，替换成真正的数据类型。模板也可以生成class的代码，使用N占位符替换常量。模板这种方式可以减少重复代码，给编程提供了极大的便利性。

线程

join

在当前线程上等待某个特定线程完成它的工作/阻塞当前线程，直到另一个线程完成，再继续执行当前线程。

使用方式

#include <iostream>
#include <thread>

static bool s_Finished = false;

void DoWork(){

while(!s_Finished){
std::cout << "working...\n";
std::this_thread::sleep_for(std::chrono::seconds(1));
}
}

int main(){
std::thread worker(DoWork);
std::cin.get();
s_Finished = true;

worker.join();
std::cout << "finished." << std::endl;
std::cin.get();
}

std::asnyc

std::async会自动创建一个线程去调用线程函数，它返回一个std::future，这个future中存储了线程函数返回的结果，
当我们需要线程函数的结果时，直接从future中获取，非常方便。

std::launch policy是启动策略，
它控制std::async的异步行为

std::launch::async 参数保证异步行为，即传递函数将在单独的线程中执行；

std::launch::deferred参数当其他线程调用get()/wait()来访问共享状态时，将调用非异步行为；

std::launch::async | std::launch::deferred参数是默认行为。有了这个启动策略，它可以异步运行或不运行，这取决于系统的负载。

代码

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

struct X
{
void foo(int x, std::string const& str) {
std::cout << "foo: " << x << " " << str << std::endl;
}
std::string bar(std::string const& str) {
std::cout << "bar: " << str << std::endl;
return str;
}
};

struct Y
{
double operator()(double x) {
std::cout << "Y operator(): " << x << std::endl;
return x; }
};

X baz(X&) {
std::cout << "call baz()" << std::endl;
return X();
}

int main() {
// 在新线程上执行
auto f6=std::async(std::launch::async, Y(), 1.2);

X x;
// 在wait()或get()调用时执行
auto f7=std::async(std::launch::deferred, baz, std::ref(x));

//执行方式由系统决定
auto f8=std::async(
std::launch::deferred | std::launch::async,
baz, std::ref(x));
执行方式由系统决定
auto f9=std::async(baz, std::ref(x));

f7.wait(); // 调用延迟函数

std::cout << "finsh!" <<std::endl;
}

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

int entry() {
std::cout <<"call entry" << std::endl;
return 11;
}
int main() {
std::future<int> the_answer=std::async(entry);
//注释下行代码看同步异步
std::this_thread::sleep_for(std::chrono::seconds(1));
std::cout << "The answer is " << the_answer.get() << "\n"<<std::endl;
}

std::future

std::mutex

static std::mutex s_mutex;
std::lock_guard<std::mutex> lock(s_mutex);

开发技巧

计时器

用于分析方法的性能，这里代码的实现思路了，是利用了方法一旦执行完，方法栈就会销毁，栈上分配的对象也会销毁。
所以在方法开头，创建对象记录执行开始时间，对象析构函数里记录执行完成时间。

RAII, Resource Acquisition is initialization. 只要退出这个函数，资源会被解锁。

代码

#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;

float ms = duration.count() * 1000.0f;
std::cout << ms << "ms" << std::endl;
}

};

void Function(){
Timer timer;
for(int i=0; i<100; i++){
std::cout << "hello\n";
}
}

int main(){
Function();

}

{}大括号限定作用域

在C/C++中大括号指明了变量的作用域，
在大括号内声明的局部变量其作用域自变量声明开始，到大括号之后终结。
{ } 里的内容是一个“块”，单独的{ }在执行顺序上没有改变，仍然是顺序执行，

类型拓展

类型双关

指的是在程序中使用一种类型的数据通过另一种不兼容的类型
来访问。这种操作有时可以绕过类型系统，直接操作内存

一种常见的类型双关形式是使用指针强制转换

#include <iostream>

struct Entity{
int x, y;
};

int main(){
Entity e = {5, 8};
int* position = (int*)&e;
std::cout << position[0] << ", " << position[1] << std::endl;

// int y = *(int*)((char*)&e + 4);
// std::cout << y << std::endl;

}

union关键字

联合体 (union) 是 C++ 中一种特殊的数据结构，它允许不同类型的成员共享相同的内存空间。通过联合体可以实现类型双关。

#include <iostream>

struct Vector2{
float x, y;
};

struct Vector4{
union{
struct{
float x, y, z, w;
};
struct{
Vector2 a, b;
};
};
};

void PrintVector2(const Vector2& vector){
std::cout << vector.x << "," << vector.y << std::endl;
}

int main(){
Vector4 vector = {1.0f, 2.0f, 3.0f, 4.0f};
PrintVector2(vector.a);
PrintVector2(vector.b);
vector.z = 500.0f;
std::cout << "--------------------------"<< std::endl;
PrintVector2(vector.a);
PrintVector2(vector.b);
}

类型转换：安全机制

static_cast

dynamic_cast

比static_cast性能开销更高，沿继承层次结构进行强制类型转换，用于父类子类之间的转换，子类转换成父类可以直接进行隐式的转换，父类到子类需要进行dynamic_cast。如果转换失败，dynamic_cast方法返回null

使用

#include <iostream>
#include <string>

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

class Player : public Entity{

};

class Enemy : public Entity{

};

int main(){
Player* player = new Player();
Entity* e = player;

Enemy* enemy = new Enemy();

Player* p= dynamic_cast<Player*>(e);
}

Runtime Type Information（RTTI）会存储我们所有类型的运行时类型信息，所以增加了性能开销，而且dynamic_cast也需要时间。

const_cast

reinterpret_cast

std::string相关性能优化

使用std::string_view 接收字符串，避免复制字符串对象。

不用substr截取字符串，而是使用std::string_view获取字符串片段，避免复制。

在C++17中，std::string_view 的优化主要体现在它的移动语义上。当你创建一个临时的 std::string 对象并将其传递给一个函数时，
该对象会被移动而不是复制。这可以极大地提高性能，尤其是在处理大量字符串的情况下。

visual studio 2019在小字符串内存分配上做了一些优化，如果不超过15个字符的小字符串，会在栈上分配。超过则在堆上分配。

代码

#include <iostream>
#include <string>

static uint32_t s_AllocCount = 0;

void* operator new(size_t size){
s_AllocCount++;
std::cout << "Allocating " << size << " bytes\n";
return malloc(size);
}

void PrintName(const std::string& name){
std::cout << name << std::endl;
}

void PrintName(std::string_view name){
std::cout << name << std::endl;
}

int main(){
std::string name = "Yan chernikov";

#if 0
std::string firstname = name.substr(0,3);
std::string lastname = name.substr(4,9);
#else
std::string_view firstname(name.c_str(), 3);
std::string_view lastname(name.c_str() + 4, 9);
#endif

PrintName(name);
PrintName(firstname);
PrintName(lastname);

std::cout << s_AllocCount << " allocation" << std::endl;
}

单例模式

当我们想要拥有用于某种全局数据集的功能（组织一堆全局变量和静态函数，比如渲染器和随机数生成器），只是想重复使用时，是比较有用的。

代码

优化前

#include <iostream>

class Singleton{
//这里可以防止实例的复制。
Singleton(const Singleton&) = delete;
public:
static Singleton& Get(){
return s_Instance;
};

void Function(){

}
private:
Singleton(){}
float m_Member = 0.0f;
static Singleton s_Instance;
};

Singleton Singleton::s_Instance;

int main(){
Singleton& instance = Singleton::Get();
//这种方式会复制一个新的singleton实例
//Singleton instanceCopy = Singleton::Get();
instance.Function();
}

优化后

#include <iostream>

class Random{
//这里可以防止实例的复制。
Random(const Random&) = delete;
public:
static Random& Get(){
static Random s_Instance;
return s_Instance;
};

static float Float(){
return Get().IFloat();
};
private:
Random(){}
float m_RandomGenerator = 0.5f;

float IFloat(){
return m_RandomGenerator;
};
};

//Random Random::s_Instance;

int main(){
//Random& instance = Random::Get();
//这种方式会复制一个新的singleton实例
//Random instanceCopy = Random::Get();
//instance.Float();
float number = Random::Float();

std::cout << number << std::endl;

}

常用关键字

const用法

修饰变量

const *

常量指针：指针指向的数据不可更改。

* const

指针常量：指针指向的位置不可以更改。

修饰方法

const修饰方法的时候，就不允许方法里的变量被修改，
方法为只读，除非变量前面有mutable关键字。

static

static 关键字在C++里有private的意思，修饰方法时，只能在当前文件调用该方法。

static 修饰class中的方法，可以直接通过类名调用该方法。

三元操作符

bool?exp1:exp2

三元操作符，可以避免一些构造字符串。

this

指向当前对象实例

auto

自动识别数据类型

int a = 5;
auto b = a;

如果一个方法的返回值类型可能改变，那么用auto类型接收返回值还是比较方便的。
不过也可能造成依赖该返回值类型的代码被破坏。

这种情况也可使用typedef using重命名类型再使用

如果一个方法有比较复杂的返回值类型，可以用auto，比如下面代码可以改造成右边这种形式

for(auto it = strings.begin();
it != strings.end(); it++)
{
std::cout << *it << std::endl;
}

namespace

使用

namespace主要是为了避免命名冲突而存在的。如果出现两个有相同函数签名，即相同的方法名，相同参数列表的方法，最好把它们包含在不同命名空间。

namespace可以嵌套多层使用

using namespace std;

使用

可以在文件开头使用，也可以在方法里面使用；

优点

会使得代码更加简洁。

缺点

容易让人混淆，搞不清函数是否来自标准库。如果遇到了其他外部的库和std标准库相同命名函数时，编译器编译时可能不会出现编译错误。所以在大型项目中，这种错误也难以追踪。

优化

最好是不要在文件开头使用namespace，而是在足够小的作用域使用namespace

enum

枚举类型

用来定义命名的整数值集合。

枚举成员是枚举类型的值，它们在定义时自动从0开始编号，每个成员依次加1。

enum class ErrorCode{
None = 0, NotFound = 1, NoAccess = 2
};

标准库

std::find_if()

#include <iostream>
#include <vector>

void ForEach(const std::vector<int>& values, void(*func)(int)){
for(int value: values)
func(value);
}

int main(){
std::vector<int> values = {1, 6, 3, 4, 5};
auto it = std::find_if(values.begin(), values.end(), [](int value){return value > 3;});
std::cout << "Larger than 3: " << *it << std::endl;
}

std::sort()

默认排序

#include <iostream>
#include <vector>

int main(){
std::vector<int> values = {1, 7, 2, 3, 6, 5 };
std::sort(values.begin(), values.end());

for(int value: values){
std::cout << value << std::endl;
}
}

降序排序

#include <iostream>
#include <vector>
#include <algorithm>
#include <functional>

int main(){
std::vector<int> values = {1, 7, 2, 3, 6, 5 };
std::sort(values.begin(), values.end(), std::greater<int>());

for(int value: values){
std::cout << value << std::endl;
}
}

比较器排序

#include <iostream>
#include <vector>
#include <algorithm>
#include <functional>

int main(){
std::vector<int> values = {1, 7, 2, 3, 6, 5 };
std::sort(values.begin(), values.end(), [](int a, int b){
return a > b;
});

for(int value: values){
std::cout << value << std::endl;
}
}

c++17

std::optional

存储可能存在或者可能不存在的数据。

代码

#include <iostream>
#include <fstream>
#include <string>
#include <optional>

std::optional<std::string> ReadFileAsString(const std::string& filePath){
std::ifstream stream(filePath);
if(stream){
std::string result;
stream.close();
return result;
}

return {};
}

int main(){
std::optional<std::string> data = ReadFileAsString("data.txt");

std::string value = data.value_or("not present");
std::cout << "value:" << value << std::endl;
if(data.has_value()){
std::cout << "successfully\n";
}else{
std::cout << "file could not be opened!\n";
}
}

std::variant

单一变量存放多种类型的数据

为我们创建了一个结构体或者类，将两种数据类型存储为那个类或者结构体中的成员

和union相比的话，union只分配占内存大小更大的数据类型的内存，更有效率更好，variant会存储两种数据类型。但是variant更加类型安全，不会造成未定义行为。

#include <iostream>
#include <variant>

int main(){

std::variant<std::string, int> data;
data = "Cherno";
std::cout << std::get<std::string>(data)<< "\n";
data = 2;
std::cout << std::get<int>(data)<< "\n";
}

std::any

也是单一变量存放多种类型

小的类型，在底层把数据存储为union

大的类型，存储为void*，动态分配内存，但是不利于性能

代码

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

int main(){

std::any anydata;
anydata = std::string("Cherno");
std::string& string = std::any_cast<std::string&>(anydata);
std::cout << "string: " << string;
}

std::move

用移动语义取代复制语义

#include <iostream>
#include <memory>

class String {
private:
char* m_Data;
uint32_t m_Size;
public:
String() = default;
String(const char* string){
printf("created\n");
m_Size = strlen(string);
m_Data = new char[m_Size];
memcpy(m_Data, string, m_Size);
}

String(const String& other){
printf("copyed\n");
m_Size = other.m_Size;
m_Data = new char[m_Size];
memcpy(m_Data, other.m_Data, m_Size);
}

String(String&& other)noexcept {
printf("moved\n");
m_Size = other.m_Size;
m_Data = other.m_Data;

other.m_Size = 0;
other.m_Data = nullptr;
}

String& operator=(String&& other)noexcept {
printf("operator=\n");

if(this != &other){
delete[] m_Data;

m_Size = other.m_Size;
m_Data = other.m_Data;

other.m_Size = 0;
other.m_Data = nullptr;
}
return *this;
};

~String(){
std::cout << "Destroy..." << std::endl;
delete m_Data;
}
void Print(){
for(uint32_t i=0; i< m_Size; i++){
printf("%c", m_Data[i]);
}
printf("\n");
}

};
class Entity{
private:
String m_Name;
public:
Entity(const String& name):m_Name(name){

};

//转换成移动语义
Entity(String&& name):m_Name(std::move(name)){

};

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

int main(){
//Entity entity(String("Cherno"));
//Entity entity("Cherno");
//entity.PrintName();
String apple = "hello";
//下面这种写法不够清晰明了，改造成std::move会好很多
//String dest((String&&)string);
//String dest(std::move(string));

String dest;

apple.Print();
dest.Print();

dest = std::move(apple);

apple.Print();
dest.Print();
}

常用数据类型

整数

int

4个字节

字符串

char*

std:string

也是容器, 可以接收char*类型的数据

浮点型

float

4个字节

布尔类型

bool

1个字节

数组

普通数组

#include <array>

需要自己维护数组大小，没有api可获取数组大小。如果越界访问数组下标会有bounds violation错误

Array(静态数组)

std::array

可以通过size()方法获取数组大小

使用方法

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

数组下标从零开始是为了计算内存地址方便。

静态数组一般在堆上创建。速度很快。

数组的创建如果在堆上，可以避免内存跳跃。

Vector(动态数组)

定义

Vector来自c++的标准库的一种容器，与java里的ArrayList差不多的用法，不过它可以接收原始类型的数据，java中的ArrayList只能传入包装类型和Class的数据，每次容量不够Vector会重新申请更大的内存空间进行自动扩容。

性能优化

问题分析

如果直接通过push_back方法将对象塞入Vector尾部，c++会先构造一遍对象，再复制对象到预先分配好的对应Vector的连续内存空间中。这样会有额外的性能消耗。

如果我们没有预先设置动态数组的大小，也会导致初始长度大小为1的Vector不断进行扩容，这里也会造成对象的二次拷贝，产生性能开销。(overheads)。

解决方法

通过reserve方法预先设置好动态数组大小，这样能有限的减少扩容次数，自然就不需要复制对象到新申请的内存空间。

将push_back方法替换成emplace_back，这种最开始就在已经分配好的内存空间上直接构造对象，不需要复制对象。

补充知识点

Vector底层是储存在堆上的，std:array数组一般存储在栈上。所以技术上来讲std:array更快。

使用

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;
}

class/struct

struct

struct 里申明的变量默认作用域是public

class

class 里申明的变量默认作用域是private，这里的class也有java类中的继承等多态的属性。

多态

继承

如果一个基类有子类的话，需要确保申明的析构函数是虚函数。
也就是包含virtual关键字，销毁子类对象时，子类的析构函数
才能确保被调用。

#include <iostream>

class Base{
public:
Base(){
std::cout << "Base Constructor\n" << std::endl;
}
virtual ~Base(){
std::cout << "Base Destructor\n" << std::endl;
}
};

class Derived : public Base{
public:
Derived(){
std::cout << "Derived Constructor\n" << std::endl;
}
~Derived(){
std::cout << "Derived Destructor\n" << std::endl;
}
};

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

访问修饰符

private

protected

public

函数/方法

性能提升

方法的参数列表需要加上&操作符去避免数据的复制。他真的很注重性能的提升。

纯虚函数

纯虚函数就是接口里没被实现的抽象方法。

构造函数

隐式构造函数

隐式构造函数很牛逼，是java里面没有的功能，但是咋说呢，我觉得可读性有点差。不过有了explicit这个关键字可以禁止隐式构造函数的使用。

拷贝构造函数

一般通过=实现对象的复制是一种浅拷贝(shallow copy)，这个拷贝构造函数是为了实现深拷贝(deep copy)存在的。

无构造函数

操作符重载

使用operator关键字申明方法重载操作符，很神奇。java并不存在这种操作。所以说c++灵活性确实是高。+-*/这些都比较好理解。Cherno还重载了[]和->和new。箭头操作符可以比较方便的获取实例中的属性值。

void* operator new(size_t size){
return malloc(size);
}

函数指针

函数可以赋值给变量，可以作为参数传给另外一个函数，不带()赋值的时候，这时候赋值的就是一个函数的地址。

编译代码时，函数会被编译成cpu指令在我们的二进制文件中。当函数被调用时，我们要检索执行的指令所在的位置。

使用

作为变量

void hello(){
std::cout << "hello world"<< std::endl;
}

int main(){
auto func = hello;
func();
func();
}

void hello(){
std::cout << "hello world"<< std::endl;
}

int main(){
void(*function)() = hello;
function();
function();
}

作为函数的参数

#include <iostream>
#include <vector>

void PrintValue(const int value){
std::cout << "Value: "<< value << std::endl;
}

void ForEach(const std::vector<int>& values, void(*func)(int)){
for(int value: values)
func(value);
}

int main(){
std::vector<int> values = {1, 2, 3, 4, 5};
ForEach(values, PrintValue);
}

函数指针的类型

void(*function)();

匿名函数lambda

[]中决定参数以什么方式传递，=传入值，&通过引用的方式传入

#include <iostream>
#include <vector>

void ForEach(const std::vector<int>& values, void(*func)(int)){
for(int value: values)
func(value);
}

int main(){
std::vector<int> values = {1, 6, 3, 4, 5};
ForEach(values,[](int value){std::cout << "Value: "<< value << std::endl;});
}

c++如何处理多返回值的经验

返回一个struct构造的对象，里面包含多个返回值。哈哈哈，这个我在java里经常操作。

函数方法的参数列表写成带引用&操作符的形式，这种传入的就是实参的内存地址，代码会直接修改内存地址的内容。

返回tuple元祖和pair。在java里面也有pair类可以处理多返回值。这节课比较轻松。不过tuple获取数据要通过std:get的方式，或者first,second的方式，可读性很差。

tuple

#include <iostream>
#include <string>
#include <tuple>

std::tuple<std::string, int> CreatePerson(){
return {"Cherno", 24};
}

int main(){

std::tuple<std::string, int> person = CreatePerson();
std::string& name = std::get<0>(person);
int age = std::get<1>(person);
std::cout <<"name:" << name << ", age:" << age << std::endl;
}

结构化绑定

#include <iostream>
#include <string>
#include <tuple>

std::tuple<std::string, int> CreatePerson(){
return {"Cherno", 24};
}

int main(){
auto[name, age] = CreatePerson();
std::cout <<"name:" << name << ", age:" << age << std::endl;
}

左值与右值

左值是有某种存储支持的变量，右值是临时值，不会存在很长时间。

#include <iostream>

void PrintName(const std::string& name){
std::cout << "[lvalue]" << name << std::endl;
}

void PrintName(const std::string&& name){
std::cout << "[rvalue]" << name << std::endl;
}

int main(){
std::string firstname = "Yan";
std::string lastname = "chernikov";

std::string fullname = firstname + lastname;

PrintName(fullname);
PrintName(firstname + lastname);
}

左值引用只能接受左值，除非是用const

内存管理

内存分配

malloc

malloc和free一般会搭配使用申请和回收内存。

new

new关键字这里有点意思，在java中必须要通过new创建对象(在堆上)，c++这里new也是可以在堆上创建对象或者其他类型的数据，然后返回对象的指针。

使用不含new普通方式创建对象时候，这种方式其实就只是在栈上创建了对象。

new需要我们使用delete操作符配合使用来做内存的回收。

代码

通过重写new操作符来追踪堆上的内存分配

new