C++ 语言基础：从入门到实践指南

本指南系统梳理 C++ 核心语法与编程范式，涵盖程序结构、数据类型、控制流、函数、数组、指针及面向对象基础，辅以可运行示例与阶梯式实践任务，助力开发者构建扎实的 C++ 工程能力。

1. C++ 程序基本结构

每个合法的 C++ 程序必须包含且仅包含一个 main 函数，作为操作系统调用的程序入口点。标准程序结构如下：

#include <iostream>

int main() {
    std::cout << "Hello, C++!" << std::endl;
    return 0;
}
​

关键组件解析

组件	说明	注意事项
#include <iostream>	预处理指令，引入标准输入输出流库	必须在文件顶部；尖括号表示系统头文件
int main()	主函数，返回整型值	返回 0 表示成功；非零值通常表示异常退出
std::cout	标准输出流对象	std:: 是标准命名空间前缀，避免全局污染
<<	流插入运算符	支持链式调用，如 std::cout << a << b << c
std::endl	操纵符	输出换行并刷新缓冲区；等价于 '\n' + std::flush

最佳实践：现代 C++ 推荐显式使用 std:: 前缀而非 using namespace std;，以避免命名冲突和二义性。

实践练习 1

编写程序，输出个性化欢迎信息：

#include <iostream>
int main() {
    std::cout << "Hello, Zhang San! Welcome to C++ world!" << std::endl;
    return 0;
}
​

2. 变量与数据类型

C++ 是静态强类型语言，所有变量必须在使用前声明类型，编译器据此分配内存并校验操作合法性。

基础数据类型（典型实现尺寸）

类型	说明	尺寸（字节）	取值范围（典型）	示例
int	有符号整数	4	-2,147,483,648 ~ 2,147,483,647	int count = 100;
short	短整型	2	-32,768 ~ 32,767	short year = 2024;
long long	长长整型	8	±9.2×10¹⁸	long long id = 123456789012345LL;
unsigned int	无符号整型	4	0 ~ 4,294,967,295	unsigned int flags = 0xFF;
float	单精度浮点	4	±3.4×10³⁸（6位有效数字）	float pi = 3.14159f;
double	双精度浮点	8	±1.7×10³⁰⁸（15位有效数字）	double gravity = 9.80665;
char	字符（ASCII/UTF-8）	1	-128 ~ 127 或 0 ~ 255	char grade = 'A';
bool	布尔值	1	true / false	bool active = true;

变量操作规范

// 声明（不初始化）
int temperature;

// 声明并初始化（推荐 C++11 以后写法）
double price{99.99};
char initial{'J'};
bool isStudent{false};

// 多变量声明（清晰分隔）
int x{10}, y{20}, z{30};

// 赋值（可重复）
temperature = 25;
price = 89.50;
​

变量命名规则与建议

• ✅ 允许字符：字母、数字、下划线（_）
• ✅ 必须以字母或下划线开头
• ❌ 禁止使用 C++ 关键字（int, class, return 等）
• ⚠️ 区分大小写（count ≠ Count）
• 💡 推荐使用驼峰命名法（studentScore, maxBufferSize）或下划线分隔（student_score, buffer_size）
• 💡 避免单字母变量（i, j, k 仅限简单循环索引）

实践练习 2

输出个人基础信息：

#include <iostream>
int main() {
    int age{22};
    double height{1.75};  // 米
    char initial{'L'};
    bool isStudent{true};

    std::cout << "年龄: " << age << " 岁\n";
    std::cout << "身高: " << height << " 米\n";
    std::cout << "姓名首字母: " << initial << "\n";
    std::cout << "是否为学生: " << (isStudent ? "是" : "否") << "\n";
    return 0;
}
​

3. 运算符与表达式

C++ 提供完备的运算符集合，支持数值计算、逻辑判断与位操作。

运算符分类与优先级（由高到低）

