基础语法

本章将介绍C++的基础语法，包括变量、常量、关键字和输入输出操作。

变量

变量的定义

#include <iostream>
using namespace std;

int main() {
    // 变量定义的基本语法：数据类型 变量名;
    
    // 定义整型变量
    int age;          // 定义一个整型变量age
    
    // 定义浮点型变量
    float height;     // 定义一个单精度浮点变量
    double weight;    // 定义一个双精度浮点变量
    
    // 定义字符变量
    char grade;       // 定义一个字符变量
    
    // 定义布尔变量
    bool isStudent;   // 定义一个布尔变量
    
    // 定义字符串变量（需要<string>头文件）
    // string name;   // 定义一个字符串变量
    
    return 0;
}

变量的初始化

#include <iostream>
#include <string>
using namespace std;

int main() {
    // ============ 初始化方式 ============
    
    // 方式1：赋值初始化（传统方式）
    int a = 10;
    
    // 方式2：直接初始化
    int b(20);
    
    // 方式3：列表初始化（C++11推荐）
    int c{30};          // 最安全的初始化方式
    int d = {40};       // 等价写法
    
    // 方式4：默认初始化
    int e;              // 未初始化，值不确定（危险）
    int f{};            // 初始化为0（安全）
    
    
    // ============ 各种类型的初始化 ============
    
    // 整型初始化
    int num1 = 100;
    int num2(200);
    int num3{300};
    
    // 浮点型初始化
    float pi = 3.14f;       // f后缀表示float类型
    double e_val{2.71828};  // 默认小数是double类型
    
    // 字符初始化
    char ch1 = 'A';         // 单引号表示字符
    char ch2{'B'};
    
    // 布尔初始化
    bool flag1 = true;
    bool flag2{false};
    
    // 字符串初始化
    string name1 = "张三";      // 双引号表示字符串
    string name2("李四");
    string name3{"王五"};
    
    
    // ============ 初始化注意事项 ============
    
    // 列表初始化会检查窄化转换（narrowing conversion）
    int x = 3.14;    // 警告：浮点转整型，丢失精度
    // int y{3.14};  // 错误：列表初始化不允许窄化转换
    
    cout << "x = " << x << endl;  // x = 3
    
    return 0;
}

变量命名规则

#include <iostream>
using namespace std;

int main() {
    // ============ 合法的变量名 ============
    
    int age;           // 字母开头
    int _count;        // 下划线开头
    int studentAge;    // 驼峰命名
    int student_age;   // 下划线命名
    int age2;          // 包含数字
    int MAX_SIZE;      // 常量风格（全大写）
    
    
    // ============ 非法的变量名 ============
    
    // int 2age;        // 错误：不能以数字开头
    // int my-name;     // 错误：不能包含连字符
    // int int;         // 错误：不能使用关键字
    // int class;       // 错误：class是关键字
    // int my var;      // 错误：不能包含空格
    
    
    // ============ 命名建议 ============
    
    // 1. 使用有意义的名称
    int studentCount = 30;    // 好：见名知意
    // int x = 30;            // 不好：含义不明
    
    // 2. 遵循命名风格
    int maxScore = 100;       // 小驼峰：变量、函数
    // int MaxScore = 100;    // 大驼峰：类名
    // int MAX_SCORE = 100;   // 全大写：常量
    
    // 3. 避免使用单字母（循环变量除外）
    for (int i = 0; i < 10; i++) {  // 循环变量i是惯例
        cout << i << " ";
    }
    cout << endl;
    
    return 0;
}

常量

const关键字

#include <iostream>
using namespace std;

int main() {
    // ============ const定义常量 ============
    
    // const修饰的变量不能被修改
    const int MAX_SIZE = 100;
    const double PI = 3.14159;
    const string APP_NAME = "MyApp";
    
    // MAX_SIZE = 200;  // 错误：不能修改常量
    
    cout << "最大尺寸: " << MAX_SIZE << endl;
    cout << "圆周率: " << PI << endl;
    cout << "应用名称: " << APP_NAME << endl;
    
    
    // ============ const与指针 ============
    
    int value = 10;
    int another = 20;
    
    // 指向常量的指针（底层const）
    const int* ptr1 = &value;
    // *ptr1 = 30;      // 错误：不能通过ptr1修改值
    ptr1 = &another;     // 正确：可以改变ptr1指向
    
    // 常量指针（顶层const）
    int* const ptr2 = &value;
    *ptr2 = 30;          // 正确：可以修改值
    // ptr2 = &another;  // 错误：不能改变ptr2指向
    
    // 指向常量的常量指针
    const int* const ptr3 = &value;
    // *ptr3 = 40;       // 错误：不能修改值
    // ptr3 = &another;  // 错误：不能改变指向
    
    cout << "value = " << value << endl;
    
    return 0;
}

