全面讲解C++ - 技术栈

数据类型

1.1 基本数据类型

1.1.1 整型（Integer Types）

整型用于表示整数值，分为以下几种类型：

int：标准整数类型，通常为4字节（32位）。
short：短整型，通常为2字节（16位）。
long：长整型，通常为4字节（32位）或8字节（64位），依赖于系统。
long long：更长的整型，至少为8字节（64位）。

整型可以带符号（signed）或无符号（unsigned），如unsigned int表示无符号整数。

1.1.2 浮点型（Floating-Point Types）

浮点型用于表示带小数的数值，主要有：

float：单精度浮点型，通常为4字节（32位）。
double：双精度浮点型，通常为8字节（64位）。
long double：扩展精度浮点型，通常为8字节或16字节，具体依赖于编译器和平台。

1.1.3 字符型（Character Type）

字符型用于表示单个字符，使用char类型，通常为1字节（8位）。字符型可以是带符号或无符号：

|----------------------------------------------------------------------------|
| |

1.1.4 布尔型（Boolean Type）

布尔型用于表示逻辑值，只有两个值：true（真）和false（假）。

|----------------------------------------------------------------------------|
| |

1.1.5 空类型（Void Type）

void类型表示无类型，常用于函数的返回类型，表示函数不返回任何值。

|----------------------------------------------------------------------------|
| |

1.2 复杂数据类型

复杂数据类型是通过组合基本数据类型或其他复杂类型构建的，主要包括以下几种：

1.2.1 数组（Array）

数组是相同类型元素的集合，可以通过下标访问元素。数组的大小在定义时确定。

|----------------------------------------------------------------------------|
| |

1.2.2 结构体（Structures）

结构体用于将不同类型的数据组合在一起，方便管理和传递。

|----------------------------------------------------------------------------|
| |

1.2.3 类（Class）

类是C++的核心特性，支持封装、继承和多态，允许定义对象的属性和行为。

|----------------------------------------------------------------------------|
| |

1.2.4 联合体（Unions）

|----------------------------------------------------------------------------|
| |

1.2.5 枚举（Enumerations）

|----------------------------------------------------------------------------|
| |

1.2.6 指针（Pointers）

|----------------------------------------------------------------------------|
| |

1.2.7 字符串（Strings）

|----------------------------------------------------------------------------|
| |

1.3 总结

C++中的数据类型包括基本数据类型和复杂数据类型。基本数据类型用于表示简单的数值和字符，复杂数据类型则通过组合基本类型形成更复杂的结构。理解这些数据类型有助于高效地管理和操作数据，编写可读性强、维护性好的代码。

数组

C++中的数组使用于存储相同类型数据的固定大小的连续集合。它可以存储基本类型(如整数、浮点数、字符等)以及用户定义的类型(如结构体、类对象等)。接下来会对这些使用方式进行详细介绍：

2.1 数组的存储方式

****线性存储：****数组中的元素在内存中使连续存储的，也就是说，数组的每个元素占据的内存地址是相邻的。例如，假设数组中存储的是int类型的元素（每个元素占据4个字节），如果数组第一个元素的地址为A，那么第二个元素的地址为A + 4，依此类推。
****索引访问：****数组的元素可以通过索引访问，索引从0开始。例如，arr[0]是数组的第一个元素，arr[1]是第一个元素。

2.2 数组的声明和初始化

在C++中，声明数组时必须指定数组的大小(静态数组)或者使用动态内存分配(动态数组)。下面将会分类介绍以下静态数组 和动态数组。

2.2.1 静态数组

1. 声明

|---------------------------------------------------------------------------------------------|
| 图 2-2-1-1 静态数组声明 |

注意：数组的大小必须是编译时已知的整数常量。

2. 初始化

数组的初始化可以通过以下几种方式：

|-----------------------------------------------------------------------------------------------|
| 图 2-2-1-2 静态数组的初始化 |

2.2.2 动态数组

在C++中也可以使用动态内存分配来创建数组，特别是数组大小在运行时才确定的情况下。

|-------------------------------------------------------------------------------------------|
| 图 2-2-1-3 动态数组 |

注意：在动态数组的使用过程中，需要进行手动释放内存，否则会导致一些不好的事情发生，

2.3 数组的使用方法

数组的元素通过索引访问和操作，常见的操作有：

2.3.1 访问数组元素

在访问数组元素的时候可以通过索引进行访问，时间复杂度为O(1)，非常快捷：

|---------------------------------------------------------------------------------------------|
| 图 2-3-1-1 访问数组元素 |

2.3.2 修改数组元素

在修改数组元素的值的时候，也是通过索引进行访问，然后修改，和变量值的修改区别不大：

|---------------------------------------------------------------------------------------------|
| 图 2-3-2-1 修改数组元素 |

2.3.3 遍历数组

