C++基础教程（转载）

C++零基础入门教学（万字解析）

爱编程的鱼 于 2023-10-15 20:52:20 发布

C语言教程

一、C++语言是什么？

二、开发环境

三、初始C++语言

1.第一个C++语言程序

2.数据类型

2.1 数据类型的长度

3.变量和常量

3.1 变量

3.2 常量

4.字符串和转义字符

4.1 字符串的表示

4.2 转义字符

4.3 字符串操作

5.判断和选择语句

5.1 if语句

5.2 if-else语句

5.3 switch语句

5.4 逻辑运算符

6.循环

6.1 for循环

6.2 while循环

6.3 do-while循环

6.4 循环控制语句

7.函数

7.1 函数的定义和调用

7.2 函数的参数

7.3 函数的返回值

7.4 函数的重载

7.5 函数的声明

8.数组

8.1 数组的定义和初始化

8.2 数组的访问和修改

8.3 数组的循环访问

8.4 多维数组

8.5 数组的长度

8.6 字符串数组

9.操作符

9.1 算术操作符

9.2 赋值操作符

9.3 比较操作符

9.4 逻辑操作符

9.5 其他操作符

10.常见关键字

11.指针

11.1 指针的声明和初始化

11.2 指针的解引用

11.3 动态内存分配

11.4 空指针和空指针常量

11.5 指针和数组

12.结构体

12.1 结构体的定义

12.2 结构体的使用

12.3 结构体的初始化

12.4 结构体作为函数参数和返回值

12.5 结构体嵌套

四、总结

一、C++语言是什么？

C++是一种通用的高级编程语言，它是C语言的扩展和增强版本。C++于1983年由比雅尼·斯特劳斯特鲁普（Bjarne Stroustrup）创建，旨在提供更好的抽象能力和面向对象编程的支持。

C++具有以下特点：

1. 面向对象编程（OOP）：C++支持面向对象的编程范式，包括封装、继承和多态。这使得编写可重用、模块化和易于维护的代码成为可能。

2. 高效性：C++是一种编译型语言，它可以直接编译成机器码，因此执行效率较高。C++还提供了底层的内存管理和指针操作能力，使得对计算资源的控制更加精细。

3. 泛型编程：C++支持泛型编程，通过模板（templates）可以实现通用的算法和数据结构。这使得C++具有高度的灵活性和可扩展性。

4. 跨平台性：C++可以在多个操作系统上运行，包括Windows、Linux、Mac等。这使得C++成为开发跨平台应用程序的理想选择。

5. 大量的库支持：C++拥有丰富的标准库和第三方库，提供了各种功能和工具，可以简化开发过程并加快开发速度。

C++是一种功能强大、灵活且高效的编程语言，适用于广泛的应用领域，包括系统开发、游戏开发、嵌入式系统、科学计算等。对于初学者来说，学习C++可以打下良好的编程基础，并为进一步深入学习其他编程语言和领域奠定坚实的基础。

二、开发环境

在开始学习C++之前，你需要设置好适合C++开发的开发环境。以下是一些常用的C++开发环境选项：

1. 编辑器（Editor）：

   - Visual Studio Code（免费）：一个轻量级的开源编辑器，支持丰富的插件扩展，可以配置C++开发环境。

   - Sublime Text（付费）：一个流行的文本编辑器，具有强大的功能和插件生态系统，适合C++开发。

   - Atom（免费）：另一个开源的文本编辑器，具有可扩展的功能和插件，适合C++编程。

2. 集成开发环境（IDE）：

   - Visual Studio（付费）：由Microsoft开发的全功能IDE，提供了强大的调试器和其他辅助工具，适合Windows平台的C++开发。

   - CLion（付费）：JetBrains开发的专门针对C++开发的跨平台IDE，提供了智能代码补全、调试器等功能。

   - Code::Blocks（免费）：一个开源的跨平台C++集成开发环境，适合初学者使用。

3. 编译器（Compiler）：

   - GCC：GNU Compiler Collection的缩写，是一个广泛使用的开源编译器套件，支持多种平台。

   - Clang：一个开源的C++编译器，被认为是GCC的竞争对手，具有更快的编译速度和更好的错误信息。

选择适合自己的开发环境主要取决于个人喜好、操作系统和项目需求。对于初学者来说，一个轻量级的编辑器配合一个简单的编译器就足够了。随着你的学习和项目的复杂性增加，你可以考虑使用更强大的IDE。

在安装开发环境之后，确保你的开发环境配置正确并能够编译和运行C++代码。你可以创建一个简单的"Hello, World!"程序来测试你的环境是否正常工作。一旦你的环境设置好，你就可以开始学习C++的基本语法和概念了。

记住，选择一个适合自己的开发环境是非常重要的，因为它会对你的学习和开发体验产生影响。尽早熟悉并熟练使用你选择的开发环境，这将有助于你更高效地学习和编写C++代码。

三、初始C++语言

1.第一个C++语言程序

当你开始学习C++时，第一个程序通常是经典的"Hello, World!"程序。这个程序非常简单，但它可以帮助你了解C++的基本语法和编写过程。下面是一个示例：

#include <iostream>

int main() {

    std::cout << "Hello, World!" << std::endl;

    return 0;

}