类别	运算符	说明	示例
一元	++, --, !, -, *, &	自增/减、逻辑非、取负、解引用、取地址	x++, !valid, *ptr
算术	*, /, %	乘、除、取余	a * b, 10 % 3 → 1
算术	+, -	加、减	a + b, x - y
关系	<, <=, >, >=	比较大小	a < b, score >= 90
相等	==, !=	相等、不等	x == 5, c != 'q'
逻辑与	&&	仅当两边均为真时返回真	age >= 18 && score > 60
逻辑或	`		`
条件	?:	三元条件运算符	max = (a > b) ? a : b
赋值	=, +=, -= 等	赋值与复合赋值	sum += value, x = y = 5

注意：==（比较）与 =（赋值）不可混淆；if (x = 5) 是赋值语句，恒为真（除非 x 是 bool 类型）。

完整运算示例

#include <iostream>
int main() {
    int a{10}, b{3};
    double pi{3.14159};

    // 算术运算
    std::cout << "和: " << a + b << "\n";           // 13
    std::cout << "余数: " << a % b << "\n";         // 1

    // 关系与逻辑
    bool isEven = (a % 2 == 0);                    // true
    bool isLeap = (2024 % 4 == 0 && 2024 % 100 != 0) || (2024 % 400 == 0); // true

    // 三元运算符
    std::cout << "较大值: " << ((a > b) ? a : b) << "\n"; // 10

    // 复合赋值
    a += 5;  // 等价于 a = a + 5
    std::cout << "a 更新后: " << a << "\n"; // 15

    return 0;
}
​

实践练习 3

实现闰年判断与基础运算验证：

#include <iostream>
int main() {
    int year{2024};
    // 闰年：能被4整除但不能被100整除，或能被400整除
    bool isLeap = (year % 4 == 0 && year % 100 != 0) || (year % 400 == 0);
    std::cout << year << "年是" << (isLeap ? "" : "非") << "闰年\n";

    int x{15}, y{4};
    std::cout << x << " + " << y << " = " << (x + y) << "\n";
    std::cout << x << " % " << y << " = " << (x % y) << "\n";
    std::cout << "x 是偶数: " << (x % 2 == 0 ? "是" : "否") << "\n";
    return 0;
}
​

4. 输入与输出流

C++ 使用 <iostream> 库提供类型安全的流式 I/O，替代 C 风格的 printf/scanf。

标准流对象

对象	方向	说明
std::cin	输入	关联标准输入（键盘）
std::cout	输出	关联标准输出（控制台）
std::cerr	输出	关联标准错误（不缓冲，立即显示）
std::clog	输出	关联标准日志（带缓冲）

输入操作详解

#include <iostream>
#include <string>
#include <limits>

int main() {
    std::string name;
    int age;

    std::cout << "请输入姓名: ";
    std::getline(std::cin, name); // 读取整行（含空格）

    std::cout << "请输入年龄: ";
    while (!(std::cin >> age)) { // 输入验证
        std::cin.clear(); // 清除错误标志
        std::cin.ignore(std::numeric_limits<std::streamsize>::max(), '\n'); // 清空缓冲区
        std::cout << "输入无效，请输入整数: ";
    }

    std::cout << "你好，" << name << "！你今年 " << age << " 岁。\n";
    return 0;
}
​

关键点：

• std::cin >> var 读取空白分隔的单词，遇到空格/换行停止
• std::getline(std::cin, str) 读取整行（推荐用于字符串输入）
• 输入失败时需手动清除错误状态和缓冲区，否则后续输入将跳过

实践练习 4

计算两数四则运算：

#include <iostream>
int main() {
    double a, b;
    std::cout << "输入第一个数: "; std::cin >> a;
    std::cout << "输入第二个数: "; std::cin >> b;

    std::cout << a << " + " << b << " = " << (a + b) << "\n";
    std::cout << a << " - " << b << " = " << (a - b) << "\n";
    std::cout << a << " * " << b << " = " << (a * b) << "\n";
    if (b != 0) {
        std::cout << a << " / " << b << " = " << (a / b) << "\n";
    } else {
        std::cout << "除零错误：第二个数不能为零\n";
    }
    return 0;
}
​

5. 控制流语句

程序逻辑通过条件分支与循环实现动态行为。

条件语句