使用for循环或while循环来遍历数组中的每个元素：

|-------------------------------------------------------------------------------------------|
| 图 3-3-3-1 数组遍历 |

2.3.4 多维数组

C++支持多维数组，常见的多维数组为二维数组：

|-------------------------------------------------------------------------------------------|
| 图 3-3-4-1 多维数组 |

通常情况下，我们使用最多的就是一维数组/二维数组，三维数组极少使用。

2.4 注意事项

数组越界问题

数组索引必须在合法范围之内（0~size-1），否则会造成未定义行为（UB，Undefined Behavior）。访问或修改超出范围的元素可能导致程序崩溃 或数据损坏。

|-------------------------------------------------------------------------------------------|
| 图 3-4-1-1 数组越界 |

数组大小固定

静态数组的大小在声明时必须指定，并且在运行时无法更改。如果需要可变大小的数组，应该考虑使用动态数组（通过new分配）或STL中的容器（如std::vector）。

数组初始化

如果在声明时未显式初始化数组，数组中的元素会包含垃圾值。因此，建议初始化数组或手动将其所有元素值设为0。

int arr[5]= {0}; // 初始化数组元素全为0

动态数组的内存管理

在使用new动态分配数组时，务必在使用完后使用delete[]释放内存。放置内存泄露。

|------------------------------------------------------------------|
| int* arr = new int[100]; // ....一系列操作 //使用完成后 delete[] arr; |

多维数组内存布局

在C++中，多维数组实际上是线性内存中的一维数组。对于一个二维数组arr[2][3]，元素arr[1][2]实际上位于数组的一维地址arr[5]位置。因此在处理多为数组时要理解其内存中的线性布局。

std::array 和 std::vector

现代C++标准库提供了更安全和灵活的容器类。std::array提供了静态数组的替代品，它可以进行数组边界检查。std::vector时动态大小的数组，提供了更灵活的内存管理。

|----------------------------------------------------------------------------------------------|
| 图 3-4-1 array静态数组 |

2.5 总结

C++中的数组是一种基本的集合数据结构，提供高效的存储和访问方式。理解其内存布局，声明和初始化方法时高效使用数组的关键。在编写代码时要注意避免数组越界和内存泄露等问题。在现代C++开发的过程中，可以考虑使用STL容器（如std::vector）来代替传统数组，以获得更好的内存管理和灵活性。

3 指针和引用

C++继承于C，并对其进行了一些拓展和优化，其中最主要的就是类和对象。不过这里的讲解对象并不是它，而是指针和引用。

在最初学习指针的时候，会有很多人觉得指针比较困难，接下来会对两者进行一个简单的讲解：

C++中的指针和引用是两个重要的概念，特别是在内存管理、函数参数传递和对象操作方面起着关键作用。理解它们的区别、用法以及各自的优缺点，对编写高效的C++代码至关重要。接下来，我将详细讲解C++中的指针和引用，包括它们的定义、使用方法、区别、注意事项等。

3.1 指针

3.1.1 指针的定义

指针也是一个变量，不过它存储的是另一个变量的内存地址。通过地址，我们可以间接地访问 和修改其它变量的值。

指针的声明

声明指针时需要指明它所指向的变量类型，格式如下：

|---------------------------------------------------|
| type* pointerName; //type是需要声明的类型，比如说int、float等等 |

type：指针所指向的变量类型；
*：表示这是一个指针；
pointerName：指针变量的名字。

3.1.2 指针的使用

指针的主要用途是通过内存地址访问和操作变量。我们可以通过赋值操作让指针指向某个变量的地址，使用 & 符号获取变量的地址。

赋值指针

|-------------------------------------------------------------------------------------------|
| 图 3-1-2-1 赋值指针 |

访问指针指向的值

|-------------------------------------------------------------------------------------------|
| 图 3-1-2-2 访问指针 |

修改指针指向的值

通过指针不仅可以访问变量的值，还可以修改它。

|---------------------------------------------------------------------------------------------|
| 图 3-1-2-3 修改指针的值 |

3.1.3 常见操作

指针的自增和自减

当对指针进行自增(++)或自减(--)操作时，指针的地址会根据指针类型的大小进行移动。

|----------------------------------------------------------------------------|
| |

nullptr

C++11引入了nullptr表示空指针，替代传统的NULL。

|----------------------------------------------------------------------------|
| |

动态内存分配

使用指针可以动态分配和释放内存。

|----------------------------------------------------------------------------|
| |

3.1.4 指针的注意事项

指针的初始化

指针在声明后应尽量立即初始化，未初始化的指针可能指向任意内存，导致未定义行为。

指针的越界访问

在访问数组或动态分配的内存时，必须确保指针不会越界访问，否则可能导致崩溃或未定义行为。

内存泄露