让我们逐行解释这个程序：

1. `#include <iostream>`：这是一个预处理指令，它告诉编译器引入`iostream`库，这个库包含了输入和输出的功能。

2. `int main()`：这是C++程序的入口点。`main`函数是每个C++程序必须有的函数，程序从这里开始执行。

3. `{` 和 `}`：这是代码块的开始和结束。所有在`main`函数内的代码都应该放在这对花括号之间。

4. `std::cout`：这是一个输出流对象，用于将文本输出到控制台。

5. `<<`：这是一个输出运算符，用于将文本或其他数据插入到输出流中。

6. `"Hello, World!"`：这是要输出的文本。你可以将其替换为任何你想要输出的内容。

7. `std::endl`：这是一个特殊的控制字符，表示换行并刷新输出流。

8. `return 0;`：这是`main`函数的结束语句，并且将0作为程序的返回值。

要运行这个程序，你需要将代码保存在以`.cpp`为扩展名的文件中，比如`hello.cpp`。然后，使用你选择的编译器将其编译为可执行文件。

在命令行中，你可以使用以下命令来编译和运行程序（以GCC编译器为例）：

g++ hello.cpp -o hello

./hello

第一条命令将源代码文件`hello.cpp`编译为可执行文件`hello`。第二条命令运行该可执行文件，并在控制台输出"Hello, World!"。

这是一个简单的C++程序示例，希望能帮助你开始入门C++编程。从这里开始，你可以逐渐学习和掌握更多的C++语法和概念。

2.数据类型

在C++中，数据类型用于定义变量的类型和内存占用大小。C++提供了多种内置的数据类型，包括整数、浮点数、字符和布尔值等。在本节中，我们将介绍C++中常用的数据类型。

1. 整数类型（Integer Types）：

   - `int`：用于表示整数，通常占用4个字节。

   - `short`：用于表示短整数，通常占用2个字节。

   - `long`：用于表示长整数，通常占用4个字节或8个字节。

   - `long long`：用于表示更长的整数，通常占用8个字节。

2. 浮点数类型（Floating-Point Types）：

   - `float`：用于表示单精度浮点数，通常占用4个字节。

   - `double`：用于表示双精度浮点数，通常占用8个字节。

   - `long double`：用于表示更高精度的浮点数，占用字节数因实现而异。

3. 字符类型（Character Types）：

   - `char`：用于表示单个字符，通常占用1个字节。

   - `wchar_t`：用于表示宽字符，通常占用2个字节。

   - `char16_t`：用于表示UTF-16编码的字符，通常占用2个字节。

   - `char32_t`：用于表示UTF-32编码的字符，通常占用4个字节。

4. 布尔类型（Boolean Type）：

   - `bool`：用于表示布尔值，只能取`true`或`false`两个值。

此外，C++还提供了其他一些数据类型，如指针类型、数组类型和结构体类型等。你可以根据具体的需求选择合适的数据类型。

在C++中，你可以使用关键字`sizeof`来获取某个数据类型的大小（以字节为单位）。例如，`sizeof(int)`将返回`4`，表示`int`类型占用4个字节。

你可以使用以下语法来声明和初始化变量：

<数据类型> <变量名> = <初始值>;

例如：

int age = 20;

double pi = 3.14159;

char grade = 'A';

bool isPassed = true;

这些是C++中常见的数据类型和变量声明的基本知识。掌握这些概念后，你可以开始使用变量来存储和操作不同类型的数据。在后续的学习中，你将学习更多关于数据类型的内容，包括类型转换、运算符和表达式等。

2.1 数据类型的长度

在C++编程中，了解数据类型的长度是非常重要的。不同的数据类型在内存中占据的空间大小是不同的，这会直接影响到程序的性能和内存的使用。

以下是一些常见的数据类型及其长度：

整型数据类型：

char： 1字节（8位）

bool:  1字节（8位）

short：2字节（16位）

int：4字节（32位）

long：4字节或8字节（32位或64位）

long long：8字节（64位）

浮点型数据类型：

float：4字节（32位）

double：8字节（64位）

布尔型数据类型：

bool：通常占用1字节，但实际上只使用其中的1位

字符串类型：

char[] 或 char*：根据字符串长度而定，每个字符占用1字节

请注意，上述长度是一般情况下的标准长度，不同的编译器和操作系统可能会有所差异。此外，还有一些特殊的数据类型，如指针类型、数组类型等，它们的长度也需要根据具体情况来确定。

在编写程序时，了解数据类型的长度有助于合理地选择合适的数据类型，避免浪费内存空间。例如，如果你知道某个变量的取值范围不会超过-128到127之间，那么可以使用char类型来存储它，而不是使用int类型，这样可以节省3个字节的内存空间。

另外，了解数据类型的长度还有助于避免数据溢出的问题。如果你使用一个长度为2字节的short类型来存储一个超过其取值范围的数值，就会发生溢出，导致结果不正确。

总结起来，掌握数据类型的长度是编程中的基础知识，它对于正确选择数据类型、优化程序性能和避免溢出等方面都起着重要的作用。因此，在学习C++编程的过程中，务必要仔细学习和理解各种数据类型及其长度。