#include <iostream>
int main() {
    int score;
    std::cout << "请输入成绩: "; std::cin >> score;

    // if-else 链
    if (score >= 90) {
        std::cout << "等级：A\n";
    } else if (score >= 80) {
        std::cout << "等级：B\n";
    } else if (score >= 70) {
        std::cout << "等级：C\n";
    } else if (score >= 60) {
        std::cout << "等级：D\n";
    } else {
        std::cout << "等级：F（不及格）\n";
    }

    // switch（仅适用于整型/枚举常量）
    char grade = 'B';
    switch (grade) {
        case 'A': std::cout << "优秀\n"; break;
        case 'B': std::cout << "良好\n"; break;
        case 'C': std::cout << "中等\n"; break;
        case 'D': std::cout << "及格\n"; break;
        default:  std::cout << "无效等级\n"; break;
    }
    return 0;
}
​

循环语句

循环类型	适用场景	特点
for	已知迭代次数	初始化、条件、更新集中表达
while	条件驱动循环	先判断后执行，可能零次执行
do-while	至少执行一次	先执行后判断

#include <iostream>
int main() {
    // for 循环：1 到 100 求和
    long sum = 0;
    for (int i = 1; i <= 100; ++i) {
        sum += i;
    }
    std::cout << "1 到 100 的和: " << sum << "\n"; // 5050

    // while 循环：猜数字游戏框架
    int target = 42, guess;
    std::cout << "已生成 1-100 的随机数，请猜测: ";
    while (std::cin >> guess) {
        if (guess == target) {
            std::cout << "恭喜！猜对了！\n";
            break;
        } else if (guess < target) {
            std::cout << "太小了，再试: ";
        } else {
            std::cout << "太大了，再试: ";
        }
    }

    return 0;
}
​

实践练习 5

完整闰年判断程序：

#include <iostream>
int main() {
    int year;
    std::cout << "请输入年份: "; std::cin >> year;

    bool isLeap = false;
    if (year % 400 == 0) {
        isLeap = true;
    } else if (year % 100 == 0) {
        isLeap = false;
    } else if (year % 4 == 0) {
        isLeap = true;
    }

    std::cout << year << "年" << (isLeap ? "是" : "不是") << "闰年\n";
    return 0;
}
​

6. 函数：模块化编程基石

函数封装可重用逻辑，提升代码可读性、可维护性与可测试性。

函数定义与调用

#include <iostream>

// 函数声明（可选，若定义在调用前）
int max(int a, int b);

// 函数定义
int max(int a, int b) {
    return (a > b) ? a : b;
}

void printGreeting(const std::string& name) { // 引用传参避免拷贝
    std::cout << "Hello, " << name << "!\n";
}

int factorial(int n) {
    if (n <= 1) return 1;
    return n * factorial(n - 1); // 递归实现
}

int main() {
    std::cout << "较大值: " << max(15, 8) << "\n";
    printGreeting("Alice");
    std::cout << "5! = " << factorial(5) << "\n"; // 120
    return 0;
}
​

关键特性说明

• 参数传递：默认值传递（拷贝）；const & 传递大对象提升效率
• 返回值：void 表示无返回值；非 void 函数必须有 return 语句
• 作用域：函数内声明的变量为局部变量，生命周期限于函数执行期
• 函数重载：同一作用域内可定义同名函数，参数列表必须不同

实践练习 6

实现完整阶乘程序：

#include <iostream>

long long factorial(int n) {
    if (n < 0) return -1; // 错误码
    long long result = 1;
    for (int i = 2; i <= n; ++i) {
        result *= i;
    }
    return result;
}

int main() {
    int n;
    std::cout << "输入非负整数 n: "; std::cin >> n;
    long long fact = factorial(n);
    if (fact == -1) {
        std::cout << "错误：n 不能为负数\n";
    } else {
        std::cout << n << "! = " << fact << "\n";
    }
    return 0;
}
​

7. 数组：同构数据集合

数组在连续内存中存储固定数量的同类型元素，支持高效随机访问。

声明、初始化与访问

#include <iostream>
#include <iomanip>

