C++ 基础语法

本章将介绍 C++ 的基本语法元素，包括变量、数据类型、运算符和控制流程。

第一个 C++ 程序

让我们从经典的 "Hello World" 程序开始：

#include <iostream>  // 引入输入输出流头文件

// 主函数，程序入口
int main() {
    std::cout << "Hello, World!" << std::endl;  // 输出 Hello World
    return 0;  // 返回 0 表示程序正常结束
}

代码解析：

部分	说明
#include <iostream>	预处理指令，包含标准输入输出库
int main()	主函数，程序执行的起点
std::cout	标准输出流对象
<<	流插入运算符
std::endl	换行符
return 0	返回 0 表示程序正常退出

注释

C++ 支持两种注释方式：

// 单行注释：用于简短说明

/*
 * 多行注释
 * 可以跨越多行
 */

// TODO: 这是一个待办事项注释
// FIXME: 这是一个需要修复的注释

变量与数据类型

基本数据类型

C++ 提供以下基本数据类型：

类型	大小	范围	说明
char	1 字节	-128 ~ 127	字符类型
short	2 字节	-32768 ~ 32767	短整数
int	4 字节	-21亿 ~ 21亿	整数
long	4/8 字节	平台相关	长整数
long long	8 字节	极大	64位整数
float	4 字节	±3.4e38	单精度浮点
double	8 字节	±1.8e308	双精度浮点
bool	1 字节	true/false	布尔值

#include <iostream>
#include <climits>  // 用于查看类型范围

int main() {
    // 整数类型
    int age = 25;
    long population = 8000000000LL;
    short score = 90;
    
    // 浮点类型
    float price = 19.99f;      // f 后缀表示 float
    double pi = 3.14159265358979;
    
    // 字符类型
    char grade = 'A';
    
    // 布尔类型
    bool isStudent = true;
    
    // 输出
    std::cout << "年龄: " << age << std::endl;
    std::cout << "价格: " << price << std::endl;
    std::cout << "圆周率: " << pi << std::endl;
    std::cout << "等级: " << grade << std::endl;
    std::cout << "是学生: " << isStudent << std::endl;
    
    // 使用 sizeof 查看类型大小
    std::cout << "int 大小: " << sizeof(int) << " 字节" << std::endl;
    
    return 0;
}

类型修饰符

C++ 提供以下类型修饰符：

// 有符号 vs 无符号
int signedValue = -10;    // 有符号整数，可以是负数
unsigned int positiveValue = 10;  // 无符号整数，只能是非负数

// signed: 默认带符号
// unsigned: 不带符号，只能表示非负数

// short vs long
short smallInt = 32767;       // 短整数
long bigInt = 2147483647L;    // 长整数，加 L 后缀
long long veryBig = 9223372036854775807LL;  // 64位整数

auto 类型推导

C++11 引入了 auto 关键字，可以自动推导变量类型：

auto a = 10;        // int
auto b = 3.14;     // double
auto c = 'A';      // char
auto d = "hello";  // const char*

// 使用 auto 的好处：简化代码，特别是长类型名
std::vector<int>::iterator it = vec.begin();  // 繁琐
auto it = vec.begin();  // 简洁

类型别名（typedef / using）

// 使用 typedef（传统方式）
typedef long long int64_t;
typedef std::vector<std::string> StringVector;

// 使用 using（C++11 推荐）
using int64 = long long;
using StringVector = std::vector<std::string>;

运算符

算术运算符

int a = 10, b = 3;

std::cout << a + b << std::endl;  // 13 - 加法
std::cout << a - b << std::endl;  // 7  - 减法
std::cout << a * b << std::endl;  // 30 - 乘法
std::cout << a / b << std::endl;  // 3  - 整数除法
std::cout << a % b << std::endl;  // 1  - 取模（余数）

注意： 整数除法会截断小数部分。如需浮点结果，至少有一个操作数必须是浮点类型：