3.变量和常量

在C++编程中，变量和常量是非常重要的概念。它们用于存储和表示程序中的数据。

3.1 变量

变量是用于存储和表示数据的一种命名内存区域。在使用变量之前，需要先声明变量并指定其类型。C++中的变量有以下几个基本要素：

变量名：用于唯一标识变量的名称。变量名必须遵循一定的命名规则，如以字母或下划线开头，只能包含字母、数字和下划线等。

变量类型：指定变量存储的数据类型，如整型、浮点型、字符型等。

变量值：存储在变量中的实际数据。

以下是一些示例：

int age; // 声明一个名为age的整型变量

double salary; // 声明一个名为salary的浮点型变量

char grade; // 声明一个名为grade的字符型变量

// 给变量赋值

age = 18;

salary = 5000.50;

grade = 'A';

在C++中，还可以在声明变量的同时进行初始化：

int score = 90;        // 声明一个名为score的整型变量，并将其初始化为90

变量的值可以随时被修改：

score = 95;              // 修改score的值为95

3.2 常量

常量是指在程序中固定不变的值。与变量不同，常量的值在定义后不能被修改。在C++中，有两种常量类型：

字面常量：直接在代码中写入的常量值，如整数常量、浮点数常量、字符常量等。例如：

int num = 10;                    // 整数常量

double pi = 3.14;     // 浮点数常量

char ch = 'A';            // 字符常量

常量变量：通过关键字const定义的常量。常量变量在定义时必须进行初始化，并且不能再修改其值。例如：

const int MAX_VALUE = 100;     // 定义一个名为MAX_VALUE的常量变量，值为100

常量的使用可以提高程序的可读性和维护性，同时还可以防止意外的数据修改。

总结起来，变量和常量是C++编程中不可或缺的基本概念。通过合理使用变量和常量，我们可以存储和操作程序中的数据。在学习C++编程的过程中，要熟悉变量的声明、赋值和修改，以及常量的定义和使用。

4.字符串和转义字符

在C++编程中，字符串是一种常用的数据类型，用于表示一串字符。C++提供了一些特殊的语法和函数来处理字符串。

4.1 字符串的表示

在C++中，字符串可以用字符数组（char[]）或字符指针（char*）来表示。字符串以空字符（\0）作为结束符，标志字符串的结束。

以下是一些字符串的表示方式的示例：

char str1[] = "Hello";              // 使用字符数组表示字符串

char* str2 = "World";             // 使用字符指针表示字符串

在C++中，还可以使用string类来表示字符串，它是C++标准库中提供的字符串类，需要包含头文件<string>。

#include <string>

using namespace std;

string str3 = "Hello World";           // 使用string类表示字符串,已经使用了std,也可省略

4.2 转义字符

转义字符是一种特殊的字符序列，用于表示一些特殊的字符或控制字符。在C++中，转义字符以反斜杠（\）开头，后面跟着一个或多个字符。

以下是一些常见的转义字符及其含义：

\n：换行符

\t：制表符

\"：双引号

\'：单引号

\\：反斜杠

例如，要在字符串中插入一个换行符，可以使用转义字符\n：

cout << "Hello\nWorld";       // 输出两行：Hello 和 World

如果要在字符串中插入一个双引号，可以使用转义字符\"：

cout << "He said, \"Hello!\""; // 输出：He said, "Hello!"

4.3 字符串操作

在C++中，还有许多用于操作字符串的函数和操作符。以下是一些常用的字符串操作：

strlen(str)：返回字符串的长度（不包括结束符\0）。

strcpy(dest, src)：将源字符串拷贝到目标字符串。

strcat(dest, src)：将源字符串连接到目标字符串的末尾。

strcmp(str1, str2)：比较两个字符串的大小关系。

substr(pos, len)：返回从指定位置开始的指定长度的子字符串。

示例：

#include <cstring>                  // 包含字符串操作函数的头文件

using namespace std;

char str1[] = "Hello";

char str2[10];

strlen(str1);                      // 返回 5

strcpy(str2, str1);            // 将 str1 拷贝到 str2

strcat(str1, " World");    // 将 " World" 连接到 str1 的末尾

strcmp(str1, str2);                   // 比较 str1 和 str2 的大小关系

string str3 = "Hello World";

str3.substr(6, 5);             // 返回 "World"

总结起来，字符串和转义字符是C++编程中常用的概念。了解字符串的表示方式、转义字符的使用和常见的字符串操作函数，可以帮助你处理和操作字符串数据。

5.判断和选择语句

在C++编程中，判断和选择语句用于根据条件执行不同的代码块。C++提供了几种常用的判断和选择语句，包括if语句、if-else语句、switch语句等。

5.1 if语句

if语句用于根据条件执行不同的代码块。它的基本语法如下：

if (condition) {

    // 如果条件为真，执行这里的代码

}

如果条件为真，则执行if语句块中的代码；否则，跳过该代码块。

以下是一个示例：

int age = 18;

if (age >= 18) {

    cout << "You are an adult." << endl;

}

在上面的示例中，如果age大于等于18，则输出"You are an adult."。

5.2 if-else语句

if-else语句用于在条件为真和条件为假时执行不同的代码块。它的基本语法如下：