动态分配内存之后，如果说没有使用delete函数，可能会导致内存泄漏，尤其是在大量动态分配的场景下。

3.2 引用

3.2.1 引用的定义

引用（Reference）是变量的别名，它本质上是一个已存在变量的另一个名字（相当于小名或昵称等等）。定义引用时需要使用 & 符号。引用必须在声明时初始化，并且初始化后不能改变所绑定的对象。

引用的声明

|----------------------------------------------------------------------------|
| |

type：引用所引用的变量的类型；
&"表示这是一个引用；
referenceName：引用变量的名字。

|----------------------------------------------------------------------------|
| |

3.2.2 引用的使用

通过引用，我们可以像操作原变量一样操作引用，引用总是与它引用的变量绑定在一起。引用常用于函数参数传递中，以避免传递的性能开销。

通过引用修改变量

|----------------------------------------------------------------------------|
| |

引用作为函数参数

引用常用于函数传递，避免值拷贝的开下奥，并允许在函数内部修改传入的参数。

|----------------------------------------------------------------------------|
| |

常量引用

常量引用(const引用)是指不能通过该引用修改其绑定的变量的值，常用于保护函数参数，防止修改传入的对象。

|----------------------------------------------------------------------------|
| |

3.2.3 引用的注意事项

必须初始化

引用在声明时必须立即初始化，不能指向空或未定义的变量。

|----------------------------------------------------------------------------|
| |

不能改变引用的绑定

一旦引用绑定到某个变量，无法更改其绑定对象。引用是不可重定向的。

|----------------------------------------------------------------------------|
| |

不能指向nullptr

与指针不同，引用是不能指向nullptr或不存在的对象。

3.3 指针与引用的比较

3.4 适用场景

指针：适合动态内存管理、数组操作、需要改变指向对象的场景。指针还可以做指针算数，如遍历数组。

引用：适合参数传递、返回值优化更安全且简介，但不具备指针的灵活性。

3.5 总结

C++中的指针和引用都是强大的工具，但它们是用于不同的场景。指针能够进行灵活的内存操作，可以通过动态内存分配和指针算数高效处理数据，但需要开发者严格管理内存，避免越界访问和内存泄漏。引用相对简单，常用于函数参数传递和返回值优化。选择使用指针还是引用取决于具体需求和场景。

结构体

C++中的结构体（struct）是一种用户自定义的数据类型，允许将不同类型的数据组合在一起。结构体广泛用于组织复杂的数据，更加清晰地表示现实世界中的实体。下面会对结构体的定义、初始化、使用方法和注意事项进行讲解：

4.1 结构体的定义

4.1.1 基本语法

结构体的定义使用struct关键字，格式如下：

|----------------------------------------------------------------------------|
| |

StructName：结构体的名称；
dataType：成员变量的类型。

4.1.2 示例

|----------------------------------------------------------------------------|
| |

4.2 结构体的使用

4.2.1 声明和初始化

结构体可以声明变量并初始化：

|----------------------------------------------------------------------------|
| |

也可以在声明时进行初始化：

|----------------------------------------------------------------------------|
| |

4.2.2 访问结构体成员

使用点（.）访问结构体的成员

|----------------------------------------------------------------------------|
| |

4.2.3 结构体数组

可以创建结构体的数组，以便管理多个相同类型的结构体：

|----------------------------------------------------------------------------|
| |

4.2.4 结构体作为函数参数

结构体可以作为函数的参数进行传递，可以通过值传递或引用传递：

|----------------------------------------------------------------------------|
| |

4.3 结构体的特点

可以包含不同类型的成员：
结构体可以包含啊多种数据类型的成员，例如：整数、字符串、读点书等等。
可以嵌套

结构体可以包含其它结构体作为成员。

|----------------------------------------------------------------------------|
| |

默认访问权限

结构体的成员默认是public，而类的成员默认是private。

可以定义构造函数

结构体可以像类一样定义构造函数、析构函数、成员函数等。

|----------------------------------------------------------------------------|
| |

4.4 注意事项

内存对齐

结构体的内存布局可能会受到对齐规则的影响，可能导致结构体的大小比其成员的总大小大。可以使用#pragma pack指令来控制对齐方式。

比较运算符

结构体默认不支持比较运算符，如果需要比较结构体实例，需要自自定义比较函数。

拷贝构造和赋值操作

结构体支持拷贝构造和赋值操作，但在有指针成员的情况下需要特别小心，避免浅拷贝问题。

4.5 总结

C++中的结构体是一个灵活且强大的工具，能将不同类型的数据组织在一起，方便管理和使用。结构体广泛用于数据建模、游戏开发、网络编程等场景。理解结构体的定义、使用和注意事项，对于高效编写C++代码是非常重要的。

5 类和对象

