Cherno C++视频课程-学习笔记

int *arr = new int[5];
delete[] arr;
1
2

#include 
std::array arr;	// 指明数组元素的类型和个数
for (int i = 0; i < arr.size(); i++) {arr[1] = 10;}
1
2
3

// 该数组定义在C++中合法，但是在C中非法
static const int size = 5;
int arr[size];
1
2
3

#include 
#include 

// void Print(std::string name) // 类对象作为函数参数时，是值拷贝的。建议使用引用作为类对象的参数
void Print(const std::string& name)
{
	std::cout << name <

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11
• 12

P33 C++字符串字面量

1.不同的字符类型：

const char *name1 = "Cherno";
const char *name2 = u8"Cherno";
const wchar_t *name3 = L"Cherno";		// wchar_t 1至4字节
const char16_t *name4 = u"Cherno";		// 2字节
const char32_t *name5 = U"Cherno";		// 4字节
1
2
3
4
5

2.C++14引入的std::string_literals

using namespace std::string_literals;
std::string name = "hello"s + "world"; // 在C++14中合法，后缀s表示将“hello”转换为std::string_literals类型；在C++11中非法
std::string name = std::string("hello") + "world"; // 在C++14中合法；在C++11中合法
1
2
3

3.忽略字符串中的转移字符

std::string name = R("line1
line2
line3");		// 前缀R表示忽略字符串中的转义字符
1
2
3

P34 C++中的CONST

1.const修饰符在变量定义时的位置

const int *var = new int;	// 不能修改var指针，指向的内存；但是可以修改var的内容，即var可以指向新的内存地址。
int const * var = new int;	// 同上
int * const var = new int;	// 可以修改var指针，指向的内存；但是不能修改var的内容，即var不能指向新的内存地址。
1
2
3

2.const用于C++类中的成员函数的定义

class Entity {
	private:
		int m_X, *m_Y;
		mutable int var;
	public:
		int GetX1() const {	// 该const表示，在方法定义中不能修改类的成员变量。
			// m_X = 2;          // 修改m_X会报错。
			return m_X;
		}
		int GetX2() const {
			var = 2;				// 被mutable修饰的成员变量，可以在const修饰的成员函数中修改。
			return m_X;
		}
		const int * const GetY1() const {	// 第一个const：返回的指针变量的内容不能被修改；第2个const：返回的指针变量本身不能被修改。
			return m_Y;
		}
};

void PrintEntity(const Entity &e) {	
	std::cout << e.GetX() << std::endl;    // 变量e的引用被const修饰，e的成员函数GetX()也必须被const修饰，否则编译不通过。
}
Entity e;
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

P36 C++的成员初始化列表

class Example
{
	private:
		int num;
	public:
		Example()
		{
			std::cout << "once" << std::endl;
		}
		
		Example(int n)
		{
			num = n;
			std::cout << "twice with " << n << std::endl;
		}
}

class Entity
{
	private:
		std::string m_Name;
		int m_Age;
		Example  m_Example;
	public:
		Entity(std::string &name, int age)
		{
			m_Name = name;
			m_Age = age;
			
			// 结论：将会打印“once”和“twice with 8”。原因：成员变量m_Example定义时，将调用无参的构造函数。
			m_Example = Example(8);
			// do other thingsl
		}

		// 结论：将会打印“twice with 8”。
		// 结论2：不仅是代码风格的问题! 成员初始化列表减少了类成员对象的默认构造函数的调用，提高了性能。
		Entity() : m_Name("lfc"), m_Age(18), m_Example(Example(8))
		{
			// do other thingsl
		}
}

结论：尽量用成员初始化列表，对性能提升有帮助。
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
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43

P37 C++的三元运算符

方式1：
int age = 18;
std::string desp;	// 调用默认构造函数，创建了desp对象
if (age > 18) {
	desp  = "man";		// 再次调用std::string的构造函数，并创建了新的对象。
} else {
	desp = "child";
}

方式2：
int age = 18;
std::string desp = age > 18 ? "man" : "child"; 		// 仅调用了一次std::string的构造函数。
1
2
3
4
5
6
7
8
9
10
11
12

P38 创建并初始化C++对象

// 在堆上分配
Entity *e = new Entity("Cherno");
delete e;

// 在栈上分配
Entity e2 = Entity("Cherno");
Entity e3("Cherno");
1
2
3
4
5
6
7

P39 C++ new关键字

// 数组的申请和释放
int *arr = new int[50];
delete[]  arr;

// 类对象的申请和释放
Entity *e = new Entity()	// 在堆上分配内存，并调用类的构造函数。
delete e; 							调用析构函数，并释放堆内存。
1
2
3
4
5
6
7

P40 C++隐式转换与explicit关键字

class Entity {
	private:
		std:string m_Name;
		int m_Age;
	public:
		Entity(std::string name) : m_Name(name), m_Age(-1) {}
		Entity(std::string name) : m_Name(name), m_Age(-1) {}
		// 在定义构造函数时，使用explicit关键字进行了声明。作用：与隐式转换相关，请看本节介绍。
		// explicit Entity(std::string name) : m_Name(name), m_Age(-1) {} 
};

void PrintEntity(Entity &e) {
	// print something
}

Entity e1 = "Cherno";  // 合法。使用了隐式构造函数
Entity e2 = 22;  // 合法。使用了隐式构造函数
PrintEntity(22);   // 合法。使用了隐式构造函数
PrintEntity("Cherno");   // 不合法。隐式转换只能进行一次。此处期望将const char *类型的"Cherno"转换为std::string，然后再转换为Entity。需要进行
两次转换，所以不合法。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

explicit关键字，可以禁用隐式构造函数。

P41 C++运算符及其重载

class Vector2 {
	private:
		float x;
		float y;
	public:
		Vector2(float x, float y) : x(x), y(y) {}	// 构造函数
		Vector2 Add(const Vector2 & other) {	// Add函数
			return Vector2(x + other,x, y + other.y);
		}
		Vector2 operator+(const Vector2 & other) {	// 重载操作符“+”
			return Vector2(x + other,x, y + other.y);
		}
};

Vector2 v1(1.1, 2.2);
Vector2 v2(3.3, 4.4);
Vector2 v3 = v1.Add(&v2); // 调用Add函数，进行加法运算
Vector2 v4 = v1 + v2;		   // 使用重载的操作符"+"，进行加法运算
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

P43 C++的对象生存期（栈作用域生存期）

class Entity {
	public:
		Entity() {
			std::cout << "Constured Entity!" << std::endl;
		}
		~Entity() {
			std::cout << "Constured Entity!" << std::endl;
		}
}

class ScopedPtr {
	private:
		Entity *m_Ptr;
	public:
		SscopedPtr(Entity *ptr) : m_Ptr(ptr){} // 构造函数
		~SscopedPtr(Entity *ptr) { // 析构函数
			delete m_Ptr;
		}
}

int main() {
	{
		ScopedPtr p = ScopedPtr(new Entity);	// 在该作用域内创建了局部变量p
	} // 作用域退出时，局部变量p被释放，自动调用析构函数，进而将使用new创建Entity释放。
	reutrn 0;
}
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
26

作用域指针（智能指针）：就是类对指针的包装。

P44 C++的智能指针

1.unique_ptr就是作用域指针。

• 作用：作用域结束后，在该作用域内定义的unique_ptr所指向的内存，会被自动释放。
• 注意：unique_ptr不能被复制。

#include 
class Entity {
}
int main()
{
	{
		// 初始化unique_ptr智能指针的两种方法
		std::unique_ptr e(new Entity);
		std::unique_ptr e2 = std::make_unique();	 // 推荐方式！
  	    std::unique_ptr e3 = e2; // 非法！
	} // 作用域退出时，e和e2被释放
}
1
2
3
4
5
6
7
8
9
10
11
12

2.shared_ptr共享指针。

• 实现方式：取决于编译器和标准库。通常基于引用计数实现。

#include 
class Entity {
}
int main()
{
	std::shared_ptr e3；
	{
		// 初始化shared_ptr智能指针的两种方法
		std::shared_ptr e(new Entity);
		std::shared_ptr e2 = std::make_shared();	 // 推荐方式！
  	    e3 = e2; // 合法！
	} // 作用域退出时，e被释放，e2没有被释放
}     // main函数退出时，e2被释放
1
2
3
4
5
6
7
8
9
10
11
12
13

3.weak_ptr弱指针。不会增加引用计数。

#include 
class Entity {
}
int main()
{
	std::weak_ptr e1；
	{
		std::shared_ptr e2 = std::make_shared();	 // 推荐方式！
  	    e31= e2; // 合法！但是不会增加e2的引用计数。
	} // 作用域退出时，e2没有被释放。此时e1指向无效的指针
} 
1
2
3
4
5
6
7
8
9
10
11

P45 C++的复制与拷贝构造函数

class String
{
	private:
		char *m_Buffer;
		unsigned int m_Size;
	public:
		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(const String& other)  // c++提供的默认拷贝构造函数的实现示例，是一个浅拷贝的实现
		//	: m_Buffer(other.m_Buff), m_Size(other.m_Size)
		//{
		//}

		// 禁用拷贝构造函数
		//String(const String& other) = delete;
		
		String(const String& other)  // 自定义深度拷贝的拷贝构造函数
			: m_Size(other.m_Size)
		{
			m_Buffer = new char[m_Size + 1];
			memcpy(m_Buffer, other.m_Buffer, m_Size);
			m_Buffer[m_Size] = 0;
		}
		
		~String() { // 析构函数
			delete[] m_Buffer;
		}

		// String类的"[]"操作符重载函数
		char& operator[](unsigned int index) {
			return m_Buffer[index];
		}
		
		// 通过friend关键字，声明友元函数，在该函数内可以访问String对象的私有成员。
		friend std::ostream& operator<<(std::ostream& stream, const String& string);
}

// String类的"<<"操作符重载函数
std::ostream& operator<<(std::ostream& stream, const String& string) {
	stream << string.m_Buffer;	// 直接访问私有成员，因为已经将该函数声明为了友元函数。
	return stream
}

int main() {
	String string = "Cherno";
	// 此处会调用String类的拷贝构造函数。C++提供默认拷贝构造函数，仅提供浅拷贝
	// 禁用拷贝构造函数后，该复制操作是非法的
	String second = string; 
	second[2] = 'a'; // 调用String类的"[]"操作符重载函数
	std::cin.get();
}

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
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57

结论：类对象作为函数参数时，尽量传递const引用，否则会调用拷贝构造函数。

P46 C++的箭头操作符（重载）

class Entity {
	public:
		void Print() {
			std::cout << "hello Entity!" << std::endl;
		}
}

class ScopePtr {
Private:
	Entity* m_Objl

public:
	ScopePtr(Entity* e) : m_Obj(e) {
	}
	~ScopePtr() {
		delete m_Obj;
	}
	Entity* GetObject() {
		return o_Obj;
	}
	// 重载了"->"操作符
	Entity* operator->() {
		return o_Obj;
	}
}

int main() {
	ScopePtr sp = new Entity();
	sp.GetObject()->Print();
	sp->Print(); // 该方式合法，因为->操作符被重载了
}
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
26
27
28
29
30
31

P47 C++中的动态数组 & P48 C++动态数组的优化

#include 
struct Vertex {
	float x, y, z;
}

// 为Vertex类型定义<<操作符的重载函数
std::ostream& operator<<(std::ostream& stream, const Vertex& vertex) {
	stream << vertex.x << " , " << vertex.y << " , " << vertex.zl
	return stream;
}

int main() {
	std::Vector vert;
	vert.push_back({1, 2, 3});	// 像动态数组vert中添加元素
	vert.push_back({4, 5, 6});

	// 遍历方式1
	for (int i = 0; i < vert.size(); i++) {
		std::cout << vert[i] <