1、C++基础语法

1、C++程序的基本结构

C++程序的基本结构由以下几部分组成：

1. 预处理指令（Preprocessor Directives）：这部分主要包括一些库的引用。例如 #include <iostream> 就是一条预处理指令，用于引入名为iostream的库，以便我们可以使用C++的输入输出功能。初学者，可以直接使用万能头文件

2. 名字空间：指明程序采用的名字空间是为了在C++新标准中，解决多数人同时编写大型程序时名字产生冲突的问题。

3. 主函数（Main Function）：C++程序的执行始于主函数。主函数通常形如 int main()，括号内可以包含参数，如命令行参数等。

4. 变量定义（Variable Definitions）：在程序中，我们需要定义各种变量以存储和处理数据。

5. 函数声明和定义（Function Declarations and Definitions）：函数是用于执行特定任务的代码块。你可以在程序中声明和定义你自己的函数。

6. 语句与表达式（Statements & Expressions）：语句通常是执行某种操作或执行一组操作的指令。表达式是一种计算并返回值的指令。

7. 注释（Comments）：注释用于解释代码的功能，提高代码的可读性。在C++中，你可以使用//来创建单行注释，或者使用/* ... */来创建多行注释。

以下是一个包含了以上所有元素的基本C++程序示例：

 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

// 预处理指令
#include <iostream>
#include <bits/stdc++.h>//万能头文件

//名字空间
using namespace std;

// 函数声明
void printMessage();

// 主函数
int main() {
    // 变量定义
    int number = 5;

    // 语句
    cout << "The number is: " << number << endl;

    // 函数调用
    printMessage();

    return 0;
}

// 函数定义
void printMessage() {
    cout << "This is a message." << endl;
}

​ 在这个程序中，首先引入了iostream库，然后定义了主函数和一个名为printMessage的函数。在主函数中，定义了一个变量number，然后打印出这个变量的值，接着调用printMessage函数。printMessage函数的功能是打印出一条消息。

C++必会程序框架：

1
2
3
4
5
6

#include <bits/stdc++.h>
using namespace std;
int main() {

    return 0;
}

2、C++常见的数据类型

​ C++支持多种数据类型，这些数据类型决定了数据的大小和存储方式，以及对数据进行的操作。以下是C++主要的数据类型：

1、基本内置类型

• 整数类型：如int，short，long，long long。它们有符号（signed）和无符号（unsigned）版本，无符号版本不能表示负数。

• 字符类型：如char，主要用于存储字符，但实际上也是整数类型。

• 布尔类型：bool，其值可以是true或false。

• 浮点类型：如float，double，long double，用于存储浮点数，也就是小数。

基本内置类型的大小和取值范围可能会根据实现（即编译器和硬件平台）有所不同。下面的信息是基于一个典型的64位系统：

​ 注意：上述表格中的信息可能会因编译器、硬件平台、操作系统等因素有所不同，可以使用C++的sizeof函数来获取特定系统上类型的实际大小。例如，sizeof(int)会返回int类型在当前系统中的字节大小。

2、复合类型

• 数组：存储同类型数据的连续集合。
• 字符串：存储字符的数组，通常以空字符（'\0'）结束。
• 指针：存储其他类型数据的内存地址。
• 引用：别名，对其他变量的引用。

3、用户自定义类型

• 枚举类型：如enum，枚举类型是由用户定义的类型，其值是由列举的一组命名的值。
• 类：由用户定义的类型，它封装了数据和操作数据的函数。
• 结构体：如struct，它可以将不同类型的数据组合在一起。
• 联合体：如union，联合体中的所有成员占据同一块内存，但只能存储其中的一种类型。

3、C++的变量与常量

在C++中，变量是程序操作的基本单位，每个变量都有特定的类型，决定了变量可以存储哪种类型的数据，以及在内存中占用多少空间。

1.变量的声明和定义

在C++中，声明一个变量通常包括类型和变量名，比如：