C++中的类（class）和对象（object）是面向对象编程（OOP）的核心概念，允许程序员通过封装数据和功能来创建复杂的程序。以下是面对C++类和对象的详细讲解，包括定义、使用方法、特性和注意事项。

5.1 类的定义

5.1.1 基本语法

类的定义使用class关键字，格式如下：

|----------------------------------------------------------------------------|
| |

ClassName：类的名称；
dataType：成员变量的数据类型；
public、private、protected：访问控制符，控制成员的可见性。

5.1.2 示例

|----------------------------------------------------------------------------|
| |

5.2 对象的创建与使用

5.2.1 创建对象

对象是类的实例，通过类定义的构造函数来初始化：

|----------------------------------------------------------------------------|
| |

5.2.2 访问对象的成员

使用点运算符（.）访问对象的成员变量和成员函数：

|----------------------------------------------------------------------------|
| |

5.2.3 类的数组

可以创建类对象的数组：

|----------------------------------------------------------------------------|
| |

5.3 类的特性

5.3.1 封装

类提供了封装的特性，可以将数据和操作数据的函数绑定在一起，同时控制访问权限。通过public、private和protected来控制成员的可见性。

public：可以外部访问；
private：外部不可访问，仅限类内部使用；
protected：外部不可访问，但是可以被派生类访问。

5.3.2 继承

C++支持继承，允许一个类（子类）从另一个类（基类）继承成员和功能：

|----------------------------------------------------------------------------|
| |

5.3.3 多态

C++支持多态性，允许通过基类指针或引用调用子类的函数。这通常通过虚函数实现：

|----------------------------------------------------------------------------|
| |

5.3.4 构造函数与析构函数

构造函数：用于初始化对象，可以重载；
析构函数：用于清理对象，当对象被销毁时自动调用。

|----------------------------------------------------------------------------|
| |

5.4 注意事项

内存管理

如果类使用动态内存（如通过new分配），则应在析构函数中释放内存，放置内存泄露。

拷贝构造和赋值操作

C++自动生成的拷贝构造函数和赋值操作符执行浅拷贝，可能导致问题。需要在有指针成员的类中自定义它们。

访问控制

合理使用访问控制符，以保护类的内部数据，确保数据的有效性。

5.5 总结

C++中的类和对象是面向对象编程的基础，允许开发者通过封装、继承和多态性来设计灵活、可扩展的代码。理解类和对象的定义、使用和特性，对于高效编写C++程序至关重要。在编写复杂程序时，合理地利用类和对象可以显著提高代码的可维护性和可读性。

6 函数

6.1 函数的定义

6.1.1 基本语法

函数的定义通常包括返回类型、函数名称、参数列表和函数体：

|----------------------------------------------------------------------------|
| |

returnType：函数返回值的类型，若无返回值则使用void；
functionName：函数名称，符合标志符命名规则；
parameterType和parameterName：参数的数据类型和名称。

6.1.2 示例

|----------------------------------------------------------------------------|
| |

6.2 函数的调用

6.2.1 调用函数

可以通过函数名称和参数列表调用函数：

|----------------------------------------------------------------------------|
| |

6.3 参数传递

6.3.1 值传递

默认情况下，C++使用值传递，将实参的副本传递给函数。

|----------------------------------------------------------------------------|
| |

6.3.2 引用传递

可以使用引用传递，允许在函数内直接修改实参的值。

|----------------------------------------------------------------------------|
| |

6.3.3 指针传递

可以通过指针传递参数，允许在函数内修改实参：

|----------------------------------------------------------------------------|
| |

6.4 返回值

6.4.1 返回单一值

函数可以返回一个值，使用return语句。

|----------------------------------------------------------------------------|
| |

6.4.2 返回多个值

通过结构体、std::tuple或引用参数返回多个值。

|----------------------------------------------------------------------------|
| |

6.5 函数重载

C++允许同一名称的函数具有不同的参数列表，称为函数重载。重载函数可以根据参数的类型和数量进行区分。

|----------------------------------------------------------------------------|
| |

6.6 内联函数

使用inline关键字可以定义内联函数，编译器会尝试在调用出替换函数体，以提高性能。

|----------------------------------------------------------------------------|
| |

6.7 注意事项

函数原型：在调用函数之前，可以使用函数原型声明函数的类型和参数，允许在源文件的其它位置定义函数。

|----------------------------------------------------------------------------|
| |

默认参数：可以为函数参数提供默认值，使得调用时可以省略某些参数。

|----------------------------------------------------------------------------|
| |

递归：函数可以调用自身，称为递归，需确保有终止条件以防无限递归。

|----------------------------------------------------------------------------|
| |

6.8 总结

C++中的函数是组织代码的重要工具，支持多种参数传递方式和返回值机制。理解函数的定义、调用和特性，对于编写可维护、可重用的代码至关重要。函数重载和内联函数的使用，可以有效提高程序的灵活性和性能。