constexpr关键字

#include <iostream>
using namespace std;

// constexpr函数：编译时计算
constexpr int square(int x) {
    return x * x;
}

// constexpr变量：编译时常量
constexpr int MAX_BUFFER = 1024;

int main() {
    // ============ constexpr vs const ============
    
    // const：运行时常量（可能）
    const int a = 10;
    
    // constexpr：编译时常量（确定）
    constexpr int b = 20;
    
    // constexpr变量必须在编译时确定值
    constexpr int c = a + b;  // 正确：编译时可计算
    // constexpr int d = a + rand();  // 错误：运行时才能确定
    
    
    // ============ constexpr函数 ============
    
    // 编译时计算
    constexpr int sq5 = square(5);  // 编译时计算为25
    
    // 运行时也可以使用
    int x = 6;
    int sqx = square(x);  // 运行时计算
    
    cout << "square(5) = " << sq5 << endl;
    cout << "square(" << x << ") = " << sqx << endl;
    
    
    // ============ constexpr数组大小 ============
    
    constexpr int ARRAY_SIZE = 5;
    int arr[ARRAY_SIZE] = {1, 2, 3, 4, 5};  // 正确：数组大小必须是编译时常量
    
    for (int i = 0; i < ARRAY_SIZE; i++) {
        cout << arr[i] << " ";
    }
    cout << endl;
    
    return 0;
}

宏定义常量

#include <iostream>
using namespace std;

// ============ 宏定义 ============

// 定义常量（不推荐，建议用const或constexpr）
#define PI 3.14159
#define MAX_SIZE 100
#define NEW_LINE '\n'

// 定义宏函数（注意括号！）
#define SQUARE(x) ((x) * (x))
#define MAX(a, b) ((a) > (b) ? (a) : (b))

// 多行宏定义
#define PRINT_INFO(name, age) \
    cout << "姓名: " << name << endl; \
    cout << "年龄: " << age << endl;

int main() {
    // 使用宏常量
    cout << "PI = " << PI << NEW_LINE;
    cout << "MAX_SIZE = " << MAX_SIZE << endl;
    
    // 使用宏函数
    cout << "SQUARE(5) = " << SQUARE(5) << endl;
    cout << "MAX(10, 20) = " << MAX(10, 20) << endl;
    
    // 宏定义的陷阱
    int x = 5;
    
    // 注意：宏是文本替换，可能导致意外行为
    // SQUARE(x++) 展开为 ((x++) * (x++))
    // cout << SQUARE(x++) << endl;  // 危险！x会被自增两次
    
    // 推荐使用内联函数或constexpr代替宏
    auto safeSquare = [](int n) { return n * n; };
    cout << "safeSquare(x++) = " << safeSquare(x++) << endl;
    
    // 使用多行宏
    PRINT_INFO("张三", 25);
    
    return 0;
}

枚举常量

#include <iostream>
using namespace std;

// ============ 传统枚举 ============

// 定义枚举类型
enum Color {
    RED,        // 默认值为0
    GREEN,      // 默认值为1
    BLUE        // 默认值为2
};

// 指定值的枚举
enum Weekday {
    MONDAY = 1,
    TUESDAY = 2,
    WEDNESDAY = 3,
    THURSDAY = 4,
    FRIDAY = 5,
    SATURDAY = 6,
    SUNDAY = 7
};

// 可以有相同值的枚举项
enum Direction {
    UP = 1,
    DOWN = 2,
    LEFT = 3,
    RIGHT = 4,
    NORTH = UP,    // 与UP相同
    SOUTH = DOWN   // 与DOWN相同
};


// ============ 强类型枚举（C++11） ============

// enum class：更安全的枚举
enum class Status {
    OK,
    ERROR,
    PENDING
};

enum class Priority : char {  // 指定底层类型
    LOW = 'L',
    MEDIUM = 'M',
    HIGH = 'H'
};