1

int number;

​ 在这个例子中，我们声明了一个类型为int（整数）的变量，名为number。这样的声明也叫做定义，因为我们创建了一个新的名为number的变量。

​ 有时，你可以在声明的时候初始化变量，如：

1

int number = 10;

​ 在这个例子中，我们声明了一个整型变量number，并将其初始化为10。

2.变量的类型

C++中有多种数据类型，包括：

• 基本类型（如 int, char, double, bool）
• 复合类型（如数组、结构体、类）
• 指针类型
• 引用类型

每种类型都有特定的大小，决定了变量在内存中占用多少空间，以及能存储的数据的范围。

3.变量的命名规则

在C++中，你可以为变量自由地选择名称，但是必须遵守以下规则：

1. 变量名称可以包含字母、数字和下划线符：例如，myVariable, variable1和variable_name都是有效的变量名称。
2. 变量名称必须以字母或下划线开始：例如，myVariable和_myVariable都是有效的变量名称，但1myVariable则不是。
3. 变量名称不能包含空格：例如，my Variable是无效的变量名称。
4. 变量名称是区分大小写的：myVariable和myvariable是两个不同的变量。
5. 变量名称不能是C++的保留字或关键字：例如，int，double，if等都是C++的关键字，不能作为变量名。
6. 变量名的长度没有限制，但是通常我们建议使用能够清楚反映变量含义的较短的名称。

另外，为了提高代码的可读性和可维护性，通常我们会遵循一些命名习惯或者约定，例如：

• 使用描述性的变量名称，比如age、firstName等，而不是a、b、c等。
• 变量名称全部小写，单词之间用下划线连接，如 my_variable。
• 或者使用"camel case"风格，即除第一个单词外，其他单词首字母大写，如 myVariable。

4.变量的作用域

在C++中，变量的作用域决定了在哪里可以访问变量。C++有以下几种作用域：

• 局部作用域：在函数或一个代码块内声明的变量，在函数或代码块外部是不可见的。
• 全局作用域：在函数外部声明的变量，全局可见。
• 命名空间作用域：在命名空间中声明的变量，在同一命名空间内可见，或者在其他地方使用命名空间修饰符可见。

5.变量的赋值

​ 在 C++ 中，赋值操作是非常常见的。赋值操作通常使用赋值运算符 =，其左边是要赋值的变量，右边是要赋给变量的值或表达式。

1
2

int myVariable; // 声明变量
myVariable = 5; // 赋值

​ 在这个例子中，我们先声明了一个名为 myVariable 的整型变量，然后将其值设置为 5。

​ 我们也可以在声明变量的同时对其进行初始化，也就是赋值：

1

int myVariable = 5; // 声明变量并赋值

​ 在这个例子中，我们在声明 myVariable 的同时给它赋了一个初始值 5。

​ 赋值操作可以对任何类型的变量进行，包括整数、浮点数、字符、字符串等。赋值表达式的右边可以是常数、变量、运算式或函数返回值等。

1
2
3
4
5

double d = 3.14; // 给浮点数变量赋值
char c = 'A'; // 给字符变量赋值
string str = "Hello, world!"; // 给字符串变量赋值
int sum = 3 + 2; // 使用运算式赋值
int max = max(3, 5); // 使用函数返回值赋值

​ 需要注意的是，赋值操作是有方向的，只能从右到左。也就是说，赋值操作的左边必须是一个变量，不能是常数或表达式。例如，5 = myVariable; 和 3 + 2 = sum; 都是错误的赋值操作。

6.常量

​ 在C++中，你可以声明一个变量为常量，表示其值不能被改变。这可以通过const关键字来实现，如：

1

const int number = 10;

​ 在这个例子中，我们声明了一个常量整型变量number，并将其初始化为10。一旦定义，number的值就不能被改变。

4、C++的输入与输出

1.cin/cout 输入与输出

1.输入（cin）

