C++ 基础入门实战指南

编译运行：

若使用 IDE（如 Visual Studio），直接点击 '运行' 按钮即可。

若使用 GCC 编译器，在终端执行：

g++ hello.cpp -o hello
./hello

二、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++ 语言预留的特殊单词，具有固定含义，不能作为标识符使用。常见关键字如下：

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++ 的数据类型分为基本数据类型和复合数据类型，基础阶段重点掌握基本数据类型：

示例：数据类型大小与取值

#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 算术运算符

#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 赋值运算符

#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），常用于条件判断：

#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 逻辑运算符

逻辑运算符用于组合多个条件，返回布尔值：

#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 = &num;

    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. 基础语法：C++ 程序以 main 函数为入口，注释分为单行 // 和多行 /* */，标识符命名需遵循规则，关键字不可自定义；变量需指定数据类型，常量可通过 const 或 #define 定义。
2. 流程控制：选择结构（if/switch）用于条件判断，循环结构（for/while/do-while）用于重复执行代码，break/continue 可控制循环流程。
3. 函数与数组：函数封装可重用代码，支持重载；数组存储同类型数据，一维数组通过下标访问，二维数组可看作'数组的数组'，数组名本质是指向首元素的指针。
4. 指针：指针存储变量地址，通过 & 取地址、* 解引用，可实现传址调用，是 C++ 高效操作内存的核心。
5. 面向对象基础：类封装属性和行为，通过访问权限（public/private/protected）实现数据保护；构造函数初始化对象，析构函数释放资源，对象是类的实例。

学习建议

1. 多敲代码：C++ 是实践性极强的语言，每个知识点都要通过代码验证，从简单的 Hello World 到实战案例，逐步积累；
2. 理解内存：指针、数组、类的内存布局是 C++ 的核心，需结合内存地址、字节大小等概念深入理解；
3. 循序渐进：先掌握过程化编程（C 语言特性），再学习面向对象编程，最后拓展泛型编程、STL 等高级特性；
4. 调试代码：学会使用 IDE 的调试功能（断点、监视变量），排查代码中的逻辑错误和语法错误。

C++ 的入门阶段重在打牢基础，掌握本文的核心知识点后，可进一步学习 STL（标准模板库）、异常处理、文件操作、继承与多态等内容，逐步向中高级进阶。