【C++】知识点汇总（上）

C++知识点复习上

[一、C++ 概述](#一、C++ 概述)
- [1. 基本数据类型](#1. 基本数据类型)
- [2. 变量定义和访问](#2. 变量定义和访问)
- [3. 常量与约束访问](#3. 常量与约束访问)
二、程序控制结构详解与示例
- [1. 表达式](#1. 表达式)
- [2. 选择控制](#2. 选择控制)
- - [2.1 if 语句](#2.1 if 语句)
  - [2.2 switch 语句](#2.2 switch 语句)
- [3. 循环控制](#3. 循环控制)
- - [3.1 for 循环](#3.1 for 循环)
  - [3.2 while 循环](#3.2 while 循环)
  - [3.3 do-while 循环](#3.3 do-while 循环)
- [4. goto 语句](#4. goto 语句)
- [5. 控制语句的嵌套](#5. 控制语句的嵌套)
三、函数
- [1. 函数的定义和调用](#1. 函数的定义和调用)
- [2. 函数参数传递](#2. 函数参数传递)
- [3. 调用机制](#3. 调用机制)
- [4. 函数地址和指针](#4. 函数地址和指针)
- [5. 内联与重载](#5. 内联与重载)
- [6. 多文件程序和命名空间](#6. 多文件程序和命名空间)
四、数组和动态存储
- [1. 一维数组](#1. 一维数组)
- [2. 二维数组](#2. 二维数组)
- [3. 指针数组](#3. 指针数组)
- [4. 动态存储](#4. 动态存储)
- [5. Vector类](#5. Vector类)
- [6. String类](#6. String类)
- 7.比较
五、集合与结构
- [1. 位运算](#1. 位运算)
- - [1.1 与运算（AND）](#1.1 与运算（AND）)
  - [1.2 或运算（OR）](#1.2 或运算（OR）)
  - [1.3 异或运算（XOR）](#1.3 异或运算（XOR）)
- [2. 集合基本运算](#2. 集合基本运算)
- - [2.1 并集](#2.1 并集)
  - [2.2 交集](#2.2 交集)
  - [2.3 差集](#2.3 差集)
- [3. 结构的定义与访问](#3. 结构的定义与访问)
- [4. 结构数组和链表](#4. 结构数组和链表)
- - [4.1 结构数组](#4.1 结构数组)
  - [4.2 链表](#4.2 链表)

一、C++ 概述

C++ 是一种强大且广泛使用的编程语言，它结合了 C 语言的高效性和面向对象编程的特性。本文将介绍 C++ 的一些基本概念，包括基本数据类型、变量定义和访问，以及常量与约束访问。通过实际例子和表格，将了解这些重要的概念。

1. 基本数据类型

在 C++ 中，基本数据类型是构建其他数据类型的基石。以下是一些常见的基本数据类型：

类型	描述	大小
int	整数类型	4 字节
float	单精度浮点数	4 字节
double	双精度浮点数	8 字节
char	字符类型	1 字节
bool	布尔类型	1 字节

2. 变量定义和访问

在 C++ 中，变量是用于存储数据值的标识符。以下是变量的定义和访问的示例：

cpp 复制代码

// 变量定义
int age;
float height;

// 变量赋值
age = 25;
height = 1.75;

// 变量访问
cout << "年龄：" << age << " 岁" << endl;
cout << "身高：" << height << " 米" << endl;

3. 常量与约束访问

常量是在程序执行期间不能被修改的值，而约束访问则是通过修饰符确保函数中的某些行为。以下是常量和约束访问的例子：

cpp 复制代码

// 常量定义
const float PI = 3.14159;
const int MAX_AGE = 100;

// 约束访问
void printMessage(const string& message) {
    cout << message << endl;
}

int main() {
    printMessage("Hello, C++!");
    return 0;
}

在上述示例中，PI 和 MAX_AGE 是常量，它们的值在程序运行期间不会改变。而 printMessage 函数中的 const string& message 表示 message 参数是一个常量引用，禁止在函数中修改传递的字符串。

二、程序控制结构详解与示例

程序控制结构是编程中至关重要的一部分，它决定了程序执行的流程和逻辑。接下来浅示七种表达式、两种选择控制、三种循环控制、goto 语句以及控制语句的嵌套。通过详细的例子和表格，将更好地理解这些控制结构的使用。

1. 表达式

表达式是编程语言中的基本构建块，它们用于执行特定的计算。以下是七种常见的表达式：

算术表达式： 执行基本的算术运算。
c 复制代码
```
int result = 5 + 3 * 2;
```
关系表达式： 比较两个值之间的关系。
python 复制代码
```
bool isEqual = (x == y);
```
逻辑表达式： 使用逻辑运算符组合多个条件。
java 复制代码
```
boolean isTrue = (a && b) || (c || d);
```
赋值表达式： 将一个值赋给一个变量。
csharp 复制代码
```
int a = 10;
```
条件表达式（三元运算符）： 根据条件选择不同的值。
javascript 复制代码
```
var result = (x > 0) ? "Positive" : "Negative";
```
位运算表达式： 对二进制位进行操作。
python 复制代码
```
int result = a & b;
```
sizeof 表达式： 返回数据类型的大小。
c 复制代码
```
size_t size = sizeof(int);
```

2. 选择控制

选择控制结构用于根据条件执行不同的代码块。

2.1 if 语句

python 复制代码

if condition:
    # 如果条件成立执行此处代码
else:
    # 否则执行此处代码

示例：

java 复制代码

int num = 5;
if (num % 2 == 0) {
    System.out.println("偶数");
} else {
    System.out.println("奇数");
}

2.2 switch 语句

c 复制代码

switch (expression) {
    case value1:
        // 如果 expression 等于 value1 执行此处代码
        break;
    case value2:
        // 如果 expression 等于 value2 执行此处代码
        break;
    default:
        // 如果 expression 不等于任何一个 value 执行此处代码
}

示例：

python 复制代码

char grade = 'B';
switch (grade) {
    case 'A':
        System.out.println("优秀");
        break;
    case 'B':
        System.out.println("良好");
        break;
    default:
        System.out.println("其他");
}

3. 循环控制

循环控制结构允许我们多次执行相同的代码块。

3.1 for 循环

javascript 复制代码

for (initialization; condition; update) {
    // 循环体
}

示例：

csharp 复制代码

for (int i = 1; i <= 5; i++) {
    Console.WriteLine(i);
}

3.2 while 循环

java 复制代码

while (condition) {
    // 循环体
}

示例：

python 复制代码

int count = 0;
while (count < 5) {
    print(count)
    count += 1
}

3.3 do-while 循环

c 复制代码

do {
    // 循环体
} while (condition);

示例：

javascript 复制代码

int i = 0;
do {
    console.log(i);
    i++;
} while (i < 5);

4. goto 语句

goto 语句允许直接跳转到程序中的标记位置。

c 复制代码

if (condition) {
    goto label;
}

// 其他代码

label:
// 标记位置的代码

示例：

python 复制代码

x = 0

if x == 0:
    goto exit

# 其他代码

exit:
# 退出标记

5. 控制语句的嵌套

控制语句可以嵌套，形成复杂的逻辑结构。

示例：

java 复制代码

for (int i = 0; i < 3; i++) {
    if (i == 0) {
        System.out.println("i 是 0");
    } else {
        System.out.println("i 不是 0");
    }
}

三、函数

当谈论C++编程时，函数是一个非常重要的概念。函数允许我们将代码组织成可重用的模块，提高代码的可读性和维护性。包括函数的定义和调用、函数参数传递、调用机制、函数地址和指针、内联与重载、以及多文件程序和命名空间。

1. 函数的定义和调用

在C++中，函数的定义包括函数名、返回类型、参数列表和函数体。下面是一个简单的例子：

cpp 复制代码

// 函数的定义
int add(int a, int b) {
    return a + b;
}

int main() {
    // 函数的调用
    int result = add(3, 5);
    return 0;
}

2. 函数参数传递

C++支持多种函数参数传递方式，包括值传递、引用传递和指针传递。看下面的例子：

cpp 复制代码

// 值传递
void incrementByValue(int x) {
    x++;
}

// 引用传递
void incrementByReference(int &x) {
    x++;
}

// 指针传递
void incrementByPointer(int *x) {
    (*x)++;
}

int main() {
    int num = 10;

    incrementByValue(num);
    // num的值不变

    incrementByReference(num);
    // num的值加1

    incrementByPointer(&num);
    // num的值再次加1

    return 0;
}

3. 调用机制

C++函数调用机制涉及栈和堆的管理，以及函数的入栈和出栈过程。这是一个复杂的话题，我们将简要介绍。函数的调用涉及以下步骤：

将参数推送到栈上
跳转到函数的地址
执行函数体
将结果返回给调用者

4. 函数地址和指针

在C++中，函数也有地址，可以通过函数指针来调用函数。下面是一个示例：

cpp 复制代码

// 函数指针的声明
int (*addPointer)(int, int);

// 函数指针的赋值
addPointer = &add;

// 使用函数指针调用函数
int result = addPointer(3, 5);

5. 内联与重载

内联函数可以提高函数调用的效率，而函数重载允许我们定义多个同名函数，根据参数的类型和数量进行区分。看下面的例子：

cpp 复制代码

// 内联函数
inline int multiply(int a, int b) {
    return a * b;
}

// 函数重载
int add(int a, int b) {
    return a + b;
}

double add(double a, double b) {
    return a + b;
}

6. 多文件程序和命名空间

在大型项目中，将代码分为多个文件是一种良好的实践。同时，命名空间可以避免命名冲突。示例如下：

文件1: math_functions.h

cpp 复制代码

namespace Math {
    int add(int a, int b);
    double multiply(double a, double b);
}

文件2: math_functions.cpp

cpp 复制代码

#include "math_functions.h"

namespace Math {
    int add(int a, int b) {
        return a + b;
    }

    double multiply(double a, double b) {
        return a * b;
    }
}

文件3: main.cpp

cpp 复制代码

#include "math_functions.h"

int main() {
    int result = Math::add(3, 5);
    double product = Math::multiply(2.5, 4.0);
    return 0;
}

四、数组和动态存储

在编程中，数组是一种基本的数据结构，用于存储相同类型的元素。对于一维数组、二维数组、指针数组、动态存储以及C++中的vector和string类。将通过例子和表格演示它们的用法和区别。

1. 一维数组

一维数组是具有相同数据类型的元素的有序集合。声明和初始化一个一维整数数组的示例：

cpp 复制代码

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

2. 二维数组

二维数组是包含行和列的数组。下面是一个2x3的整数二维数组的声明和初始化：

cpp 复制代码

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

3. 指针数组

指针数组是一个数组，其中的元素是指针。以下是一个包含指向整数的指针的数组的示例：

cpp 复制代码

int a = 5, b = 10, c = 15;
int* ptrArr[3] = {&a, &b, &c};

4. 动态存储

动态存储允许在运行时分配内存。使用new关键字在堆上动态分配内存：

cpp 复制代码

int* dynamicArr = new int[5];
dynamicArr[0] = 10;
dynamicArr[1] = 20;
// ... 使用动态数组
delete[] dynamicArr; // 释放内存

5. Vector类

C++中的std::vector是一个动态数组，可以自动调整大小。以下是一个使用vector的示例：

cpp 复制代码

#include <vector>
std::vector<int> vec = {1, 2, 3, 4, 5};
vec.push_back(6); // 添加元素

6. String类

C++中的std::string是处理字符串的类。以下是一个使用string的示例：

cpp 复制代码

#include <string>
std::string str = "Hello, World!";

7.比较

在下表中，对这些数组和动态存储的不同方面进行了比较：

特性	一维数组	二维数组	指针数组	动态存储	Vector类	String类
声明与初始化	int arr[5];	int matrix[2][3];	int* ptrArr[3];	int* dynamicArr = new int[5];	std::vector vec;	std::string str;
内存管理	栈	栈	栈	堆	动态增长	堆
大小可变性	静态	静态	静态	动态	动态	动态

五、集合与结构

集合与结构是两个基本而重要的概念。包括位运算、集合基本运算、结构的定义与访问，以及结构数组和链表的应用。通过例子和表格，将介绍这些概念。

1. 位运算

位运算是在二进制位上执行操作的一种技术。以下是一些常见的位运算操作：

1.1 与运算（AND）

cpp 复制代码

int result = a & b; // 将a和b的每个对应位进行与运算

1.2 或运算（OR）

cpp 复制代码

int result = a | b; // 将a和b的每个对应位进行或运算

1.3 异或运算（XOR）

cpp 复制代码

int result = a ^ b; // 将a和b的每个对应位进行异或运算

2. 集合基本运算

集合是一个独特的数据结构，常用于存储不重复的元素。以下是一些集合的基本运算：

2.1 并集

cpp 复制代码

set<int> unionSet = setA;
unionSet.insert(setB.begin(), setB.end());

2.2 交集

cpp 复制代码

set<int> intersectionSet;
set_intersection(setA.begin(), setA.end(), setB.begin(), setB.end(), inserter(intersectionSet, intersectionSet.begin()));

2.3 差集

cpp 复制代码

set<int> differenceSet;
set_difference(setA.begin(), setA.end(), setB.begin(), setB.end(), inserter(differenceSet, differenceSet.begin()));

3. 结构的定义与访问

结构是一种用户自定义的数据类型，可以包含不同类型的数据。以下是结构的定义和访问：

cpp 复制代码

struct Point {
    int x;
    int y;
};

Point p1;
p1.x = 10;
p1.y = 20;

4. 结构数组和链表

4.1 结构数组

结构数组是一组相同类型的结构的集合。以下是一个点的结构数组的例子：

cpp 复制代码

Point pointsArray[5];
pointsArray[0].x = 1;
pointsArray[0].y = 2;
// 其他元素的赋值类似

4.2 链表

链表是一种动态数据结构，它可以动态增长和缩小。以下是一个简单链表的例子：

cpp 复制代码

struct Node {
    int data;
    Node* next;
};

Node* head = new Node();
head->data = 1;
head->next = new Node();
head->next->data = 2;
head->next->next = nullptr;