if (condition) {

    // 如果条件为真，执行这里的代码

} else {

    // 如果条件为假，执行这里的代码

}

如果条件为真，则执行if语句块中的代码；否则，执行else语句块中的代码。

以下是一个示例：

int age = 16;

if (age >= 18) {

    cout << "You are an adult." << endl;

} else {

    cout << "You are a teenager." << endl;

}

在上面的示例中，如果age大于等于18，则输出"You are an adult."；否则，输出"You are a teenager."。

5.3 switch语句

switch语句用于根据不同的条件执行不同的代码块。它的基本语法如下：

switch (expression) {

    case value1:

        // 如果 expression 等于 value1，执行这里的代码

        break;

    case value2:

        // 如果 expression 等于 value2，执行这里的代码

        break;

             // 可以有更多的 case

    default:

        // 如果 expression 不等于任何一个 case 的值，执行这里的代码

        break;

}

switch语句根据expression的值来匹配不同的case，并执行相应的代码块。如果expression不等于任何一个case的值，则执行default代码块。

以下是一个示例：

int day = 3;

switch (day) {

    case 1:

        cout << "Monday" << endl;

        break;

    case 2:

        cout << "Tuesday" << endl;

        break;

    case 3:

        cout << "Wednesday" << endl;

        break;

    default:

        cout << "Invalid day" << endl;

        break;

}

在上面的示例中，根据day的值，输出相应的星期几。如果day等于3，则输出"Wednesday"。

5.4 逻辑运算符

在判断和选择语句中，经常会用到逻辑运算符来组合多个条件。C++提供了三个常用的逻辑运算符：

&&：与运算符，表示两个条件都为真时整个表达式为真。

||：或运算符，表示两个条件中至少有一个为真时整个表达式为真。

!：非运算符，表示对条件的取反。

以下是一个示例：

int age = 20;

bool isStudent = true;

if (age >= 18 && isStudent) {

    cout << "You are an adult student." << endl;

}

在上面的示例中，如果age大于等于18且isStudent为真，则输出"You are an adult student."。

总结起来，判断和选择语句是C++编程中常用的控制结构，用于根据条件执行不同的代码块。通过if语句、if-else语句和switch语句，可以灵活地控制程序的执行流程。同时，逻辑运算符可以帮助我们组合多个条件，实现更复杂的判断。

6.循环

在C++编程中，循环结构用于重复执行一段代码，直到满足退出条件。C++提供了几种常用的循环结构，包括for循环、while循环和do-while循环。

6.1 for循环

for循环是一种常用的循环结构，用于指定循环的初始条件、循环条件和循环迭代。它的基本语法如下：

for (initialization; condition; iteration) {

    // 循环体

}

initialization：循环初始条件，在循环开始前执行一次。

condition：  循环条件，每次循环开始前检查该条件，如果为真则执行循环体，否则退出循环。

iteration：   循环迭代，每次循环结束后执行一次。

以下是一个示例：

for (int i = 1; i <= 5; i++) {

    cout << i << " ";

}

在上面的示例中，循环从i的初始值1开始，每次循环增加1，直到i的值大于5为止。循环体中的代码输出i的值，并在每次循环结束后输出一个空格。

输出结果为：1 2 3 4 5

6.2 while循环

while循环用于在满足条件时重复执行一段代码。它的基本语法如下：

while (condition) {

    // 循环体

}

在每次循环开始前，检查condition的值。如果为真，则执行循环体，否则退出循环。

以下是一个示例：

int i = 1;

while (i <= 5) {

    cout << i << " ";

    i++;

}

在上面的示例中，循环从i的初始值1开始，每次循环增加1，直到i的值大于5为止。循环体中的代码输出i的值，并在每次循环结束后输出一个空格。

输出结果为：1 2 3 4 5

6.3 do-while循环

do-while循环是一种先执行循环体，再检查条件的循环结构。它的基本语法如下：

do {

    // 循环体

} while (condition);

先执行循环体中的代码，然后检查condition的值。如果为真，则继续执行循环体，否则退出循环。

以下是一个示例：

int i = 1;

do {

    cout << i << " ";

    i++;

} while (i <= 5);

在上面的示例中，循环从i的初始值1开始，每次循环增加1，直到i的值大于5为止。循环体中的代码输出i的值，并在每次循环结束后输出一个空格。

输出结果为：1 2 3 4 5

6.4 循环控制语句

在循环中，可以使用循环控制语句来控制循环的执行流程。

break语句用于立即退出当前循环。

continue语句用于跳过当前循环中剩余的代码，进入下一次循环。

以下是一个示例：

for (int i = 1; i <= 5; i++) {

    if (i == 3) {

        break;             // 当 i 等于 3 时退出循环

    }

    cout << i << " ";

}

在上面的示例中，当i等于3时，执行break语句退出循环。因此，输出结果为：1 2

for (int i = 1; i <= 5; i++) {

    if (i == 3) {

        continue;       // 当 i 等于 3 时跳过剩余代码，进入下一次循环

    }

    cout << i << " ";

}

在上面的示例中，当i等于3时，执行continue语句跳过剩余的代码，进入下一次循环。因此，输出结果为：1 2 4 5