cin 是最常用的输入对象，它是 istream 类的一个实例。我们通常使用提取操作符 >> 从 cin 对象中提取数据。

2.输出（cout）

cout 是最常用的输出对象，它是 ostream 类的一个实例。我们通常使用插入操作符 << 将数据插入到 cout 对象中以输出数据。

​ C++中的格式化输出主要依赖于<iomanip>库，该库包含了一系列格式控制操作符。下面是一些常见的格式化操作符：

2.scanf/printf 输入与输出

​ scanf 和 printf 是C语言中用于输入和输出的函数，也可以在C++中使用。它们是 <stdio.h>（在C++中通常使用 <cstdio>）库中的函数。

1.scanf

​ scanf 函数用于格式化输入。它的用法和 printf 类似，但是 scanf 需要提供变量的地址（通过 & 操作符获取），因为它需要修改变量的值。

1
2
3
4
5
6
7
8
9

#include <cstdio>

int main() {
    int number;
    printf("Please enter a number: ");
    scanf("%d", &number);
    printf("You entered: %d\n", number);
    return 0;
}

​ 在这个例子中，scanf 函数会等待用户输入一个整数，然后将这个整数的值赋给 number 变量。

​ 需要注意的是，虽然 scanf 和 printf 在某些情况下可以使用，但它们没有C++中的 cin 和 cout 那么安全和易用。在C++中，建议优先使用 cin 和 cout 进行输入和输出操作。

2.printf

​ printf 函数用于格式化输出。它的第一个参数是一个格式字符串，其中包含了一些格式指定符。之后的参数是要输出的值。

1
2
3
4
5
6
7

#include <cstdio>

int main() {
    int number = 5;
    printf("The number is: %d\n", number);
    return 0;
}

​ 在这个例子中，%d 是一个格式指定符，表示一个整数。printf 函数会将 number 的值插入到 %d 的位置。

以下是printf和scanf函数中的一些常见格式说明符，以及对应的数据类型：

注意，对于scanf函数，对于字符串或数组类型，不需要使用&符号获取变量的地址，因为它们本身就是地址。

5、C++的算术运算符

在C++中，算术运算符用于执行常见的数学运算。以下是C++中常见的算术运算符：

1. 加法运算符（+）：用于两个数相加。

1
2
3

int a = 5;
int b = 3;
int sum = a + b;  // sum is 8

1. 减法运算符（-）：用于两个数相减。

1
2
3

int a = 5;
int b = 3;
int difference = a - b;  // difference is 2

1. 乘法运算符（*）：用于两个数相乘。

1
2
3

int a = 5;
int b = 3;
int product = a * b;  // product is 15

1. 除法运算符（/）：用于两个数相除。如果两个操作数都是整数，那么结果是整数除法。如果至少一个操作数是浮点数，那么结果是浮点数除法。

1
2
3
4
5
6
7

int a = 5;
int b = 2;
int quotient = a / b;  // quotient is 2 (integer division)

double c = 5.0;
double d = 2.0;
double quotient2 = c / d;  // quotient2 is 2.5 (floating-point division)

1. 求余运算符（%）：用于求两个整数相除的余数。注意：这个运算符只能用于整数。

1
2
3

int a = 5;
int b = 3;
int remainder = a % b;  // remainder is 2

1. 自增运算符（++）：用于将变量的值增加1。

1
2

int a = 5;
a++;  // a is now 6

1. 自减运算符（--）：用于将变量的值减少1。

1
2

int a = 5;
a--;  // a is now 4

​ 请注意，自增和自减运算符有两种形式：前置（如 ++a 或 --a）和后置（如 a++ 或 a--）。前置形式先增加（或减少）值，然后返回新值。后置形式先返回当前值，然后再增加（或减少）值。

6、C++的关系运算符

C++的关系运算符用于比较两个值之间的关系，这些运算符总是返回一个布尔值，即true（真）或false（假）。以下是C++中常见的关系运算符：