std::cout << 10 / 3 << std::endl;     // 3 （整数）
std::cout << 10.0 / 3 << std::endl;   // 3.33333 （浮点数）
std::cout << 10 / 3.0 << std::endl;   // 3.33333

赋值运算符

int x = 10;

x += 5;   // x = x + 5 -> x = 15
x -= 3;   // x = x - 3 -> x = 12
x *= 2;   // x = x * 2 -> x = 24
x /= 4;   // x = x / 4 -> x = 6
x %= 5;   // x = x % 5 -> x = 1

递增/递减运算符

int a = 5;

// 前缀：先递增/递减，再使用
std::cout << ++a << std::endl;  // 6，先加1再输出

// 后缀：先使用，再递增/递减
std::cout << a++ << std::endl;  // 5，先输出再加1

// 完整示例
int b = 5;
int c = ++b;  // b = 6, c = 6  前缀
int d = b++;  // d = 6, b = 7  后缀

比较运算符

int a = 5, b = 10;

std::cout << (a == b) << std::endl;  // false (0)
std::cout << (a != b) << std::endl;  // true  (1)
std::cout << (a < b) << std::endl;   // true
std::cout << (a > b) << std::endl;   // false
std::cout << (a <= b) << std::endl;  // true
std::cout << (a >= b) << std::endl;  // false

逻辑运算符

bool x = true, y = false;

std::cout << (x && y) << std::endl;  // false - 逻辑与
std::cout << (x || y) << std::endl;  // true  - 逻辑或
std::cout << (!x) << std::endl;       // false - 逻辑非

逗号运算符

// 逗号运算符：从左到右求值，整个表达式值为最后一个表达式的值
int a = (1, 2, 3);  // a = 3

// 常见用法：在 for 循环中
for (int i = 0, j = 10; i < j; i++, j--) {
    std::cout << i << " " << j << std::endl;
}

运算符优先级

优先级（从高到低）：
1. 括号 ( )
2. 一元运算符 ! ++ -- -（负号） *（解引用） &
3. 乘除模 * / %
4. 加减 + -
5. 比较 < <= > >=
6. 相等 == !=
7. 逻辑与 &&
8. 逻辑或 ||
9. 赋值 = += -= *= /= %=
10. 逗号 ,

控制流程

条件语句

if 语句

int score = 85;

if (score >= 90) {
    std::cout << "优秀" << std::endl;
} else if (score >= 80) {
    std::cout << "良好" << std::endl;
} else if (score >= 60) {
    std::cout << "及格" << std::endl;
} else {
    std::cout << "不及格" << std::endl;
}

嵌套 if

int age = 25;
bool isStudent = true;

if (age < 18) {
    std::cout << "未成年人" << std::endl;
} else {
    if (isStudent) {
        std::cout << "成年学生" << std::endl;
    } else {
        std::cout << "成年人" << std::endl;
    }
}

三目运算符

// 条件 ? 值1 : 值2
int a = 10, b = 20;
int max = (a > b) ? a : b;  // max = 20

// 等价于
int max;
if (a > b) {
    max = a;
} else {
    max = b;
}

switch 语句

char grade = 'B';

switch (grade) {
    case 'A':
        std::cout << "90-100分" << std::endl;
        break;
    case 'B':
        std::cout << "80-89分" << std::endl;
        break;
    case 'C':
        std::cout << "70-79分" << std::endl;
        break;
    case 'D':
        std::cout << "60-69分" << std::endl;
        break;
    default:
        std::cout << "不及格" << std::endl;
}

注意： 每个 case 后的 break 很重要，缺少 break 会导致"贯穿"：

int num = 2;
switch (num) {
    case 1:
        std::cout << "one" << std::endl;
        // 没有 break，会继续执行 case 2
    case 2:
        std::cout << "two" << std::endl;
        break;
    case 3:
        std::cout << "three" << std::endl;
        break;
}
// 输出: two

switch 表达式（C++17）

