C++ 作为一门兼具高效性和灵活性的编程语言，自诞生以来一直是系统开发、游戏引擎、嵌入式开发等领域的核心工具。它既保留了 C 语言的过程化编程特性，又引入了面向对象编程（OOP）、泛型编程等高级特性，是编程新手进阶的重要基石。本文将从环境搭建、基础语法、数据类型、流程控制、函数、数组、指针到面向对象基础等维度，结合大量可运行的代码示例，全面讲解 C++ 入门核心知识点，帮助你从零开始掌握 C++ 的基础框架。
一、C++ 开发环境搭建
在编写第一个 C++ 程序前，首先需要搭建合适的开发环境。C++ 作为编译型语言，需要编译器将源代码转换为可执行文件，同时搭配编辑器 / IDE 提升开发效率。
1.1 主流开发工具选择
- Windows 平台：
- Dev-C++：轻量级、开箱即用，适合新手入门；
- Code::Blocks：开源免费，支持多编译器；
- Visual Studio 2022：微软官方 IDE，功能强大，内置 MSVC 编译器，推荐新手使用社区版（免费）；
- MinGW：GCC 编译器的 Windows 移植版，可搭配 VS Code 使用。
- Linux 平台：自带 GCC 编译器，搭配 VS Code、Vim 或 CLion 即可。
- macOS 平台：安装 Xcode Command Line Tools（
xcode-select --install）获取 Clang/GCC，搭配 Xcode 或 VS Code。
1.2 第一个 C++ 程序：Hello World
无论学习哪门语言，"Hello World" 都是入门的起点。以下是标准的 C++ Hello World 程序，我们以此为例讲解基础结构：
// 包含输入输出流头文件，cout/cin 需要依赖此文件
#include <iostream>
// 使用 std 命名空间，避免每次写 std::cout
using namespace std;
// 主函数：程序的入口，int 表示返回值类型
int main() {
// 输出字符串到控制台，endl 表示换行并刷新缓冲区
cout << "Hello, C++ World!" << endl;
// 暂停程序（Windows 平台），避免控制台一闪而过
// system("pause");
// 返回 0 表示程序正常结束
return 0;
}
代码解释：
#include <iostream>：预处理指令，引入标准输入输出流头文件，iostream是 input/output stream 的缩写，提供了控制台输入输出的功能；using namespace std：std是 C++ 标准库的命名空间，C++ 标准库的所有内容都封装在std中，此语句让我们可以直接使用cout而非std::cout；int main()：main函数是程序的唯一入口，int表示函数执行后返回一个整数；cout << "Hello, C++ World!" << endl：cout是标准输出流对象，<<是流插入运算符，用于将内容输出到控制台；endl等价于\n（换行符），但会额外刷新输出缓冲区；return 0：主函数返回 0 表示程序正常退出，非 0 值通常表示程序异常。
编译运行：
- 若使用 IDE（如 Visual Studio），直接点击'运行'按钮即可。
若使用 GCC 编译器，在终端执行：
g++ hello.cpp -o hello # 编译源代码生成可执行文件
./hello # 运行可执行文件（Linux/macOS）
# 或 hello.exe # Windows 平台
二、C++ 基础语法
2.1 注释
注释是代码的说明文字，编译器会忽略注释内容。C++ 支持两种注释方式：
// 单行注释：以//开头，直到行尾
/* 多行注释：以/*开头，以*/结尾
可跨多行
注意：多行注释不能嵌套 */
#include <iostream>
using namespace std;
int main() {
// 输出测试语句（单行注释）
cout << "测试注释" << endl;
/* 行内多行注释 */
return 0;
}
2.2 标识符与关键字
2.2.1 标识符
标识符是变量、函数、类等自定义名称的统称，命名规则：
- 由字母（A-Z/a-z）、数字（0-9）、下划线（_）组成；
- 不能以数字开头；
- 区分大小写（如
age和Age是两个不同的标识符）； - 不能与 C++ 关键字重名。
合法标识符示例：name、_score、stu_123、MAX_NUM；非法标识符示例：123abc（以数字开头）、stu-name（含非法字符 -）、int（关键字）。
2.2.2 关键字
关键字是 C++ 语言预留的特殊单词，具有固定含义，不能作为标识符使用。常见关键字如下：
| 类别 | 关键字示例 |
|---|---|
| 数据类型 | int、char、float、double、bool |
| 控制语句 | if、else、for、while、switch |
| 存储类 | static、const、extern |
| 面向对象 | class、public、private、virtual |
| 其他 | return、void、sizeof、typedef |
2.3 变量与常量
2.3.1 变量
变量是程序中用于存储数据的内存单元，其值可以在程序运行过程中改变。定义变量的语法：
数据类型 变量名 = 初始值; // 推荐初始化
// 或 数据类型 变量名; // 不推荐，未初始化的变量值为随机值
示例：
#include <iostream>
using namespace std;
int main() {
// 整型变量：存储整数
int age = 18;
// 浮点型变量：存储小数
float height = 175.5f; // float 需加 f 后缀，否则默认是 double
double weight = 65.8; // double 精度更高
// 字符型变量：存储单个字符，用单引号包裹
char gender = 'M';
// 布尔型变量：存储真（true/1）或假（false/0）
bool isStudent = true;
// 输出变量值
cout << "年龄：" << age << endl;
cout << "身高：" << height << "cm" << endl;
cout << "体重：" << weight << "kg" << endl;
cout << "性别：" << gender << endl;
cout << "是否学生：" << boolalpha << isStudent << endl;
// boolalpha：将布尔值以 true/false 输出，而非 1/0
// 修改变量值
age = 19;
cout << "修改后的年龄：" << age << endl;
return 0;
}
输出结果：
年龄：18 身高：175.5cm 体重：65.8kg 性别：M 是否学生：true 修改后的年龄：19
2.3.2 常量
常量是程序运行过程中值不可改变的量，C++ 定义常量有两种方式：
#include <iostream>
using namespace std;
// 1. 宏常量：预处理阶段替换，无类型检查
#define PI 3.1415926
#define MAX_SCORE 100
int main() {
// 2. const 常量：编译阶段检查，有类型限制（推荐）
const int MIN_AGE = 0;
// 使用常量
double radius = 5.0;
double area = PI * radius * radius;
cout << "圆的面积：" << area << endl;
// 常量不可修改，以下代码会报错
// PI = 3.14; // 宏常量修改报错
// MIN_AGE = 1; // const 常量修改报错
return 0;
}
输出结果：
圆的面积：78.5398
对比：#define 是预处理指令，仅做文本替换，无类型安全检查；const 是编译期常量，有类型限制，占用内存，更安全，推荐优先使用。
2.4 数据类型
C++ 的数据类型分为基本数据类型和复合数据类型，基础阶段重点掌握基本数据类型：
| 类型 | 关键字 | 大小（字节） | 取值范围 | 用途 |
|---|---|---|---|---|
| 布尔型 | bool | 1 | true/false（等价于 1/0） | 表示真假 |
| 字符型 | char | 1 | -128 ~ 127（或 0 ~ 255，取决于编译器） | 存储单个字符 |
| 短整型 | short | 2 | -32768 ~ 32767 | 小范围整数 |
| 整型 | int | 4 | -2^31 ~ 2^31-1 | 常用整数 |
| 长整型 | long | 4/8 | 取决于系统（至少 4 字节） | 较大范围整数 |
| 长长整型 | long long | 8 | -2^63 ~ 2^63-1 | 超大范围整数 |
| 浮点型 | float | 4 | 6~7 位有效数字 | 单精度小数 |
| 双精度浮点型 | double | 8 | 15~16 位有效数字 | 常用小数（默认） |
示例：数据类型大小与取值
#include <iostream>
#include <climits> // 包含整型取值范围常量
#include <cfloat> // 包含浮点型取值范围常量
using namespace std;
int main() {
// 输出各数据类型的大小（字节）
cout << "bool 大小：" << sizeof(bool) << "字节" << endl;
cout << "char 大小：" << sizeof(char) << "字节" << endl;
cout << "short 大小：" << sizeof(short) << "字节" << endl;
cout << "int 大小：" << sizeof(int) << "字节" << endl;
cout << "long 大小：" << sizeof(long) << "字节" << endl;
cout << "long long 大小：" << sizeof(long long) << "字节" << endl;
cout << "float 大小：" << sizeof(float) << "字节" << endl;
cout << "double 大小：" << sizeof(double) << "字节" << endl;
// 输出整型取值范围
cout << "int 最小值：" << INT_MIN << endl;
cout << "int 最大值：" << INT_MAX << endl;
cout << "long long 最小值：" << LLONG_MIN << endl;
cout << "long long 最大值：" << LLONG_MAX << endl;
// 输出浮点型精度
cout << "float 有效数字：" << FLT_DIG << "位" << endl;
cout << "double 有效数字：" << DBL_DIG << "位" << endl;
return 0;
}
输出结果（64 位系统）：
bool 大小：1 字节 char 大小：1 字节 short 大小：2 字节 int 大小：4 字节 long 大小：8 字节 long long 大小：8 字节 float 大小：4 字节 double 大小：8 字节 int 最小值：-2147483648 int 最大值：2147483647 long long 最小值：-9223372036854775808 long long 最大值：9223372036854775807 float 有效数字：6 位 double 有效数字：15 位
2.5 运算符
运算符是用于执行运算的符号，C++ 运算符分为算术运算符、赋值运算符、比较运算符、逻辑运算符、位运算符等，以下是常用运算符的示例：
2.5.1 算术运算符
| 运算符 | 功能 | 示例 |
|---|---|---|
| + | 加法 | a + b |
| - | 减法 | a - b |
| * | 乘法 | a * b |
| / | 除法 | a /b（整数除法取整） |
| % | 取模（余数） | a % b（仅整数可用） |
| ++ | 自增 | a++（后置）、++a（前置） |
| -- | 自减 | a--（后置）、--a（前置） |
#include <iostream>
using namespace std;
int main() {
int a = 10, b = 3;
// 基本算术运算
cout << "a + b = " << a + b << endl; // 13
cout << "a - b = " << a - b << endl; // 7
cout << "a * b = " << a * b << endl; // 30
cout << "a / b = " << a / b << endl; // 3（整数除法）
cout << "a % b = " << a % b << endl; // 1（余数）
// 自增自减
int c = 5;
cout << "c++ = " << c++ << endl; // 5（先输出，后自增）
cout << "c = " << c << endl; // 6
cout << "++c = " << ++c << endl; // 7（先自增，后输出）
int d = 8;
cout << "d-- = " << d-- << endl; // 8（先输出，后自减）
cout << "d = " << d << endl; // 7
cout << "--d = " << --d << endl; // 6（先自减，后输出）
return 0;
}
2.5.2 赋值运算符
| 运算符 | 功能 | 示例 | 等价于 |
|---|---|---|---|
| = | 基本赋值 | a = 5 | - |
| += | 加后赋值 | a += 5 | a = a + 5 |
| -= | 减后赋值 | a -= 5 | a = a - 5 |
| *= | 乘后赋值 | a *= 5 | a = a * 5 |
| /= | 除后赋值 | a /= 5 | a = a / 5 |
| %= | 模后赋值 | a %= 5 | a = a % 5 |
#include <iostream>
using namespace std;
int main() {
int x = 10;
x += 5; // x = 15
cout << "x += 5: " << x << endl;
x -= 3; // x = 12
cout << "x -= 3: " << x << endl;
x *= 2; // x = 24
cout << "x *= 2: " << x << endl;
x /= 4; // x = 6
cout << "x /= 4: " << x << endl;
x %= 4; // x = 2
cout << "x %= 4: " << x << endl;
return 0;
}
2.5.3 比较运算符
比较运算符返回布尔值（true/false），常用于条件判断：
| 运算符 | 功能 | 示例 |
|---|---|---|
| == | 等于 | a == b |
| != | 不等于 | a != b |
| > | 大于 | a > b |
| < | 小于 | a < b |
| >= | 大于等于 | a >= b |
| <= | 小于等于 | a <= b |
#include <iostream>
using namespace std;
int main() {
int m = 8, n = 8;
cout << boolalpha; // 输出 true/false 而非 1/0
cout << "m == n: " << (m == n) << endl; // true
cout << "m != n: " << (m != n) << endl; // false
cout << "m > n: " << (m > n) << endl; // false
cout << "m < n: " << (m < n) << endl; // false
cout << "m >= n: " << (m >= n) << endl; // true
cout << "m <= n: " << (m <= n) << endl; // true
return 0;
}
2.5.4 逻辑运算符
逻辑运算符用于组合多个条件，返回布尔值：
| 运算符 | 功能 | 示例 | 规则 |
|---|---|---|---|
| && | 逻辑与 | a && b | 全为 true 则 true，否则 false |
| || | 逻辑或 | a || b | 有一个 true 则 true，否则 false |
| ! | 逻辑非 | !a | 取反，true 变 false，false 变 true |
#include <iostream>
using namespace std;
int main() {
bool cond1 = true, cond2 = false;
cout << boolalpha;
cout << "cond1 && cond2: " << (cond1 && cond2) << endl; // false
cout << "cond1 || cond2: " << (cond1 || cond2) << endl; // true
cout << "!cond1: " << !cond1 << endl; // false
cout << "!cond2: " << !cond2 << endl; // true
// 实际应用：判断年龄是否在 18-60 之间
int age = 25;
bool isAdult = (age >= 18) && (age <= 60);
cout << "是否为成年且未退休：" << isAdult << endl; // true
return 0;
}
三、流程控制语句
流程控制用于改变程序的执行顺序，C++ 提供三种基本流程结构：顺序结构（默认）、选择结构（if/switch）、循环结构（for/while/do-while）。
3.1 选择结构
3.1.1 if 语句
if 语句根据条件执行不同的代码块，分为单分支、双分支、多分支：
单分支 if：
#include <iostream>
using namespace std;
int main() {
// 单分支：条件为 true 时执行
int score = 90;
if (score >= 60) {
cout << "成绩合格" << endl;
}
return 0;
}
双分支 if-else：
#include <iostream>
using namespace std;
int main() {
// 双分支：条件为 true 执行 if 块，否则执行 else 块
int score = 55;
if (score >= 60) {
cout << "成绩合格" << endl;
} else {
cout << "成绩不合格" << endl;
}
return 0;
}
多分支 if-else if-else：
#include <iostream>
using namespace std;
int main() {
// 多分支：依次判断条件，匹配则执行对应块
int score = 85;
if (score >= 90) {
cout << "优秀" << endl;
} else if (score >= 80) {
cout << "良好" << endl;
} else if (score >= 70) {
cout << "中等" << endl;
} else if (score >= 60) {
cout << "及格" << endl;
} else {
cout << "不及格" << endl;
}
return 0;
}
3.1.2 switch 语句
switch 语句适用于多分支的等值判断，比多分支 if 更简洁：
#include <iostream>
using namespace std;
int main() {
// switch：根据表达式的值匹配 case
int grade = 3;
switch (grade) {
case 1:
cout << "一年级" << endl;
break; // 跳出 switch，避免穿透
case 2:
cout << "二年级" << endl;
break;
case 3:
cout << "三年级" << endl;
break;
default: // 所有 case 不匹配时执行
cout << "未知年级" << endl;
}
return 0;
}
注意：
switch的表达式只能是整型、字符型或枚举类型；case后必须是常量表达式，不能是变量；break用于终止当前 case，否则会发生'case 穿透'（执行后续 case）；default可选，通常放在最后，处理未匹配的情况。
3.2 循环结构
循环结构用于重复执行一段代码，直到满足终止条件。
3.2.1 for 循环
for 循环适用于已知循环次数的场景，语法：
for (初始化表达式; 条件表达式; 更新表达式) {
循环体;
}
示例 1：遍历 1-10 的整数并求和
#include <iostream>
using namespace std;
int main() {
int sum = 0;
// 初始化 i=1；条件 i<=10 为 true 时执行循环体；每次循环后 i++
for (int i = 1; i <= 10; i++) {
sum += i; // 累加
cout << "当前 i：" << i << "，累计和：" << sum << endl;
}
cout << "1-10 的和：" << sum << endl; // 55
return 0;
}
示例 2：输出 100 以内的偶数
#include <iostream>
using namespace std;
int main() {
cout << "100 以内的偶数：" << endl;
for (int i = 0; i <= 100; i += 2) {
cout << i << " "; // 每输出 10 个换行
if (i % 20 == 0 && i != 0) {
cout << endl;
}
}
return 0;
}
3.2.2 while 循环
while 循环适用于未知循环次数的场景，语法：
while (条件表达式) {
循环体;
}
示例：计算 1-100 的累加和（while 版）
#include <iostream>
using namespace std;
int main() {
int sum = 0;
int i = 1;
// 条件 i<=100 为 true 时执行循环体
while (i <= 100) {
sum += i;
i++; // 必须手动更新循环变量，否则死循环
}
cout << "1-100 的和：" << sum << endl; // 5050
return 0;
}
3.2.3 do-while 循环
do-while 循环先执行一次循环体，再判断条件，语法：
do {
循环体;
} while (条件表达式);
示例：输入密码直到正确
#include <iostream>
#include <string> // 字符串头文件
using namespace std;
int main() {
string password;
const string correct_pwd = "123456";
// 至少执行一次输入
do {
cout << "请输入密码：";
cin >> password;
if (password != correct_pwd) {
cout << "密码错误，请重新输入！" << endl;
}
} while (password != correct_pwd);
cout << "密码正确，登录成功！" << endl;
return 0;
}
3.2.4 循环控制关键字
break：跳出当前循环（或 switch），终止循环；continue：跳过当前循环的剩余语句，直接进入下一次循环；goto：跳转到指定标签（不推荐使用，易导致代码混乱）。
示例：break 和 continue 的使用
#include <iostream>
using namespace std;
int main() {
// break 示例：找到第一个大于 5 的数就退出循环
cout << "break 示例：" << endl;
for (int i = 1; i <= 10; i++) {
if (i > 5) {
break;
}
cout << i << " "; // 输出：1 2 3 4 5
}
cout << endl;
// continue 示例：跳过偶数，只输出奇数
cout << "continue 示例：" << endl;
for (int i = 1; i <= 10; i++) {
if (i % 2 == 0) {
continue; // 跳过偶数
}
cout << i << " "; // 输出：1 3 5 7 9
}
cout << endl;
return 0;
}
四、函数
函数是封装的可重用代码块，用于实现特定功能，C++ 函数分为库函数（如 cout、sqrt）和自定义函数。
4.1 函数的定义与调用
函数定义语法：
返回值类型 函数名 (参数列表) {
函数体;
return 返回值; // 无返回值（void）时可省略
}
示例 1：无参无返回值函数
#include <iostream>
using namespace std;
// 函数定义：打印欢迎信息
void printWelcome() {
cout << "欢迎使用 C++ 函数！" << endl;
}
int main() {
// 函数调用
printWelcome();
return 0;
}
示例 2：有参有返回值函数（计算两数之和）
#include <iostream>
using namespace std;
// 函数定义：计算 a+b 的和，返回 int 类型
int add(int a, int b) {
int result = a + b;
return result;
}
int main() {
int x = 10, y = 20;
// 函数调用：将返回值赋值给 sum
int sum = add(x, y);
cout << x << " + " << y << " = " << sum << endl; // 30
// 直接调用并输出
cout << "5 + 8 = " << add(5, 8) << endl; // 13
return 0;
}
4.2 函数的参数
4.2.1 形参与实参
- 形参：函数定义时的参数（如
add中的a、b），仅在函数内部有效； - 实参：函数调用时传递的参数（如
add(x, y)中的x、y），必须与形参类型匹配。
4.2.2 传值调用与传址调用
- 传值调用：默认方式，将实参的值拷贝给形参，形参修改不影响实参；
- 传址调用：传递实参的地址（指针 / 引用），形参修改会影响实参。
示例：传值调用 vs 传址调用
#include <iostream>
using namespace std;
// 传值调用：形参是实参的拷贝
void swapByValue(int a, int b) {
int temp = a;
a = b;
b = temp;
cout << "函数内：a=" << a << ", b=" << b << endl; // a=20, b=10
}
// 传址调用：形参是指针，指向实参的地址
void swapByAddress(int* a, int* b) {
int temp = *a;
*a = *b;
*b = temp;
}
int main() {
int x = 10, y = 20;
// 传值调用
swapByValue(x, y);
cout << "传值调用后：x=" << x << ", y=" << y << endl; // x=10, y=20（无变化）
// 传址调用
swapByAddress(&x, &y);
cout << "传址调用后：x=" << x << ", y=" << y << endl; // x=20, y=10（交换成功）
return 0;
}
4.3 函数重载
函数重载是 C++ 的重要特性，允许在同一作用域内定义多个同名函数，要求参数列表不同（参数个数、类型、顺序不同），与返回值无关。
#include <iostream>
using namespace std;
// 重载 1：两个 int 求和
int add(int a, int b) {
return a + b;
}
// 重载 2：三个 int 求和（参数个数不同）
int add(int a, int b, int c) {
return a + b + c;
}
// 重载 3：两个 double 求和（参数类型不同）
double add(double a, double b) {
return a + b;
}
int main() {
cout << "add(10, 20) = " << add(10, 20) << endl; // 调用重载 1，输出 30
cout << "add(10, 20, 30) = " << add(10, 20, 30) << endl; // 调用重载 2，输出 60
cout << "add(1.5, 2.5) = " << add(1.5, 2.5) << endl; // 调用重载 3，输出 4.0
return 0;
}
五、数组
数组是存储同一类型数据的连续内存空间，分为一维数组和多维数组。
5.1 一维数组
5.1.1 数组定义
// 方式 1：指定长度，后续赋值
数据类型 数组名 [数组长度];
// 方式 2：指定长度并初始化
数据类型 数组名 [数组长度] = {值 1, 值 2, ...};
// 方式 3：省略长度，由初始化列表决定
数据类型 数组名 [] = {值 1, 值 2, ...};
5.1.2 数组访问
数组元素通过下标访问，下标从 0 开始，语法：数组名 [下标]。
示例：一维数组的定义与遍历
#include <iostream>
using namespace std;
int main() {
// 方式 1：定义并初始化
int scores[5] = {90, 85, 95, 88, 92};
// 遍历数组（for 循环）
cout << "数组元素：";
for (int i = 0; i < 5; i++) {
cout << scores[i] << " ";
}
cout << endl;
// 计算数组元素总和
int sum = 0;
for (int i = 0; i < 5; i++) {
sum += scores[i];
}
cout << "总分：" << sum << endl;
cout << "平均分：" << (double)sum / 5 << endl; // 强制类型转换
// 方式 2：省略长度
char arr[] = {'a', 'b', 'c', 'd'};
// sizeof(arr)：数组总字节数；sizeof(arr[0])：单个元素字节数
int len = sizeof(arr) / sizeof(arr[0]);
cout << "字符数组长度：" << len << endl; // 4
return 0;
}
5.2 二维数组
二维数组可看作'数组的数组'，常用于表示表格、矩阵等。
5.2.1 二维数组定义
// 方式 1：指定行列数并初始化
数据类型 数组名 [行数][列数] = {{值 1, 值 2}, {值 3, 值 4}, ...};
// 方式 2：省略行数，由初始化列表决定
数据类型 数组名[][列数] = {{值 1, 值 2}, {值 3, 值 4}, ...};
5.2.2 二维数组访问
语法：数组名 [行下标][列下标]，行 / 列下标均从 0 开始。
示例：二维数组遍历（成绩表）
#include <iostream>
using namespace std;
int main() {
// 3 行 2 列：3 个学生，2 门科目成绩
int scores[3][2] = {{90, 85}, {88, 92}, {78, 89}};
// 遍历二维数组：外层循环行，内层循环列
for (int i = 0; i < 3; i++) {
cout << "第" << i+1 << "个学生成绩：";
int sum = 0;
for (int j = 0; j < 2; j++) {
cout << scores[i][j] << " ";
sum += scores[i][j];
}
cout << "总分：" << sum << "，平均分：" << sum / 2.0 << endl;
}
return 0;
}
输出结果：
第 1 个学生成绩：90 85 总分：175，平均分：87.5 第 2 个学生成绩：88 92 总分：180，平均分：90 第 3 个学生成绩：78 89 总分：167，平均分：83.5
六、指针
指针是 C++ 的核心概念，用于存储变量的内存地址。掌握指针是理解 C++ 内存模型的关键。
6.1 指针的基本概念
- 内存地址：每个变量在内存中都有唯一的地址，可通过
&变量名获取； - 指针变量：专门存储地址的变量，定义语法：
数据类型* 指针名;； - 解引用：通过
*指针名访问指针指向的变量值。
示例：指针的定义与使用
#include <iostream>
using namespace std;
int main() {
int num = 10;
// 定义指针变量 p，存储 num 的地址
int* p = #
cout << "变量 num 的值：" << num << endl; // 10
cout << "变量 num 的地址：" << &num << endl; // 如 0x61fe14
cout << "指针 p 的值（num 的地址）：" << p << endl; // 同&num
cout << "指针 p 的地址：" << &p << endl; // 指针自身的地址
cout << "解引用 p（访问指向的值）：" << *p << endl; // 10
// 通过指针修改变量值
*p = 20;
cout << "修改后 num 的值：" << num << endl; // 20
return 0;
}
6.2 指针与数组
数组名本质上是指向数组第一个元素的常量指针，因此可通过指针访问数组元素。
#include <iostream>
using namespace std;
int main() {
int arr[] = {10, 20, 30, 40, 50};
int* p = arr; // 数组名 arr 等价于&arr[0]
// 方式 1：下标访问
cout << "下标访问：";
for (int i = 0; i < 5; i++) {
cout << arr[i] << " ";
}
cout << endl;
// 方式 2：指针访问
cout << "指针访问：";
for (int i = 0; i < 5; i++) {
cout << *(p + i) << " "; // p+i 指向第 i 个元素的地址
}
cout << endl;
// 方式 3：指针自增
cout << "指针自增：";
int* q = arr;
for (int i = 0; i < 5; i++) {
cout << *q << " ";
q++; // 指针向后移动一个 int 长度
}
cout << endl;
return 0;
}
6.3 指针与函数
指针作为函数参数时，可实现'传址调用'，让函数修改实参的值（如交换函数）。
示例：指针实现数组排序（冒泡排序）
#include <iostream>
using namespace std;
// 冒泡排序函数：指针接收数组，len 接收长度
void bubbleSort(int* arr, int len) {
for (int i = 0; i < len - 1; i++) {
for (int j = 0; j < len - 1 - i; j++) {
// 指针访问数组元素，交换
if (*(arr + j) > *(arr + j + 1)) {
int temp = *(arr + j);
*(arr + j) = *(arr + j + 1);
*(arr + j + 1) = temp;
}
}
}
}
int main() {
int arr[] = {34, 7, 23, 32, 5, 62};
int len = sizeof(arr) / sizeof(arr[0]);
cout << "排序前：";
for (int i = 0; i < len; i++) {
cout << arr[i] << " ";
}
cout << endl;
// 调用排序函数：数组名作为参数，传递的是地址
bubbleSort(arr, len);
cout << "排序后：";
for (int i = 0; i < len; i++) {
cout << arr[i] << " ";
}
cout << endl;
return 0;
}
输出结果：
排序前：34 7 23 32 5 62 排序后：5 7 23 32 34 62
七、面向对象基础
C++ 的核心特性之一是面向对象编程（OOP），其三大核心是封装、继承、多态。此处先讲解最基础的封装和类的使用。
7.1 类与对象
类是自定义数据类型，封装了数据（成员变量）和行为（成员函数）；对象是类的实例。
7.1.1 类的定义
#include <iostream>
#include <string>
using namespace std;
// 定义类：class 关键字
class Student {
// 访问权限：public（公有的，外部可访问）
public:
// 成员变量（属性）
string name;
int age;
double score;
// 成员函数（行为）：显示学生信息
void showInfo() {
cout << "姓名：" << name << endl;
cout << "年龄：" << age << endl;
cout << "成绩：" << score << endl;
}
// 成员函数：修改成绩
void setScore(double s) {
if (s >= 0 && s <= 100) {
score = s;
} else {
cout << "成绩输入无效！" << endl;
}
}
};
int main() {
// 创建对象：类名 对象名
Student stu1;
// 访问公有成员变量
stu1.name = "张三";
stu1.age = 18;
stu1.setScore(95.5); // 调用成员函数设置成绩
// 调用成员函数
stu1.showInfo();
// 创建第二个对象
Student stu2;
stu2.name = "李四";
stu2.age = 19;
stu2.setScore(105); // 无效成绩
stu2.showInfo();
return 0;
}
输出结果：
姓名：张三 年龄：18 成绩：95.5 成绩输入无效！ 姓名：李四 年龄：19 成绩：0
7.1.2 访问权限
C++ 类的成员有三种访问权限：
public：公有的，类内、类外均可访问；private：私有的，仅类内可访问（默认权限）；protected：受保护的，类内、子类可访问，类外不可访问。
示例：私有成员与封装
#include <iostream>
#include <string>
using namespace std;
class Student {
// 私有成员：类外不可直接访问
private:
string name;
int age;
double score;
// 公有成员函数：作为接口访问私有成员
public:
// 设置学生信息
void setInfo(string n, int a, double s) {
name = n;
// 年龄合法性校验
if (a >= 0 && a <= 120) {
age = a;
} else {
age = 0;
cout << "年龄输入无效，默认设为 0！" << endl;
}
// 成绩合法性校验
if (s >= 0 && s <= 100) {
score = s;
} else {
score = 0;
cout << "成绩输入无效，默认设为 0！" << endl;
}
}
// 获取姓名（只读）
string getName() {
return name;
}
// 显示信息
void showInfo() {
cout << "姓名：" << name << "，年龄：" << age << "，成绩：" << score << endl;
}
};
int main() {
Student stu;
// 错误：私有成员不可直接访问
// stu.name = "王五";
// 正确：通过公有成员函数访问
stu.setInfo("王五", 150, 98);
stu.showInfo();
// 获取姓名
cout << "学生姓名：" << stu.getName() << endl;
return 0;
}
输出结果：
年龄输入无效，默认设为 0！ 姓名：王五，年龄：0，成绩：98 学生姓名：王五
7.2 构造函数与析构函数
7.2.1 构造函数
构造函数是类的特殊成员函数，用于对象创建时初始化成员变量，特点：
- 函数名与类名相同；
- 无返回值（连 void 都没有）；
- 可重载；
- 创建对象时自动调用。
7.2.2 析构函数
析构函数用于对象销毁时释放资源，特点：
- 函数名是
~类名； - 无返回值、无参数；
- 不可重载；
- 对象销毁时自动调用。
示例：构造函数与析构函数
#include <iostream>
#include <string>
using namespace std;
class Person {
public:
// 无参构造函数
Person() {
cout << "无参构造函数调用！" << endl;
name = "未知";
age = 0;
}
// 有参构造函数（重载）
Person(string n, int a) {
cout << "有参构造函数调用！" << endl;
name = n;
age = a;
}
// 析构函数
~Person() {
cout << "析构函数调用：" << name << "对象销毁！" << endl;
}
void showInfo() {
cout << "姓名：" << name << "，年龄：" << age << endl;
}
private:
string name;
int age;
};
int main() {
// 创建对象 1：调用无参构造
Person p1;
p1.showInfo();
// 创建对象 2：调用有参构造
Person p2("张三", 20);
p2.showInfo();
return 0;
}
输出结果：
无参构造函数调用！ 姓名：未知，年龄：0 有参构造函数调用！ 姓名：张三，年龄：20 析构函数调用：张三对象销毁！ 析构函数调用：未知对象销毁！
八、C++ 基础实战案例
案例：学生成绩管理系统（控制台版）
功能：添加学生、显示所有学生、计算平均分、查找学生。
#include <iostream>
#include <string>
using namespace std;
// 定义学生类
class Student {
private:
string name;
int id; // 学号
double score; // 成绩
public:
// 构造函数
Student() : name(""), id(0), score(0.0) {}
Student(string n, int i, double s) : name(n), id(i), score(s) {}
// 获取成员变量
string getName() { return name; }
int getId() { return id; }
double getScore() { return score; }
// 显示学生信息
void showInfo() {
cout << "学号：" << id << "，姓名：" << name << "，成绩：" << score << endl;
}
};
// 成绩管理系统类
class ScoreSystem {
private:
Student students[100]; // 最多存储 100 个学生
int count; // 当前学生数量
public:
// 构造函数
ScoreSystem() : count(0) {}
// 添加学生
void addStudent() {
if (count >= 100) {
cout << "学生数量已达上限，无法添加！" << endl;
return;
}
string name;
int id;
double score;
cout << "请输入学生姓名：";
cin >> name;
cout << "请输入学生学号：";
cin >> id;
cout << "请输入学生成绩：";
cin >> score;
// 创建学生对象并添加到数组
students[count] = Student(name, id, score);
count++;
cout << "学生添加成功！" << endl;
}
// 显示所有学生
void showAllStudents() {
if (count == 0) {
cout << "暂无学生信息！" << endl;
return;
}
cout << "===== 所有学生信息 =====" << endl;
for (int i = 0; i < count; i++) {
students[i].showInfo();
}
}
// 计算平均分
void calculateAvg() {
if (count == 0) {
cout << "暂无学生信息，无法计算平均分！" << endl;
return;
}
double sum = 0.0;
for (int i = 0; i < count; i++) {
sum += students[i].getScore();
}
double avg = sum / count;
cout << "学生平均成绩：" << avg << endl;
}
// 按学号查找学生
void findStudentById() {
int id;
cout << "请输入要查找的学生学号：";
cin >> id;
for (int i = 0; i < count; i++) {
if (students[i].getId() == id) {
cout << "找到学生：" << endl;
students[i].showInfo();
return;
}
}
cout << "未找到学号为" << id << "的学生！" << endl;
}
};
// 主函数：菜单界面
int main() {
ScoreSystem system;
int choice;
while (true) {
cout << "\n===== 学生成绩管理系统 =====" << endl;
cout << "1. 添加学生" << endl;
cout << "2. 显示所有学生" << endl;
cout << "3. 计算平均分" << endl;
cout << "4. 按学号查找学生" << endl;
cout << "0. 退出系统" << endl;
cout << "请输入操作序号：";
cin >> choice;
switch (choice) {
case 1:
system.addStudent();
break;
case 2:
system.showAllStudents();
break;
case 3:
system.calculateAvg();
break;
case 4:
system.findStudentById();
break;
case 0:
cout << "退出系统，感谢使用！" << endl;
return 0;
default:
cout << "输入无效，请重新选择！" << endl;
}
}
}
运行示例：
===== 学生成绩管理系统 ===== 1. 添加学生 2. 显示所有学生 3. 计算平均分 4. 按学号查找学生 0. 退出系统 请输入操作序号：1 请输入学生姓名：张三 请输入学生学号：101 请输入学生成绩：95 学生添加成功！ ===== 学生成绩管理系统 ===== 1. 添加学生 2. 显示所有学生 3. 计算平均分 4. 按学号查找学生 0. 退出系统 请输入操作序号：2 ===== 所有学生信息 ===== 学号：101，姓名：张三，成绩：95 ===== 学生成绩管理系统 ===== 1. 添加学生 2. 显示所有学生 3. 计算平均分 4. 按学号查找学生 0. 退出系统 请输入操作序号：3 学生平均成绩：95 ===== 学生成绩管理系统 ===== 1. 添加学生 2. 显示所有学生 3. 计算平均分 4. 按学号查找学生 0. 退出系统 请输入操作序号：4 请输入要查找的学生学号：101 找到学生： 学号：101，姓名：张三，成绩：95 ===== 学生成绩管理系统 ===== 1. 添加学生 2. 显示所有学生 3. 计算平均分 4. 按学号查找学生 0. 退出系统 请输入操作序号：0 退出系统，感谢使用！
总结
核心知识点回顾
- 基础语法：C++ 程序以
main函数为入口，注释分为单行//和多行/* */，标识符命名需遵循规则，关键字不可自定义；变量需指定数据类型，常量可通过const或#define定义。 - 流程控制：选择结构（if/switch）用于条件判断，循环结构（for/while/do-while）用于重复执行代码，
break/continue可控制循环流程。 - 函数与数组：函数封装可重用代码，支持重载；数组存储同类型数据，一维数组通过下标访问，二维数组可看作'数组的数组'，数组名本质是指向首元素的指针。
- 指针：指针存储变量地址，通过
&取地址、*解引用，可实现传址调用，是 C++ 高效操作内存的核心。 - 面向对象基础：类封装属性和行为，通过访问权限（public/private/protected）实现数据保护；构造函数初始化对象，析构函数释放资源，对象是类的实例。
学习建议
- 多敲代码：C++ 是实践性极强的语言，每个知识点都要通过代码验证，从简单的 Hello World 到实战案例，逐步积累；
- 理解内存：指针、数组、类的内存布局是 C++ 的核心，需结合内存地址、字节大小等概念深入理解；
- 循序渐进：先掌握过程化编程（C 语言特性），再学习面向对象编程，最后拓展泛型编程、STL 等高级特性；
- 调试代码：学会使用 IDE 的调试功能（断点、监视变量），排查代码中的逻辑错误和语法错误。
C++ 的入门阶段重在打牢基础，掌握本文的核心知识点后，可进一步学习 STL（标准模板库）、异常处理、文件操作、继承与多态等内容，逐步向中高级进阶。