总结起来，循环是C++编程中常用的控制结构，用于重复执行一段代码。通过for循环、while循环和do-while循环，可以根据不同的需求选择合适的循环结构。同时，循环控制语句可以帮助我们控制循环的执行流程。

7.函数

在C++编程中，函数用于封装可重用的代码块，可以提高代码的可读性和可维护性。C++中的函数由函数头和函数体组成，可以接受参数并返回值。

7.1 函数的定义和调用

函数的定义包括函数头和函数体。函数头指定函数的返回类型、函数名和参数列表。函数体包含函数的具体实现。

以下是一个示例：

// 函数的定义

int add(int a, int b) {

    int sum = a + b;

    return sum;

}

// 函数的调用

int result = add(3, 5);

在上面的示例中，add函数接受两个整数参数a和b，计算它们的和，并将结果返回。在函数调用时，传递参数3和5，将返回值赋给result变量。

7.2 函数的参数

函数的参数用于接受传递给函数的数据。C++中的函数可以有零个或多个参数，参数之间用逗号分隔。

以下是一个示例：

int multiply(int a, int b) {

    int product = a * b;

    return product;

}

int result = multiply(3, 5);

在上面的示例中，multiply函数接受两个整数参数a和b，计算它们的乘积，并将结果返回。

7.3 函数的返回值

函数的返回值用于将函数的计算结果返回给调用者。在函数定义中，可以指定函数的返回类型。如果函数没有返回值，可以使用void作为返回类型。

以下是一个示例：

int square(int x) {

    int result = x * x;

    return result;

}

void printMessage() {

    cout << "Hello, World!" << endl;

}

int squaredValue = square(5);

printMessage();

在上面的示例中，square函数接受一个整数参数x，计算它的平方，并将结果返回。printMessage函数没有返回值，使用void作为返回类型。

7.4 函数的重载

函数的重载是指在同一个作用域内定义多个同名函数，但它们的参数列表不同。C++中的函数可以根据参数的类型、个数或顺序进行重载。

以下是一个示例：

int add(int a, int b) {

    return a + b;

}

double add(double a, double b) {

    return a + b;

}

int sum = add(3, 5);

double total = add(3.5, 2.7);

在上面的示例中，定义了两个名为add的函数，一个接受两个整数参数，另一个接受两个浮点数参数。根据参数的类型不同，编译器会选择合适的函数进行调用。

7.5 函数的声明

函数的声明用于告诉编译器函数的存在和函数的签名（返回类型、函数名和参数列表）。函数的声明通常放在函数调用之前，可以放在全局作用域或其他函数内部。

以下是一个示例：

// 函数的声明

int multiply(int a, int b);

int main() {

    int result = multiply(3, 5);

    return 0;

}

// 函数的定义

int multiply(int a, int b) {

    int product = a * b;

    return product;

}

在上面的示例中，先声明了multiply函数，然后在main函数中调用了该函数。最后，在代码的末尾定义了multiply函数的具体实现。

函数的声明可以将函数的定义放在函数调用之后，这样可以避免在函数调用之前出现未知的函数名。

总结起来，函数是C++编程中重要的组织代码的工具。通过函数，可以将代码模块化、可重用，并提高代码的可读性和可维护性。函数可以接受参数和返回值，并可以根据需要进行重载。函数的声明可以在函数调用之前告诉编译器函数的存在和函数的签名。

8.数组

在C++编程中，数组是一种用于存储多个相同类型的数据的数据结构。数组可以按照索引访问和修改其中的元素，提供了一种便捷的方式来处理一组数据。

8.1 数组的定义和初始化

数组的定义需要指定元素的类型和数组的名称，并可以指定数组的大小。

以下是一个示例：

// 声明一个整型数组

int numbers[5];

// 声明一个字符型数组并初始化

char vowels[] = {'a', 'e', 'i', 'o', 'u'};

在上面的示例中，声明了一个整型数组numbers，它有5个元素。另外，声明了一个字符型数组vowels，并使用大括号初始化了数组的元素。

8.2 数组的访问和修改

数组的元素可以通过索引访问和修改。数组的索引从0开始，到数组大小减1结束。

以下是一个示例：

int numbers[] = {1, 2, 3, 4, 5};

// 访问数组的元素

int firstNumber = numbers[0];      // 第一个元素

int thirdNumber = numbers[2];     // 第三个元素

// 修改数组的元素

numbers[1] = 10; // 修改第二个元素的值为10

在上面的示例中，定义了一个整型数组numbers，并初始化了数组的元素。通过索引可以访问数组的元素，也可以使用索引修改数组的元素。

8.3 数组的循环访问

可以使用循环结构来遍历数组的所有元素，进行一系列的操作。

以下是一个示例：

int numbers[] = {1, 2, 3, 4, 5};

// 使用for循环遍历数组并输出元素

for (int i = 0; i < 5; i++) {

    cout << numbers[i] << " ";

}

在上面的示例中，使用for循环遍历整型数组numbers的所有元素，并输出每个元素的值。

输出结果为：1 2 3 4 5

8.4 多维数组

除了一维数组，C++还支持多维数组，也称为矩阵或二维数组。多维数组是一种表格状的数据结构，可以按行和列访问其中的元素。