// C++17 支持 switch 作为表达式
int num = 2;
std::string result = [num]() -> std::string {
    switch (num) {
        case 1: return "one";
        case 2: return "two";
        default: return "other";
    }
}();

循环语句

for 循环

// 传统 for 循环
for (int i = 0; i < 5; i++) {
    std::cout << i << " ";
}
// 输出: 0 1 2 3 4

// 范围 for 循环（C++11）
int arr[] = {1, 2, 3, 4, 5};
for (int num : arr) {
    std::cout << num << " ";
}
// 输出: 1 2 3 4 5

while 循环

int i = 0;
while (i < 5) {
    std::cout << i << " ";
    i++;
}
// 输出: 0 1 2 3 4

do-while 循环

int i = 0;
do {
    std::cout << i << " ";
    i++;
} while (i < 5);
// 输出: 0 1 2 3 4

注意： do-while 至少会执行一次，无论条件是否满足。

循环控制

// break: 跳出整个循环
for (int i = 0; i < 10; i++) {
    if (i == 5) break;
    std::cout << i << " ";
}
// 输出: 0 1 2 3 4

// continue: 跳过本次循环，继续下一次
for (int i = 0; i < 5; i++) {
    if (i == 2) continue;
    std::cout << i << " ";
}
// 输出: 0 1 3 4

范围 for 循环详解（C++11）

#include <vector>
#include <string>

int main() {
    // 遍历数组
    int nums[] = {1, 2, 3, 4, 5};
    for (int n : nums) {
        std::cout << n << " ";
    }
    std::cout << std::endl;
    
    // 遍历 vector
    std::vector<std::string> names = {"Alice", "Bob", "Charlie"};
    for (const auto& name : names) {  // 使用 const 引用避免拷贝
        std::cout << name << " ";
    }
    std::cout << std::endl;
    
    // 遍历字符串
    std::string str = "Hello";
    for (char c : str) {
        std::cout << c << "-";
    }
    std::cout << std::endl;
    
    return 0;
}

常量

const 关键字

const int MAX_SIZE = 100;      // 常量，整数
const double PI = 3.14159;    // 常量，浮点数
const char* MSG = "Warning";  // 常量，字符串

// const 在 C++ 中的含义：只读
// MAX_SIZE = 200;  // 错误！不能修改

// const 与指针
const int* p1;      // 指向常量整数的指针，不能通过 p1 修改值
int const* p2;      // 同上，等价写法
int* const p3;      // 常量指针，指针本身不能改变
const int* const p4;  // 指向常量的常量指针，两者都不能改变

constexpr（C++11）

constexpr 用于编译时常量：

// 编译器在编译时计算
constexpr int SQUARE(int x) { return x * x; }
constexpr int size = SQUARE(5);  // size = 25

// constexpr 函数可以在编译时求值
constexpr int max(int a, int b) {
    return a > b ? a : b;
}

枚举

// 传统枚举
enum Color {
    RED = 0,
    GREEN = 1,
    BLUE = 2
};

Color c = RED;
std::cout << c << std::endl;  // 输出 0

// 枚举类（C++11，推荐）
enum class Level {
    LOW,
    MEDIUM,
    HIGH
};

Level l = Level::LOW;
// std::cout << l << std::endl;  // 错误！需要类型转换
std::cout << static_cast<int>(l) << std::endl;  // 输出 0

练习

1. 编写程序，计算圆的面积（使用 PI * r * r）
2. 编写程序，判断一个数是否为偶数
3. 编写程序，输出 1 到 100 的所有整数
4. 编写程序，计算 1 到 100 的和

小结

本章学习了：

1. 基本程序结构：#include、主函数、输入输出
2. 变量与数据类型：基本类型、类型修饰符、auto
3. 运算符：算术、赋值、比较、逻辑
4. 控制流程：条件语句、循环语句、循环控制
5. 常量：const、constexpr、枚举

下一步

接下来让我们学习 C++ 函数，了解如何组织代码和实现代码复用。