1. 等于（==）：检查两个操作数是否相等，如果相等则条件为真。

1
2
3

int a = 5;
int b = 3;
bool result = (a == b);  // result is false

1. 不等于（!=）：检查两个操作数是否不相等，如果不相等则条件为真。

1
2
3

int a = 5;
int b = 3;
bool result = (a != b);  // result is true

1. 大于（>）：检查左操作数的值是否大于右操作数，如果是则条件为真。

1
2
3

int a = 5;
int b = 3;
bool result = (a > b);  // result is true

1. 小于（<）：检查左操作数的值是否小于右操作数，如果是则条件为真。

1
2
3

int a = 5;
int b = 3;
bool result = (a < b);  // result is false

1. 大于或等于（>=）：检查左操作数的值是否大于或等于右操作数，如果是则条件为真。

1
2
3

int a = 5;
int b = 3;
bool result = (a >= b);  // result is true

1. 小于或等于（<=）：检查左操作数的值是否小于或等于右操作数，如果是则条件为真。

1
2
3

int a = 5;
int b = 3;
bool result = (a <= b);  // result is false

​ 这些关系运算符可以用于所有的基本数据类型，包括整数、浮点数、字符等。同时，也可以用于某些复杂的数据类型，例如字符串和自定义的对象（需要重载相应的运算符）。

7、C++的逻辑运算符

C++ 的逻辑运算符用于连接和修改布尔表达式。以下是 C++ 中的逻辑运算符：

1. 逻辑 AND（&&）：如果两个操作数都是真，则条件变为真。

1
2
3

bool a = true;
bool b = false;
bool result = a && b;  // result is false

1. 逻辑 OR（||）：如果两个操作数中至少有一个是真，则条件变为真。

1
2
3

bool a = true;
bool b = false;
bool result = a || b;  // result is true

1. 逻辑 NOT（!）：用于反转操作数的逻辑状态。如果条件为真，则逻辑 NOT 操作符将使其为假；如果条件为假，则逻辑 NOT 操作符将使其为真。

1
2

bool a = true;
bool result = !a;  // result is false

​ 需要注意的是，逻辑 AND 和逻辑 OR 操作符在 C++ 中是短路的。这意味着对于逻辑 AND，如果第一个操作数为假，那么第二个操作数就不会被评估，因为整个表达式已经可以确定为假。同理，对于逻辑 OR，如果第一个操作数为真，那么第二个操作数就不会被评估，因为整个表达式已经可以确定为真。

8、C++的位运算符

位运算符在 C++ 中用于对二进制位进行操作。以下是 C++ 中的位运算符：

1. 位 AND（&）：如果两个相应的二进制位都为1，则结果为1，否则为0。

1
2
3

int a = 5;  // in binary: 101
int b = 3;  // in binary: 011
int result = a & b;  // result is 1 (in binary: 001)

1. 位 OR（|）：如果两个相应的二进制位至少有一个为1，则结果为1，否则为0。

1
2
3

int a = 5;  // in binary: 101
int b = 3;  // in binary: 011
int result = a | b;  // result is 7 (in binary: 111)

1. 位 XOR（^）：如果两个相应的二进制位中只有一个为1，则结果为1，否则为0。

1
2
3

int a = 5;  // in binary: 101
int b = 3;  // in binary: 011
int result = a ^ b;  // result is 6 (in binary: 110)

1. 位 NOT（~）：对二进制数进行“翻转”操作，即将1变为0，将0变为1。

1
2

int a = 5;  // in binary: 00000101
int result = ~a;  // result is -6 (in binary: 11111010)

1. 左移（<<）：将二进制位向左移动指定的位数，右侧用0填充。

1
2

int a = 5;  // in binary: 101
int result = a << 1;  // result is 10 (in binary: 1010)

1. 右移（>>）：将二进制位向右移动指定的位数。对于无符号数，左侧用0填充。对于有符号数，左侧用符号位的值填充（这被称为“算术右移”）。