int main() {
    // 静态数组：编译时确定大小
    const int SIZE = 5;
    int scores[SIZE] = {85, 92, 78, 96, 88}; // 部分初始化，其余为0

    // 访问元素（索引从0开始）
    std::cout << "第一个成绩: " << scores[0] << "\n"; // 85
    scores[2] = 80; // 修改第三项

    // 遍历数组
    std::cout << "所有成绩:\n";
    for (int i = 0; i < SIZE; ++i) {
        std::cout << "scores[" << i << "] = " << scores[i] << "\n";
    }

    // 计算平均值
    double sum = 0;
    for (int score : scores) { // C++11 范围 for 循环
        sum += score;
    }
    std::cout << "平均分: " << std::fixed << std::setprecision(2) << (sum / SIZE) << "\n";

    return 0;
}
​

字符串数组与 C 风格字符串

#include <iostream>
#include <string>

int main() {
    // C 风格字符串（字符数组）
    char city[20] = "Beijing"; // 自动添加 '\0' 终止符

    // C++ string（推荐）
    std::string cities[] = {"Beijing", "Shanghai", "Guangzhou", "Shenzhen", "Hangzhou"};

    std::cout << "正序输出:\n";
    for (const auto& c : cities) {
        std::cout << c << "\n";
    }

    std::cout << "逆序输出:\n";
    for (int i = 4; i >= 0; --i) {
        std::cout << cities[i] << "\n";
    }

    return 0;
}
​

实践练习 7

数组最大值函数实现：

#include <iostream>
#include <climits>

int findMax(const int arr[], int size) {
    if (size <= 0) return INT_MIN;
    int maxVal = arr[0];
    for (int i = 1; i < size; ++i) {
        if (arr[i] > maxVal) maxVal = arr[i];
    }
    return maxVal;
}

int main() {
    const int SIZE = 10;
    int numbers[SIZE];
    std::cout << "请输入 " << SIZE << " 个整数:\n";
    for (int i = 0; i < SIZE; ++i) {
        std::cin >> numbers[i];
    }

    int maxVal = findMax(numbers, SIZE);
    std::cout << "数组最大值: " << maxVal << "\n";
    return 0;
}
​

8. 指针：内存地址的直接操作

指针存储变量地址，实现间接访问、动态内存管理与高效数据结构。

基础操作与安全实践

#include <iostream>

int main() {
    int value = 42;
    int* ptr = &value; // ptr 存储 value 的地址

    std::cout << "value 值: " << value << "\n";           // 42
    std::cout << "value 地址: " << &value << "\n";       // 如 0x7ffd1234
    std::cout << "ptr 存储的地址: " << ptr << "\n";       // 同上
    std::cout << "ptr 解引用值: " << *ptr << "\n";        // 42

    *ptr = 100; // 通过指针修改 value
    std::cout << "修改后 value: " << value << "\n";       // 100

    // 安全指针初始化
    int* safePtr = nullptr; // C++11 推荐替代 NULL
    if (safePtr != nullptr) {
        std::cout << *safePtr << "\n"; // 避免解引用空指针
    }

    return 0;
}
​

指针与数组的等价性

#include <iostream>

int main() {
    int arr[] = {10, 20, 30, 40, 50};
    const int SIZE = sizeof(arr) / sizeof(arr[0]);

    int* ptr = arr; // 等价于 &arr[0]

    std::cout << "数组遍历（指针方式）:\n";
    for (int i = 0; i < SIZE; ++i) {
        std::cout << "arr[" << i << "] = " << *(ptr + i) << "\n";
        // 或 std::cout << "ptr[" << i << "] = " << ptr[i] << "\n";
    }

    // 指针算术：ptr + i 指向第 i 个元素
    std::cout << "ptr + 2 指向: " << *(ptr + 2) << "\n"; // 30

    return 0;
}
​

实践练习 8

指针求和函数：

#include <iostream>

int sumArray(const int* arr, int size) {
    if (arr == nullptr || size <= 0) return 0;
    int sum = 0;
    for (int i = 0; i < size; ++i) {
        sum += *(arr + i); // 等价于 arr[i]
    }
    return sum;
}

int main() {
    int data[] = {1, 2, 3, 4, 5};
    const int SIZE = 5;
    std::cout << "数组和: " << sumArray(data, SIZE) << "\n"; // 15
    return 0;
}
​