int main() {
    // 使用传统枚举
    Color myColor = RED;
    cout << "颜色值: " << myColor << endl;  // 输出0
    
    Weekday today = WEDNESDAY;
    cout << "今天是星期" << today << endl;  // 输出3
    
    // 传统枚举可以隐式转换为整数
    int colorValue = myColor;  // 隐式转换
    cout << "颜色整数值: " << colorValue << endl;
    
    
    // 使用强类型枚举
    Status status = Status::OK;  // 需要使用作用域
    
    // 必须显式转换
    // int s = status;  // 错误：不能隐式转换
    int s = static_cast<int>(status);  // 显式转换
    cout << "状态值: " << s << endl;
    
    // 使用指定类型的枚举
    Priority p = Priority::HIGH;
    char pc = static_cast<char>(p);
    cout << "优先级: " << pc << endl;
    
    
    // switch与枚举配合使用
    switch (myColor) {
        case RED:
            cout << "红色" << endl;
            break;
        case GREEN:
            cout << "绿色" << endl;
            break;
        case BLUE:
            cout << "蓝色" << endl;
            break;
    }
    
    return 0;
}

关键字

#include <iostream>
using namespace std;

/*
 * C++关键字列表（部分）：
 * 
 * 数据类型：
 *   int, float, double, char, bool, void
 *   long, short, signed, unsigned
 *   auto, wchar_t, char16_t, char32_t
 * 
 * 类型定义：
 *   class, struct, union, enum, typedef
 *   using, typename, template
 * 
 * 控制流：
 *   if, else, switch, case, default
 *   for, while, do, break, continue
 *   return, goto
 * 
 * 存储类：
 *   static, extern, register, mutable, thread_local
 * 
 * 常量和类型限定：
 *   const, constexpr, volatile
 * 
 * 访问控制：
 *   public, private, protected
 * 
 * 函数相关：
 *   inline, virtual, override, final
 *   friend, operator
 * 
 * 异常处理：
 *   try, catch, throw, noexcept
 * 
 * 内存管理：
 *   new, delete
 * 
 * 其他：
 *   sizeof, typeid, namespace, using
 *   this, nullptr, true, false
 */

int main() {
    // ============ auto关键字（C++11） ============
    
    // 自动类型推导
    auto num = 10;           // 推导为int
    auto pi = 3.14;          // 推导为double
    auto ch = 'A';           // 推导为char
    auto str = "hello";      // 推导为const char*
    auto flag = true;        // 推导为bool
    
    cout << "num类型大小: " << sizeof(num) << " 字节" << endl;
    cout << "pi类型大小: " << sizeof(pi) << " 字节" << endl;
    
    
    // ============ decltype关键字（C++11） ============
    
    // 获取表达式的类型
    int x = 10;
    decltype(x) y = 20;      // y的类型与x相同（int）
    
    decltype(x + 0.5) z = 1.5;  // z的类型是double（x + 0.5的结果类型）
    
    cout << "x + y = " << x + y << endl;
    cout << "z = " << z << endl;
    
    
    // ============ sizeof运算符 ============
    
    cout << "\n各类型大小：" << endl;
    cout << "int: " << sizeof(int) << " 字节" << endl;
    cout << "float: " << sizeof(float) << " 字节" << endl;
    cout << "double: " << sizeof(double) << " 字节" << endl;
    cout << "char: " << sizeof(char) << " 字节" << endl;
    cout << "bool: " << sizeof(bool) << " 字节" << endl;
    
    return 0;
}

输入输出

标准输出cout

#include <iostream>
#include <iomanip>  // 用于格式化输出
using namespace std;

int main() {
    // ============ 基本输出 ============
    
    // 使用流插入运算符 <<
    cout << "Hello, C++!" << endl;
    
    // 链式输出
    string name = "张三";
    int age = 25;
    cout << "姓名: " << name << ", 年龄: " << age << endl;
    
    
    // ============ 格式化输出 ============
    
    // 设置整数进制
    int num = 255;
    cout << "十进制: " << dec << num << endl;   // 255
    cout << "十六进制: " << hex << num << endl; // ff
    cout << "八进制: " << oct << num << endl;   // 377
    cout << dec;  // 恢复十进制
    
    
    // 设置浮点数精度
    double pi = 3.141592653589793;
    
    cout << "默认精度: " << pi << endl;
    
    cout << fixed;  // 固定小数点格式
    cout << "精度2位: " << setprecision(2) << pi << endl;
    cout << "精度4位: " << setprecision(4) << pi << endl;
    cout << "精度6位: " << setprecision(6) << pi << endl;
    
    cout << scientific;  // 科学计数法
    cout << "科学计数法: " << pi << endl;
    
    cout << defaultfloat;  // 恢复默认格式
    
    
    // ============ 宽度和对齐 ============
    
    cout << "\n对齐示例：" << endl;
    cout << left;  // 左对齐
    cout << setw(10) << "姓名" << setw(10) << "年龄" << setw(10) << "分数" << endl;
    cout << setw(10) << "张三" << setw(10) << 25 << setw(10) << 95.5 << endl;
    
    cout << right;  // 右对齐
    cout << setw(10) << "李四" << setw(10) << 23 << setw(10) << 88.0 << endl;
    
    
    // ============ 填充字符 ============
    
    cout << "\n填充示例：" << endl;
    cout << setfill('0');  // 设置填充字符
    cout << setw(5) << 42 << endl;  // 输出: 00042
    
    cout << setfill(' ');  // 恢复空格填充
    
    
    // ============ 布尔值输出 ============
    
    bool flag = true;
    cout << "\n布尔值输出：" << endl;
    cout << "默认: " << flag << endl;        // 输出: 1
    cout << boolalpha;
    cout << "boolalpha: " << flag << endl;   // 输出: true
    cout << noboolalpha;  // 恢复默认
    
    return 0;
}