以下是一个示例：

int matrix[3][3] = {

    {1, 2, 3},

    {4, 5, 6},

    {7, 8, 9}

};

// 访问多维数组的元素

int element = matrix[1][2]; // 第二行第三列的元素

在上面的示例中，定义了一个3x3的整型多维数组matrix，并初始化了数组的元素。可以使用两个索引访问多维数组的元素。

8.5 数组的长度

在C++中，可以使用sizeof运算符获取数组的长度（以字节为单位）。

以下是一个示例：

int numbers[] = {1, 2, 3, 4, 5};

int length = sizeof(numbers) / sizeof(numbers[0]);

在上面的示例中，使用sizeof运算符获取整型数组numbers的总字节数，然后除以单个元素的字节数，得到数组的长度。

8.6 字符串数组

字符串数组是一种特殊的数组，用于存储多个字符串。在C++中，字符串可以用字符数组表示，以空字符（'\0'）作为字符串的结束标志。

以下是一个示例：

char names[][10] = {

    "Alice",

    "Bob",

    "Charlie"

};

// 访问字符串数组的元素

char* first = names[0];                   // 第一个字符串

char* second = names[1];   // 第二个字符串

在上面的示例中，定义了一个字符型字符串数组names，并初始化了数组的元素。可以使用索引访问字符串数组的元素，每个元素是一个字符数组（字符串）。

总结起来，数组是C++编程中常用的数据结构，用于存储多个相同类型的数据。通过索引可以访问和修改数组的元素，可以使用循环结构遍历数组的所有元素。C++还支持多维数组和字符串数组。使用sizeof运算符可以获取数组的长度。

9.操作符

在C++编程中，操作符是用于进行各种操作和计算的符号。C++提供了丰富的操作符，包括算术操作符、赋值操作符、比较操作符、逻辑操作符等，用于处理不同类型的数据。

9.1 算术操作符

算术操作符用于进行基本的数学运算，如加法、减法、乘法、除法等。

以下是一些常见的算术操作符：

加法：+

减法：-

乘法：*

除法：/

取模（取余数）：%

int a = 5;

int b = 3;

int sum = a + b;               // 加法

int difference = a - b;     // 减法

int product = a * b;        // 乘法

int quotient = a / b;        // 除法

int remainder = a % b;  // 取模

在上面的示例中，使用了不同的算术操作符对变量进行数学运算，并将结果赋值给另一个变量。

9.2 赋值操作符

赋值操作符用于将一个值赋给变量。

以下是一些常见的赋值操作符：

简单赋值：=

加法赋值：+=

减法赋值：-=

乘法赋值：*=

除法赋值：/=

int a = 5;

int b = 3;

a = b;      // 简单赋值

a += b;    // 加法赋值

a -= b;     // 减法赋值

a *= b;    // 乘法赋值

a /= b;     // 除法赋值

在上面的示例中，使用了不同的赋值操作符将一个值赋给变量，并进行相应的操作。

9.3 比较操作符

比较操作符用于比较两个值的大小关系，并返回布尔值（true或false）。

以下是一些常见的比较操作符：

相等：==

不相等：!=

大于：>

小于：<

大于等于：>=

小于等于：<=

int a = 5;

int b = 3;

bool isEqual = (a == b);                    // 相等

bool isNotEqual = (a != b);             // 不相等

bool isGreater = (a > b);             // 大于

bool isLess = (a < b);                          // 小于

bool isGreaterOrEqual = (a >= b);  // 大于等于

bool isLessOrEqual = (a <= b);     // 小于等于

在上面的示例中，使用了不同的比较操作符比较两个值的大小关系，并将结果赋给布尔变量。

9.4 逻辑操作符

逻辑操作符用于对布尔值进行逻辑运算，如与、或、非等。

以下是一些常见的逻辑操作符：

逻辑与：&&

逻辑或：||

逻辑非：!

bool a = true;

bool b = false;

bool result1 = (a && b); // 逻辑与

bool result2 = (a || b); // 逻辑或

bool result3 = !a; // 逻辑非

在上面的示例中，使用了不同的逻辑操作符对布尔值进行逻辑运算，并将结果赋给布尔变量。

9.5 其他操作符

除了上述常见的操作符，C++还提供了其他一些特殊的操作符，如条件操作符、成员访问操作符、指针操作符等。这些操作符的使用需要根据具体的场景和需求进行学习和掌握。

总结起来，操作符是C++编程中用于进行各种操作和计算的符号。C++提供了丰富的操作符，包括算术操作符、赋值操作符、比较操作符、逻辑操作符等。通过合理使用操作符，可以进行数学运算、赋值操作、比较大小和逻辑运算等。

10.常见关键字

在C++编程中，关键字是具有特殊含义的保留字，用于标识语言的各种元素，如变量、函数、类等。关键字在编程中具有特殊的语法和语义，不能作为标识符（变量名、函数名等）使用。

下面是一些常见的C++关键字：

auto：用于自动推导变量的类型。

break：用于跳出循环或开关语句。

case：用于开关语句中的分支。

char：用于声明字符类型。

const：用于声明常量，表示变量的值不可修改。