1
2

int a = 5;  // in binary: 101
int result = a >> 1;  // result is 2 (in binary: 10)

请注意，位运算符只能用于整数类型（如 int、char、long 等）。对于浮点数或对象，这些运算符没有定义。

9、C++的赋值运算符

C++ 的赋值运算符用于将值赋给变量。以下是 C++ 中的赋值运算符：

1. 基础赋值运算符（=）：将右操作数的值赋给左操作数。

1
2

int a;
a = 5;  // a is now 5

1. 加法赋值运算符（+=）：把右操作数加到左操作数上，并将结果赋给左操作数。

1
2

int a = 5;
a += 2;  // a is now 7

1. 减法赋值运算符（-=）：从左操作数中减去右操作数，并将结果赋给左操作数。

1
2

int a = 5;
a -= 2;  // a is now 3

1. 乘法赋值运算符（*=）：把右操作数乘以左操作数，并将结果赋给左操作数。

1
2

int a = 5;
a *= 2;  // a is now 10

1. 除法赋值运算符（/=）：将左操作数除以右操作数，并将结果赋给左操作数。

1
2

int a = 5;
a /= 2;  // a is now 2 (integer division)

1. 模数赋值运算符（%=）：将左操作数除以右操作数，并将余数赋给左操作数。

1
2

int a = 5;
a %= 2;  // a is now 1

1. 左移赋值运算符（<<=）：将左操作数的二进制位向左移动指定的位数，并将结果赋给左操作数。

1
2

int a = 5;  // in binary: 101
a <<= 1;  // a is now 10 (in binary: 1010)

1. 右移赋值运算符（>>=）：将左操作数的二进制位向右移动指定的位数，并将结果赋给左操作数。

1
2

int a = 5;  // in binary: 101
a >>= 1;  // a is now 2 (in binary: 10)

1. 位 AND 赋值运算符（&=）：对左操作数和右操作数进行位 AND 操作，并将结果赋给左操作数。

1
2

int a = 5;  // in binary: 101
a &= 3;  // a is now 1 (in binary: 001)

1. 位 OR 赋值运算符（|=）：对左操作数和右操作数进行位 OR 操作，并将结果赋给左操作数。

   C++
   1 2	cppCopy codeint a = 5; // in binary: 101 a |= 3; // a is now 7 (in binary: 111)

2. 位 XOR 赋值运算符（^=）：对左操作数和右操作数进行位 XOR 操作，并将结果赋给左操作数。

   C++
   1 2	int a = 5; // in binary: 101 a ^= 3; // a is now 6 (in binary: 110)

​ 这些赋值运算符都有相应的二元运算符，例如 += 对应 +，-= 对应 -，等等。它们将二元运算的结果赋值给左操作数，这可以使代码更简洁。

10、C++常见运算符的优先级

下面是按优先级（从高到低）列出的 C++ 运算符：

​ 注意：这个表格并没有包括所有的 C++ 运算符，但已经包括了最常用的运算符。一些更复杂的运算符，例如函数调用运算符 ()、数组下标运算符 []、类型信息运算符 typeid 等，没有包括在内。

11、C++的分支结构

C++ 的分支结构允许根据条件的真假选择执行不同的代码块。以下是 C++ 中的主要分支结构：

1. if 语句：if 语句是最基础的分支结构。如果 if 语句的条件为真（即非零），则执行其后的代码块。

1
2
3

if (condition) {
    // execute this block if condition is true
}

1. if-else 语句：if-else 语句允许在 if 语句的条件为假时执行另一个代码块。

1
2
3
4
5

if (condition) {
    // execute this block if condition is true
} else {
    // execute this block if condition is false
}

1. if-else if-else 语句：if-else if-else 语句允许对多个条件进行检查，按顺序执行第一个为真的条件对应的代码块。

1
2
3
4
5
6
7