标准输入cin

#include <iostream>
#include <string>
using namespace std;

int main() {
    // ============ 基本输入 ============
    
    int age;
    cout << "请输入年龄: ";
    cin >> age;
    cout << "你输入的年龄是: " << age << endl;
    
    
    // ============ 连续输入 ============
    
    string name;
    int score;
    
    cout << "请输入姓名和分数（用空格分隔）: ";
    cin >> name >> score;  // 连续读取两个值
    cout << "姓名: " << name << ", 分数: " << score << endl;
    
    
    // ============ 输入整行 ============
    
    cin.ignore();  // 清除缓冲区中的换行符
    
    string address;
    cout << "请输入地址: ";
    getline(cin, address);  // 读取整行，包括空格
    cout << "地址: " << address << endl;
    
    
    // ============ 输入验证 ============
    
    int number;
    cout << "请输入一个整数: ";
    
    // 检查输入是否有效
    while (!(cin >> number)) {
        cout << "输入无效，请重新输入整数: ";
        cin.clear();  // 清除错误标志
        cin.ignore(10000, '\n');  // 忽略错误输入
    }
    
    cout << "你输入的整数是: " << number << endl;
    
    
    // ============ 读取字符 ============
    
    char ch;
    cout << "请输入一个字符: ";
    cin >> ch;
    cout << "你输入的字符是: " << ch << endl;
    
    // 读取包括空白字符
    cin.ignore();
    char ch2;
    cout << "请再输入一个字符（包括空格）: ";
    cin.get(ch2);  // 可以读取空格
    cout << "你输入的字符是: '" << ch2 << "'" << endl;
    
    return 0;
}

文件流

#include <iostream>
#include <fstream>  // 文件流头文件
#include <string>
using namespace std;

int main() {
    // ============ 写入文件 ============
    
    // 创建输出文件流对象
    ofstream outFile("example.txt");
    
    // 检查文件是否成功打开
    if (!outFile) {
        cerr << "无法打开文件进行写入！" << endl;
        return 1;
    }
    
    // 写入数据
    outFile << "Hello, File!" << endl;
    outFile << "这是第二行" << endl;
    outFile << "数字: " << 12345 << endl;
    
    // 关闭文件
    outFile.close();
    cout << "文件写入完成！" << endl;
    
    
    // ============ 读取文件 ============
    
    // 创建输入文件流对象
    ifstream inFile("example.txt");
    
    if (!inFile) {
        cerr << "无法打开文件进行读取！" << endl;
        return 1;
    }
    
    cout << "\n文件内容：" << endl;
    cout << "----------" << endl;
    
    // 逐行读取
    string line;
    while (getline(inFile, line)) {
        cout << line << endl;
    }
    
    inFile.close();
    
    
    // ============ 追加写入 ============
    
    // 以追加模式打开文件
    ofstream appendFile("example.txt", ios::app);
    
    if (appendFile) {
        appendFile << "这是追加的内容" << endl;
        appendFile.close();
        cout << "\n追加内容完成！" << endl;
    }
    
    return 0;
}

本章小结

本章学习了：

• 变量：定义、初始化方式、命名规则
• 常量：const、constexpr、宏定义、枚举
• 关键字：auto、decltype、sizeof等
• 输出：cout格式化输出、宽度对齐控制
• 输入：cin格式化输入、getline读取整行
• 文件流：ifstream、ofstream的基本使用

下一章，我们将学习数据类型，了解C++的各种数据类型。