continue：用于终止当前循环的迭代，进入下一次迭代。

default：用于开关语句中的默认分支。

do：用于循环执行一段代码。

double：用于声明双精度浮点数类型。

else：用于条件语句中的否定分支。

enum：用于声明枚举类型。

extern：用于声明外部变量或函数。

float：用于声明浮点数类型。

for：用于循环执行一段代码。

if：用于条件判断。

int：用于声明整数类型。

long：用于声明长整数类型。

return：用于从函数中返回值。

short：用于声明短整数类型。

signed：用于声明有符号数类型。

sizeof：用于获取变量或类型的大小。

static：用于声明静态变量或函数。

struct：用于声明结构体类型。

switch：用于多分支选择。

typedef：用于定义类型别名。

unsigned：用于声明无符号数类型。

void：用于声明无返回值或不带参数的函数。

volatile：用于声明易变变量。

这些关键字具有特定的语法和语义，用于在C++程序中表示不同的概念和操作。在编程中，应避免将关键字作为标识符使用，以免造成语法错误。

总结起来，关键字是C++编程中具有特殊含义的保留字，用于标识语言的各种元素。常见的关键字包括auto、break、case、char、const、continue、default、do、double、else、enum、extern、float、for、if、int、long、return、short、signed、sizeof、static、struct、switch、typedef、unsigned、void和volatile等。

11.指针

指针是C++中非常重要的概念，它用于存储变量的地址。通过指针，我们可以间接地访问和操作变量，这在编程中非常有用。

11.1 指针的声明和初始化

在C++中，可以通过以下方式声明指针变量：

type* pointerName;

其中，type表示指针指向的数据类型，pointerName是指针变量的名称。

要将指针初始化为特定的地址，可以使用以下方式：

type* pointerName = &variable;

其中，variable是一个已经定义的变量，&操作符用于获取变量的地址。

以下是一个示例：

int* ptr;           // 声明一个整数类型的指针变量

int num = 5;  // 定义一个整数变量

ptr = &num;  // 将指针初始化为变量num的地址

在上面的示例中，我们声明了一个整数类型的指针变量ptr，并将其初始化为变量num的地址。

11.2 指针的解引用

指针的解引用操作允许我们访问指针所指向的变量。通过解引用操作符*，可以获取指针指向的值。

以下是一个示例：

int* ptr;    // 声明一个整数类型的指针变量

int num = 5; // 定义一个整数变量

ptr = &num; // 将指针初始化为变量num的地址

int value = *ptr; // 解引用指针，获取指针所指向的值

在上面的示例中，通过解引用操作符*，我们获取了指针ptr所指向的值，并将其赋给变量value。

11.3 动态内存分配

C++中的动态内存分配允许我们在程序运行时动态地分配和释放内存。new操作符用于动态分配内存，delete操作符用于释放动态分配的内存。(C语言使用malloc和free分配与释放动态内存)

以下是一个示例：

int* ptr = new int;          // 动态分配一个整数类型的内存空间

*ptr = 10;                         // 对动态分配的内存进行赋值

// 使用动态分配的内存

delete ptr;                        // 释放动态分配的内存

在上面的示例中，通过new操作符动态分配了一个整数类型的内存空间，并将其地址赋给指针ptr。然后，我们对动态分配的内存进行赋值和使用。最后，通过delete操作符释放了动态分配的内存。

需要注意的是，使用动态内存分配后，必须记得及时释放内存，以避免内存泄漏问题。

11.4 空指针和空指针常量

空指针是指未指向任何有效对象或函数的指针。在C++中，可以使用空指针来表示一个无效的指针。

要声明一个空指针，可以使用以下方式：

type* pointerName = nullptr;

其中，type是指针指向的数据类型，pointerName是指针变量的名称。

空指针常量nullptr是C++11引入的，用于表示空指针。

以下是一个示例：

int* ptr = nullptr; // 声明一个空指针

在上面的示例中，我们声明了一个整数类型的空指针变量ptr。

11.5 指针和数组

指针和数组在C++中有着紧密的关系。数组名本身可以视为指向数组第一个元素的指针。

以下是一个示例：

int arr[5] = {1, 2, 3, 4, 5};      // 声明并初始化一个整数数组

int* ptr = arr;                                    // 将数组名赋给指针变量

// 使用指针访问数组元素

int firstElement = *ptr;            // 获取数组第一个元素的值

int thirdElement = *(ptr + 2); // 获取数组第三个元素的值

在上面的示例中，我们声明并初始化了一个整数数组arr，然后将数组名赋给指针变量ptr。通过指针，我们可以访问数组元素，使用解引用操作符*获取数组元素的值。

总结起来，指针是C++中非常重要的概念，用于存储变量的地址。通过指针，我们可以间接地访问和操作变量。在C++中，可以使用指针的声明和初始化、解引用、动态内存分配、空指针和指针与数组等特性。合理地使用指针可以提高程序的灵活性和效率。

12.结构体

结构体是C++中一种自定义的数据类型，它允许我们将不同类型的数据组合在一起，形成一个新的数据类型。结构体可以用于表示具有相关属性的实体，比如人员信息、学生信息等。

12.1 结构体的定义