if (condition1) {
    // execute this block if condition1 is true
} else if (condition2) {
    // execute this block if condition1 is false and condition2 is true
} else {
    // execute this block if both conditions are false
}

1. switch 语句：switch 语句用于基于一个表达式或变量的值在多个选项中选择一个执行。每个选项由一个 case 标签表示。还有一个可选的 default 标签，如果没有任何 case 标签匹配，则执行 default 标签后的代码块。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

switch (expression) {
    case value1:
        // execute this block if expression equals value1
        break;
    case value2:
        // execute this block if expression equals value2
        break;
    default:
        // execute this block if expression doesn't match any case value
}

在每个 case 代码块的结尾，通常使用 break 语句结束 switch 语句。如果没有 break，则会发生“贯穿”（fallthrough），即继续执行下一个 case 代码块，直到遇到 break 或 switch 结构结束。

​ 在编写条件时，要注意用正确的比较运算符（==、!=、<、>、<=、>=）和逻辑运算符（&&、||、!）。注意 if 和 switch 中的条件或表达式应该是布尔表达式或可以转换为布尔值的表达式，即结果为 true 或 false。

12、C++的循环结构

C++的循环结构允许你多次执行一段代码。以下是C++中的主要循环结构：

1. for 循环：for循环在一个序列上重复一个或多个语句。你可以在循环的开始设置一个初始值，定义一个条件，以及定义一个在每次迭代后执行的操作。

1
2
3

for (int i = 0; i < 10; i++) {
    // execute this block 10 times
}

1. while 循环：while循环在条件为真时重复一个或多个语句。

1
2
3

while (condition) {
    // execute this block as long as the condition is true
}

1. do-while 循环：do-while循环与 while 循环类似，但它至少执行一次代码块，然后再检查条件。

1
2
3

do {
    // execute this block at least once, and then as long as the condition is true
} while (condition);

​ 在每种循环中，你可以使用 break 关键字提前退出循环，无论条件是否满足。同样，你可以使用 continue 关键字跳过当前迭代的剩余部分，直接开始下一次迭代。

​ 在编写循环条件时，需要确保你在正确的时机更新了循环变量或者状态，否则可能会导致无限循环。请确保你的循环总是有一个定义明确的退出条件，且该退出条件在循环过程中总能被满足，这样可以避免无限循环的发生。

​ 4.循环嵌套

​ 在 C++ 中，你可以在一个循环内部放置另一个循环，这就是所谓的循环的嵌套。最内层的循环是最先执行的，当最内层的循环的所有迭代都执行完毕后，外层的循环才会进行下一次迭代。下面是一些例子：

1. 嵌套的 for 循环：

1
2
3
4
5

for (int i = 0; i < 5; i++) {
    for (int j = 0; j < 5; j++) {
        // This block is executed 25 times, for each combination of i and j
    }
}

1. 嵌套的 while 循环：

1
2
3
4
5
6
7
8
9

int i = 0;
while (i < 5) {
    int j = 0;
    while (j < 5) {
        // This block is executed 25 times, for each combination of i and j
        j++;
    }
    i++;
}

1. 嵌套的 do-while 循环：

1
2
3
4
5
6
7
8
9

int i = 0;
do {
    int j = 0;
    do {
        // This block is executed 25 times, for each combination of i and j
        j++;
    } while (j < 5);
    i++;
} while (i < 5);

​ 在这些例子中，我们打印了所有 i 和 j 的组合，这是一个 5x5 的网格。这只是嵌套循环的一个例子，你可以根据需要调整循环的条件和结构。

​ 在使用嵌套循环时，要注意每层循环的条件和计数器。特别是当你在内部循环中改变外部循环的计数器或条件时，你需要格外小心，因为这可能会导致意外的结果或无限循环。

本页面的全部内容在 小熊老师 - 莆田青少年编程俱乐部 0594codes.cn 协议之条款下提供，附加条款亦可能应用