9. 类与对象：面向对象编程入门

类封装数据（成员变量）与行为（成员函数），支持封装、继承与多态三大特性。

类定义与对象实例化

#include <iostream>
#include <string>

class Rectangle {
private:
    double width_;
    double height_;

public:
    // 构造函数（C++11 委托构造）
    Rectangle() : Rectangle(1.0, 1.0) {}
    Rectangle(double w, double h) : width_{w}, height_{h} {}

    // 公有接口（访问器与修改器）
    void setWidth(double w) { width_ = (w > 0) ? w : 1.0; }
    void setHeight(double h) { height_ = (h > 0) ? h : 1.0; }
    double getWidth() const { return width_; }
    double getHeight() const { return height_; }

    // 行为方法
    double getArea() const { return width_ * height_; }
    double getPerimeter() const { return 2 * (width_ + height_); }
    void display() const {
        std::cout << "矩形[宽=" << width_ << ", 高=" << height_
                  << "] → 面积=" << getArea() << ", 周长=" << getPerimeter() << "\n";
    }
};

int main() {
    Rectangle rect1(5.0, 3.0);
    rect1.display(); // 矩形[宽=5, 高=3] → 面积=15, 周长=16

    Rectangle rect2;
    rect2.setWidth(4.5);
    rect2.setHeight(2.0);
    rect2.display(); // 矩形[宽=4.5, 高=2] → 面积=9, 周长=13

    return 0;
}
​

核心概念解析

• 封装：private 成员隐藏实现细节，仅通过 public 接口交互
• 构造函数：对象创建时自动调用，用于初始化成员变量
• const 成员函数：不修改对象状态，可被 const 对象调用
• 命名约定：成员变量后缀 _（如 width_）避免与参数名冲突

实践练习 9

完整学生类实现：

#include <iostream>
#include <string>

class Student {
private:
    std::string name_;
    int age_;
    double score_;

public:
    Student(const std::string& name, int age, double score)
        : name_{name}, age_{age}, score_{score} {}

    void setName(const std::string& name) { name_ = name; }
    void setAge(int age) { age_ = (age > 0) ? age : 18; }
    void setScore(double score) { score_ = (score >= 0 && score <= 100) ? score : 0; }

    std::string getName() const { return name_; }
    int getAge() const { return age_; }
    double getScore() const { return score_; }

    void displayInfo() const {
        std::cout << "学生信息：姓名=" << name_ << ", 年龄=" << age_
                  << ", 分数=" << score_ << "\n";
    }
};

int main() {
    Student stu("Li Si", 20, 87.5);
    stu.displayInfo(); // 学生信息：姓名=Li Si, 年龄=20, 分数=87.5

    stu.setScore(92.0);
    stu.displayInfo(); // 学生信息：姓名=Li Si, 年龄=20, 分数=92

    return 0;
}
​

总结：构建坚实的 C++ 编程基础

C++ 作为兼具高性能与表达力的系统级编程语言，其基础体系涵盖程序结构、类型系统、运算逻辑、I/O 机制、流程控制、函数抽象、内存布局（数组/指针）及面向对象建模九大核心维度。掌握这些内容不仅是语法层面的熟悉，更是建立计算思维与工程化开发习惯的关键起点。

• 语法严谨性：C++ 强类型与显式内存管理要求开发者对数据表示与生命周期有深刻理解
• 实践驱动性：每个知识点均配套可验证的实践任务，强化“写-编译-调试-优化”闭环能力
• 演进兼容性：示例代码遵循 C++11 及以上标准，兼顾现代特性（如范围 for、nullptr、委托构造）与广泛兼容性

下一步建议：深入学习标准模板库（STL）容器与算法、智能指针与 RAII 资源管理、异常处理机制，以及现代 C++ 的移动语义与并发编程模型。持续编码实践与开源项目参与是深化 C++ 能力的最有效路径。

关键词：C++ 入门教程、C++ 基础语法、C++ 面向对象、C++ 指针、C++ 数组、C++ 函数、C++ 控制流、C++ 输入输出、C++ 类与对象