在C++中，可以使用struct关键字定义结构体。结构体定义的一般形式如下：

struct StructName {

    type1 member1;

    type2 member2;

    // ...

};

其中，StructName是结构体的名称，type1、type2等是成员变量的类型，member1、member2等是成员变量的名称。

以下是一个示例：

struct Person {

    std::string name;

    int age;

    float height;

};

在上面的示例中，我们定义了一个名为Person的结构体，它包含了三个成员变量：name（姓名，字符串类型）、age（年龄，整数类型）和height（身高，浮点数类型）。

12.2 结构体的使用

定义结构体后，我们可以声明结构体类型的变量，并使用成员运算符.来访问结构体的成员变量。

以下是一个示例：

Person person1;    // 声明一个Person类型的变量person1

// 访问结构体的成员变量

person1.name = "John";

person1.age = 25;

person1.height = 1.75;

// 输出结构体的成员变量

std::cout << "Name: " << person1.name << std::endl;

std::cout << "Age: " << person1.age << std::endl;

std::cout << "Height: " << person1.height << std::endl;

在上面的示例中，我们声明了一个Person类型的变量person1，并使用成员运算符.来访问和赋值结构体的成员变量。最后，通过输出语句将结构体的成员变量打印出来。

12.3 结构体的初始化

可以使用花括号初始化器或赋值语句对结构体进行初始化。

以下是两种初始化结构体的方式：

Person person1 = {"John", 25, 1.75};   // 使用花括号初始化器

Person person2;                                   // 声明一个Person类型的变量person2

person2 = {"Alice", 30, 1.65};            // 使用赋值语句进行初始化

在上面的示例中，我们使用花括号初始化器和赋值语句分别对结构体进行了初始化。

12.4 结构体作为函数参数和返回值

结构体可以作为函数的参数和返回值，以便传递和操作结构体类型的数据。

以下是一个示例：

Person createPerson(std::string name, int age, float height) {

    Person person;

    person.name = name;

    person.age = age;

    person.height = height;

    return person;

}

void printPerson(const Person& person) {

    std::cout << "Name: " << person.name << std::endl;

    std::cout << "Age: " << person.age << std::endl;

    std::cout << "Height: " << person.height << std::endl;

}

int main() {

    Person person = createPerson("John", 25, 1.75);

    printPerson(person);

    return 0;

}

在上面的示例中，我们定义了一个createPerson函数，用于创建一个Person类型的结构体并返回。我们还定义了一个printPerson函数，用于打印结构体的成员变量。在main函数中，我们调用createPerson函数创建一个Person结构体，并将其传递给printPerson函数进行打印。

12.5 结构体嵌套

结构体可以嵌套在其他结构体中，形成更复杂的数据结构。

以下是一个示例：

struct Date {

    int year;

    int month;

    int day;

};

struct Person {

    std::string name;

    Date birthDate;

};

int main() {

    Person person;

    person.name = "John";

    person.birthDate.year = 1990;

    person.birthDate.month = 5;

    person.birthDate.day = 15;

    std::cout << "Name: " << person.name << std::endl;

    std::cout << "Birth Date: " << person.birthDate.year << "/"

              << person.birthDate.month << "/" << person.birthDate.day << std::endl;

    return 0;

}

在上面的示例中，我们定义了一个Date结构体和一个Person结构体。Person结构体中嵌套了Date结构体作为一个成员变量。我们可以通过嵌套的方式访问和赋值结构体的成员变量。

总结起来，结构体是C++中一种自定义的数据类型，用于将不同类型的数据组合在一起。通过结构体，我们可以创建新的数据类型，表示具有相关属性的实体。在使用结构体时，可以声明结构体类型的变量，访问结构体的成员变量，进行初始化，作为函数参数和返回值，以及进行结构体的嵌套。

四、总结

本篇笔记对C++语言的基础知识进行了介绍，包括数据类型、变量、运算符、控制流语句、函数、数组、指针和结构体等内容。通过学习这些基础知识，你可以初步掌握C++语言的基本语法和常用功能。

以下是对本篇笔记的总结和建议：

基础知识：掌握C++的基本数据类型，包括整型、浮点型、字符型等，了解变量的声明和赋值，熟悉常用的运算符和表达式。

控制流语句：学习条件语句（if-else语句、switch语句）和循环语句（for循环、while循环、do-while循环），掌握如何使用这些语句来控制程序的执行流程。

函数：了解函数的定义和调用，学习函数的参数传递和返回值，掌握函数的基本用法和编写规范。

数组：理解数组的概念和用法，学习如何声明和初始化数组，掌握数组的访问和遍历方法。

指针：学习指针的定义和使用，了解指针和变量之间的关系，掌握指针的运算和指针的常见应用。

结构体：了解结构体的定义和使用，学习如何声明和访问结构体的成员变量，掌握结构体的初始化和作为函数参数和返回值的用法。

在学习C++语言时，建议进行实践和练习，通过编写代码来巩固所学知识。同时，阅读相关的教程和参考资料也是提高编程能力的重要途径。

最后制作实在不易，给我个关注，是你对我最大的支持！！

————————————————

版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。

                       

原文链接：https://blog.csdn.net/m0_69824302/article/details/133837877