Chapter 4 复合类型

double salesJan, salesFeb, salesMar, /* ..., */ salesDec; 

typeName arrayName[arraySize]; 

// 声明一个可以存储 12 个 double 类型值的数组，名为 monthlySales
double monthlySales[12]; 

// 声明一个可以存储 5 个 int 类型值的数组，名为 scores
int scores[5];

// 使用 const 常量定义数组大小
const int NUM_STUDENTS = 30;
int studentGrades[NUM_STUDENTS]; 

// 访问 monthlySales 数组的第一个元素 (一月)
monthlySales[0] = 1500.50; 

// 访问 monthlySales 数组的第三个元素 (三月)
monthlySales[2] = 2100.75; 

// 访问 scores 数组的最后一个元素
scores[4] = 95; 

// 读取 scores 数组的第二个元素
int secondScore = scores[1]; 

std::cout << "March sales: " << monthlySales[2] << std::endl;
std::cout << "Second score: " << secondScore << std::endl;

int n = 10;
// int dynamicArray[n]; // 错误! C++ 标准不允许使用变量作为数组大小 (虽然某些编译器可能作为扩展支持)

const int SIZE = 5;
int staticArray[SIZE]; // 正确! SIZE 是 const 常量

int anotherArray[10]; // 正确! 10 是字面常量

#include <iostream>

int main() {
    // 完整初始化
    int fibonacci[8] = {0, 1, 1, 2, 3, 5, 8, 13};
    std::cout << "Fibonacci[5]: " << fibonacci[5] << std::endl; // 输出 8

    // 部分初始化
    double data[5] = {1.1, 2.2};
    std::cout << "Data[0]: " << data[0] << std::endl; // 输出 1.1
    std::cout << "Data[1]: " << data[1] << std::endl; // 输出 2.2
    std::cout << "Data[2]: " << data[2] << std::endl; // 输出 0
    std::cout << "Data[3]: " << data[3] << std::endl; // 输出 0
    std::cout << "Data[4]: " << data[4] << std::endl; // 输出 0

    // 省略大小
    char vowels[] = {'a', 'e', 'i', 'o', 'u'};
    std::cout << "Number of vowels: " << sizeof(vowels) / sizeof(char) << std::endl; // 输出 5

    // 初始化所有元素为 0
    int results[20] = {0};
    std::cout << "Results[15]: " << results[15] << std::endl; // 输出 0

    return 0;
}

typeName arrayName[arraySize] {initializer_list}; // C++11 列表初始化 (可省略等号)
typeName arrayName[] {initializer_list};         // 省略大小

#include <iostream>

int main() {
    // C++11 列表初始化 (省略等号)
    int scores[5] {90, 85, 92, 78, 88}; 
    double lengths[3] {1.2, 3.4, 0.5};
    int counts[10] {1, 2, 3}; // 部分初始化，剩余元素为 0
    int allZeros[100] {};     // 所有元素初始化为 0 (空列表)
    short values[] {10, 20, 30, 40}; // 省略大小

    std::cout << "Scores[1]: " << scores[1] << std::endl; // 输出 85
    std::cout << "Counts[5]: " << counts[5] << std::endl; // 输出 0
    std::cout << "allZeros[50]: " << allZeros[50] << std::endl; // 输出 0
    std::cout << "Size of values: " << sizeof(values) / sizeof(short) << std::endl; // 输出 4

    // 禁止缩窄转换示例
    // int errors[3] {1, 2, 3.0}; // 错误! double (3.0) 到 int 是缩窄转换
    // char chars[2] { 'a', 300 }; // 错误! 300 超出 char 的范围 (假设 char 是 8 位)
    
    // 允许非缩窄转换
    char chars_ok[3] { 'a', 66, 'c' }; // 66 在 char 范围内，可以隐式转换为 'B'
    std::cout << "Chars OK: " << chars_ok[0] << chars_ok[1] << chars_ok[2] << std::endl; // 输出 aBc

    return 0;
}

#include <iostream>

int main() {
    // 相邻的字符串字面值会被自动拼接
    std::cout << "This is the first part, " "and this is the second part." << std::endl;
    // 输出: This is the first part, and this is the second part.

    // 可以跨越多行
    std::cout << "Line 1: Some text...\n"
                 "Line 2: More text...\n"
                 "Line 3: Final line." << std::endl;
    /*
    输出:
    Line 1: Some text...
    Line 2: More text...
    Line 3: Final line.
    */

    // 拼接结果是一个单独的字符串常量
    const char* long_message = "Part 1. "
                               "Part 2. "
                               "Part 3.";
    std::cout << long_message << std::endl; 
    // 输出: Part 1. Part 2. Part 3.

    // 注意：变量和字符串字面值不能自动拼接
    std::string part1 = "Hello";
    // std::cout << part1 " world!"; // 错误! 不能这样拼接变量和字面值
    // 需要使用 string 类的拼接操作 (见 4.3 节) 或 cout 的链式输出
    std::cout << part1 << " world!" << std::endl; // 正确

    return 0;
}

#include <iostream>
#include <cstring> // 包含 C 风格字符串函数库 (例如 strlen)

int main() {
    // 使用字符串字面值初始化 char 数组
    char dog[8] = "fatcat"; // 数组大小必须足够容纳字符串 + 空字符 ('f','a','t','c','a','t','\0')
                            // dog 数组大小为 8，实际使用 7 个字符 + 1 个空字符
    
    char bird[] = "wren";   // 编译器自动推断大小为 5 ('w','r','e','n','\0')

    // 使用列表初始化 (需要显式包含空字符)
    char fish[] = {'t', 'r', 'o', 'u', 't', '\0'}; 

    // 错误示例：数组大小不足
    // char cat[3] = "cat"; // 错误! 需要大小 4 来存储 'c','a','t','\0'

    std::cout << "Dog: " << dog << std::endl;   // cout 遇到空字符停止输出
    std::cout << "Bird: " << bird << std::endl;
    std::cout << "Fish: " << fish << std::endl;

    // 访问单个字符
    std::cout << "Third letter of dog: " << dog[2] << std::endl; // 输出 't'
    dog[0] = 'p'; // 可以修改数组内容
    std::cout << "Modified dog: " << dog << std::endl; // 输出 "patcat"

    // strlen() 函数计算字符串长度 (不包括空字符)
    std::cout << "Length of dog: " << std::strlen(dog) << std::endl; // 输出 6 (因为现在是 "patcat")
    std::cout << "Length of bird: " << std::strlen(bird) << std::endl; // 输出 4

    // sizeof() 计算整个数组占用的内存大小 (包括空字符和未使用的空间)
    std::cout << "Size of dog array: " << sizeof(dog) << " bytes" << std::endl; // 输出 8
    std::cout << "Size of bird array: " << sizeof(bird) << " bytes" << std::endl; // 输出 5

    return 0;
}

#include <iostream>

int main() {
    const int SIZE = 20;
    char name[SIZE];
    char dessert[SIZE];

    std::cout << "Enter your first name: ";
    std::cin >> name; // 读取直到遇到第一个空白字符

    std::cout << "Enter your favorite dessert: ";
    std::cin >> dessert; // 读取直到遇到第一个空白字符

    std::cout << "Hello, " << name << "!" << std::endl;
    std::cout << "I see you like " << dessert << "." << std::endl;

    return 0;
}

#include <iostream>

int main() {
    const int SIZE = 50;
    char fullName[SIZE];
    char address[SIZE];

    // 使用 getline()
    std::cout << "Enter your full name: ";
    std::cin.getline(fullName, SIZE); // 读取整行，包括空格，丢弃换行符

    std::cout << "Enter your address: ";
    std::cin.getline(address, SIZE); // 读取下一行

    std::cout << "Name: " << fullName << std::endl;
    std::cout << "Address: " << address << std::endl;
    std::cout << "--------------------" << std::endl;

    // 使用 get() - 注意换行符问题
    char title[SIZE];
    char author[SIZE];

    std::cout << "Enter book title: ";
    std::cin.get(title, SIZE); // 读取整行，换行符留在缓冲区

    // 如果直接调用下一个 get()，它会立即读到上一个留下的换行符并停止
    // std::cin.get(author, SIZE); // 这将导致 author 为空

    // 需要处理掉留下的换行符
    // 方法一：再调用一次 get() 读取单个字符
    // std::cin.get(); // 读取并丢弃换行符
    
    // 方法二：使用 ignore() 跳过字符
    std::cin.ignore(100, '\n'); // 跳过最多100个字符，直到遇到换行符（并丢弃换行符）

    std::cout << "Enter author name: ";
    std::cin.get(author, SIZE); // 现在可以正确读取作者名

    std::cout << "Title: " << title << std::endl;
    std::cout << "Author: " << author << std::endl;


    return 0;
}

#include <iostream>

int main() {
    int age;
    char name[50];

    std::cout << "Enter your age: ";
    std::cin >> age; // 读取年龄，换行符留在缓冲区

    std::cout << "Enter your full name: ";
    std::cin.getline(name, 50); // 立即读到残留的换行符，getline 结束，name 为空

    std::cout << "Age: " << age << std::endl;
    std::cout << "Name: [" << name << "]" << std::endl; // 输出 Name: []

    return 0;
}

#include <iostream>
#include <limits> // 为了 numeric_limits (更健壮的 ignore)

int main() {
    int age;
    char name[50];

    std::cout << "Enter your age: ";
    std::cin >> age; 

    // 清除输入缓冲区，特别是换行符
    std::cin.ignore(std::numeric_limits<std::streamsize>::max(), '\n'); 
    // numeric_limits<streamsize>::max() 获取流能处理的最大字符数，确保清除整行

    std::cout << "Enter your full name: ";
    std::cin.getline(name, 50); // 现在可以正确读取姓名

    std::cout << "Age: " << age << std::endl;
    std::cout << "Name: [" << name << "]" << std::endl; 

    return 0;
}

#include <iostream>
#include <ios> // 为了 ws

int main() {
    int age;
    char name[50];

    std::cout << "Enter your age: ";
    std::cin >> age; 

    std::cout << "Enter your full name: ";
    // 在 getline 之前使用 ws 跳过空白符
    (std::cin >> std::ws).getline(name, 50); 

    std::cout << "Age: " << age << std::endl;
    std::cout << "Name: [" << name << "]" << std::endl; 

    return 0;
}

#include <iostream>
#include <string> // 必须包含 string 头文件

int main() {
    // 声明 string 对象
    std::string s1; // 创建一个空字符串
    std::string s2 = "Hello"; // 使用 C 风格字符串字面值初始化
    std::string s3("World"); // 使用 C 风格字符串字面值初始化 (构造函数语法)
    std::string s4 = s2; // 使用另一个 string 对象初始化 (复制)

    std::cout << "s1: " << s1 << std::endl; // 输出空行
    std::cout << "s2: " << s2 << std::endl; // 输出 Hello
    std::cout << "s3: " << s3 << std::endl; // 输出 World
    std::cout << "s4: " << s4 << std::endl; // 输出 Hello

    // string 对象可以像普通变量一样使用
    std::string message = s2 + ", " + s3 + "!"; // 字符串拼接
    std::cout << "Message: " << message << std::endl; // 输出 Hello, World!

    return 0;
}

#include <string>

std::string str1 { "Initialized with braces" }; // 使用 C 风格字符串字面值
std::string str2 = { "Also works with =" }; 
// std::string str3 { 'a', 'b', 'c' }; // C++11 中通常不直接用字符列表初始化 string (会尝试调用匹配的构造函数)
// std::string str4 = { 'x', 'y', 'z' }; // 同上

#include <iostream>
#include <string>

int main() {
    std::string greeting1 { "Good morning" };
    std::string greeting2 = { "Good afternoon" };
    // std::string letters { 'H', 'i', '\0' }; // 可能不按预期工作或编译错误

    std::cout << greeting1 << std::endl; // 输出 Good morning
    std::cout << greeting2 << std::endl; // 输出 Good afternoon

    // 推荐的初始化方式
    std::string s1 = "Hello";       // C 风格字面值
    std::string s2("World");      // 构造函数语法
    std::string s3 = s1;          // 复制构造
    std::string s4(10, 'c');      // 创建包含 10 个 'c' 的字符串 "cccccccccc"

    std::cout << "s4: " << s4 << std::endl;

    return 0;
}

#include <iostream>
#include <string>

int main() {
    std::string s1 = "Hello";
    std::string s2 = "World";
    std::string s3;
    std::string s4;

    // 赋值
    s3 = s1; // s3 变为 "Hello"
    std::cout << "s3 after assignment: " << s3 << std::endl;
    s3 = "Goodbye"; // s3 变为 "Goodbye"
    std::cout << "s3 after new assignment: " << s3 << std::endl;
    s3 = 'X'; // s3 变为 "X"
    std::cout << "s3 after char assignment: " << s3 << std::endl;

    // 拼接 (+) - 创建新字符串
    s4 = s1 + " " + s2 + "!"; // s4 变为 "Hello World!"
    std::cout << "s4 (concatenated): " << s4 << std::endl;
    
    std::string s5 = s1 + '!'; // s5 变为 "Hello!"
    std::cout << "s5 (string + char): " << s5 << std::endl;

    // 错误: 不能直接拼接两个 C 风格字符串字面值
    // std::string error_str = "String1" + "String2"; // 编译错误!

    // 正确: 至少有一个是 string 对象
    std::string ok_str1 = s1 + " String2"; 
    std::string ok_str2 = "String1" + s2; 
    std::cout << "ok_str1: " << ok_str1 << std::endl;
    std::cout << "ok_str2: " << ok_str2 << std::endl;

    // 附加 (+=) - 修改原字符串
    s1 += " "; // s1 变为 "Hello "
    s1 += s2; // s1 变为 "Hello World"
    s1 += '!'; // s1 变为 "Hello World!"
    std::cout << "s1 after append: " << s1 << std::endl;

    return 0;
}

#include <iostream>
#include <string>
#include <stdexcept> // 为了 std::out_of_range

int main() {
    std::string text = "Hello C++ World!";

    // 长度和空检查
    std::cout << "Text: \"" << text << "\"" << std::endl;
    std::cout << "Length: " << text.length() << std::endl; // 输出 16
    std::cout << "Is empty? " << std::boolalpha << text.empty() << std::endl; // 输出 false

    // 访问字符
    std::cout << "First char (operator[]): " << text[0] << std::endl;   // 输出 H
    std::cout << "Fifth char (at()): " << text.at(4) << std::endl;     // 输出 o
    // std::cout << text.at(20); // 会抛出 std::out_of_range 异常

    // 查找
    size_t pos_cpp = text.find("C++");
    if (pos_cpp != std::string::npos) {
        std::cout << "\"C++\" found at index: " << pos_cpp << std::endl; // 输出 6
    } else {
        std::cout << "\"C++\" not found." << std::endl;
    }
    
    size_t pos_l = text.find('l'); // 查找第一个 'l'
    std::cout << "First 'l' found at index: " << pos_l << std::endl; // 输出 2

    size_t pos_last_l = text.rfind('l'); // 查找最后一个 'l'
    std::cout << "Last 'l' found at index: " << pos_last_l << std::endl; // 输出 12

    // 子字符串
    std::string sub = text.substr(6, 3); // 从索引 6 开始，取 3 个字符
    std::cout << "Substring (6, 3): \"" << sub << "\"" << std::endl; // 输出 "C++"

    // 比较
    std::string s1 = "apple";
    std::string s2 = "apply";
    if (s1 < s2) {
        std::cout << "\"" << s1 << "\" comes before \"" << s2 << "\"" << std::endl;
    }
    int cmp_result = s1.compare(s2); // 返回负数，因为 "apple" < "apply"
    std::cout << "Compare result: " << cmp_result << std::endl; 

    // 修改
    text.insert(10, " beautiful"); // 在索引 10 处插入
    std::cout << "After insert: \"" << text << "\"" << std::endl; // 输出 "Hello C++ beautiful World!"

    text.erase(6, 4); // 从索引 6 开始，删除 4 个字符 ("C++ ")
    std::cout << "After erase: \"" << text << "\"" << std::endl; // 输出 "Hello beautiful World!"

    text.replace(6, 9, "gorgeous"); // 从索引 6 开始，替换 9 个字符 ("beautiful")
    std::cout << "After replace: \"" << text << "\"" << std::endl; // 输出 "Hello gorgeous World!"

    text.clear(); // 清空字符串
    std::cout << "After clear, is empty? " << std::boolalpha << text.empty() << std::endl; // 输出 true

    return 0;
}

#include <iostream>
#include <string>

int main() {
    std::string word1, word2;
    std::string line;

    // 输出
    std::string message = "Enter two words:";
    std::cout << message << std::endl;

    // 输入 (cin >> 读取单词)
    std::cin >> word1 >> word2; // 输入 "Hello World" (用空格隔开)
    std::cout << "Word 1: " << word1 << std::endl; // 输出 Hello
    std::cout << "Word 2: " << word2 << std::endl; // 输出 World

    // 清除输入缓冲区中可能残留的换行符 (cin >> 之后通常需要)
    std::cin.ignore(10000, '\n'); 

    // 输入 (getline 读取整行)
    std::cout << "Enter a line of text: ";
    getline(std::cin, line); // 输入 "This is a test line."
    std::cout << "You entered: \"" << line << "\"" << std::endl; // 输出 "This is a test line."

    return 0;
}

#include <iostream>
#include <string>

int main() {
    // 原始字符串字面值
    std::string path1 = "C:\\Program Files\\My App\\"; // 需要转义反斜杠
    std::string path2 = R"(C:\Program Files\My App\)"; // 使用原始字符串，无需转义
    std::string regex = R"(\b[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Za-z]{2,}\b)"; // 正则表达式
    std::string html = R"delimiter(
<html>
  <head><title>Raw String</title></head>
  <body><p>"Hello!"</p></body>
</html>)delimiter";

    std::cout << "Path 1: " << path1 << std::endl;
    std::cout << "Path 2: " << path2 << std::endl;
    std::cout << "Regex: " << regex << std::endl;
    std::cout << "HTML:\n" << html << std::endl;

    // Unicode 字符串字面值 (主要用于需要特定编码的场景)
    const char* utf8_str = u8"你好，世界"; // UTF-8 (需要支持 UTF-8 的环境/终端才能正确显示)
    const char16_t* utf16_str = u"你好，世界"; // UTF-16
    const char32_t* utf32_str = U"你好，世界"; // UTF-32

    std::cout << "UTF-8 String (may not display correctly): " << utf8_str << std::endl;
    
    // 处理和打印 UTF-16/32 通常需要专门的库或函数
    // std::cout << utf16_str; // 不能直接用 cout 打印 char16_t* / char32_t*

    return 0;
}

struct StructureName {
    memberType1 memberName1;
    memberType2 memberName2;
    // ... more members
}; // 注意定义末尾的分号

#include <iostream>
#include <string> // 为了使用 string

// 1. 定义结构: 描述充气产品的结构体
struct Inflatable {
    std::string name; // 商品名称 (string 类型成员)
    float volume;     // 体积 (float 类型成员)
    double price;     // 价格 (double 类型成员)
};

int main() {
    // 2. 声明结构变量
    Inflatable product1; // 声明一个 Inflatable 类型的变量 product1
    Inflatable product2; // 声明另一个 Inflatable 类型的变量 product2

    // 3. 访问并赋值结构成员
    product1.name = "Awesome Air Mattress";
    product1.volume = 1.8f;
    product1.price = 49.99;

    // 也可以在声明时进行初始化 (C++98/03 风格，需要按顺序)
    Inflatable product3 = {"Giant Swan Floatie", 2.5f, 79.95}; 

    // 访问并输出成员
    std::cout << "Product 1 Name: " << product1.name << std::endl;
    std::cout << "Product 1 Price: $" << product1.price << std::endl;

    std::cout << "Product 3 Name: " << product3.name << std::endl;
    std::cout << "Product 3 Volume: " << product3.volume << " cubic meters" << std::endl;

    // 结构变量之间可以直接赋值 (成员逐个复制)
    product2 = product1; 
    std::cout << "Product 2 Name (after assignment): " << product2.name << std::endl;

    return 0;
}

#include <iostream>
#include <string>

struct Product {
    std::string id;
    int quantity;
    double price;
};

int main() {
    // C++11 列表初始化 (省略等号)
    Product item1 { "A123", 50, 19.95 }; // 按顺序初始化所有成员
    
    // 省略等号，部分初始化 (C++11/14/17 中，未提供的成员会被值初始化/零初始化)
    // 注意：这种部分初始化对于包含 std::string 等类类型成员时，行为依赖于这些类的默认构造函数
    // Product item2 { "B456", 100 }; // price 会被零初始化为 0.0

    // 空花括号进行零初始化
    Product item3 {}; // id 为空字符串, quantity 为 0, price 为 0.0

    std::cout << "Item 1 ID: " << item1.id << ", Qty: " << item1.quantity << ", Price: " << item1.price << std::endl;
    // std::cout << "Item 2 ID: " << item2.id << ", Qty: " << item2.quantity << ", Price: " << item2.price << std::endl;
    std::cout << "Item 3 ID: \"" << item3.id << "\", Qty: " << item3.quantity << ", Price: " << item3.price << std::endl;

    // 禁止缩窄转换
    // Product item_error { "C789", 10.5, 25.0 }; // 错误! 10.5 (double) 到 int 是缩窄转换

    // C++20 Designated Initializers (如果编译器支持 C++20)
    // Product item4 { .id = "D001", .price = 99.99 }; // quantity 会被零初始化
    // std::cout << "Item 4 ID: " << item4.id << ", Qty: " << item4.quantity << ", Price: " << item4.price << std::endl;

    return 0;
}

#include <string>

struct Student {
    std::string name; // string 成员
    int studentID;
    double gpa;
};

int main() {
    Student s1 { "Alice Wonderland", 12345, 3.8 };
    Student s2;
    s2.name = "Bob The Builder"; // 可以像普通 string 一样操作
    s2.studentID = 67890;
    s2.gpa = 3.5;

    std::cout << s1.name << " has GPA: " << s1.gpa << std::endl;
    std::cout << s2.name << " has ID: " << s2.studentID << std::endl;

    return 0;
}

#include <iostream>
#include <string>

struct Student {
    std::string name;
    int studentID;
};

const int CLASS_SIZE = 3;

int main() {
    // 声明一个包含 CLASS_SIZE 个 Student 结构的数组
    Student classRoster[CLASS_SIZE]; 

    // 初始化结构数组 (使用嵌套花括号)
    Student graduates[2] = {
        {"Alice", 101}, // 初始化 graduates[0]
        {"Bob", 102}    // 初始化 graduates[1]
    };

    // C++11 列表初始化
    Student freshmen[CLASS_SIZE] {
        {"Charlie", 201},
        {"David", 202},
        {"Eve", 203}
    };

    // 访问结构数组中的元素及其成员
    classRoster[0].name = "Frank";
    classRoster[0].studentID = 301;

    std::cout << "Graduate 1: " << graduates[0].name << " (ID: " << graduates[0].studentID << ")" << std::endl;
    std::cout << "Freshman 3 ID: " << freshmen[2].studentID << std::endl;
    std::cout << "Roster 1 Name: " << classRoster[0].name << std::endl;

    // 遍历结构数组
    std::cout << "\nFreshmen List:" << std::endl;
    for (int i = 0; i < CLASS_SIZE; ++i) {
        std::cout << " - " << freshmen[i].name << " (ID: " << freshmen[i].studentID << ")" << std::endl;
    }

    return 0;
}

struct RegisterFlags {
    unsigned int readEnable : 1; // 占用 1 位
    unsigned int writeEnable : 1; // 占用 1 位
    unsigned int mode : 2;       // 占用 2 位
    unsigned int reserved : 4;   // 占用 4 位 (通常用于填充或对齐)
    // ...
};

#include <iostream>

// 假设用于控制某个设备的状态
struct DeviceStatus {
    // 打包到单个字节 (假设 unsigned int 至少 8 位)
    unsigned int powerOn : 1;
    unsigned int errorFlag : 1;
    unsigned int channel : 3; // 可以表示 0-7
    unsigned int : 3;       // 填充未使用的 3 位，使总共 8 位
};

int main() {
    DeviceStatus status;

    // 设置位字段的值
    status.powerOn = 1;    // 设备开机
    status.errorFlag = 0; // 无错误
    status.channel = 5;   // 设置通道为 5

    // 读取位字段的值
    std::cout << "Device Status:" << std::endl;
    std::cout << " Power On: " << status.powerOn << std::endl;
    std::cout << " Error Flag: " << status.errorFlag << std::endl;
    std::cout << " Channel: " << status.channel << std::endl;

    // 位字段通常打包存储
    std::cout << "Size of DeviceStatus struct: " << sizeof(DeviceStatus) << " byte(s)" << std::endl; 
    // 输出通常是 1 或 4 (取决于编译器如何对齐和打包，以及 int 的大小)

    // 检查特定标志
    if (status.powerOn) {
        std::cout << "Device is powered on." << std::endl;
    }

    // 不能获取位字段地址
    // unsigned int* pPower = &status.powerOn; // 错误!

    return 0;
}

union UnionName {
    memberType1 memberName1;
    memberType2 memberName2;
    // ... more members
}; // 注意定义末尾的分号

#include <iostream>

// 定义一个共用体，可以存储 int, long 或 double
union DataValue {
    int i_val;
    long l_val;
    double d_val;
};

int main() {
    DataValue data; // 声明一个 DataValue 共用体变量

    std::cout << "Size of DataValue union: " << sizeof(DataValue) << " bytes" << std::endl; 
    // 输出的大小通常等于 sizeof(double)，因为它是最大的成员

    // 存储并使用 int 成员
    data.i_val = 100;
    std::cout << "Stored as int: " << data.i_val << std::endl; 
    // 此时访问 l_val 或 d_val 的结果是未定义的/无意义的

    // 存储并使用 double 成员 (会覆盖之前的 int 值)
    data.d_val = 3.14159;
    std::cout << "Stored as double: " << data.d_val << std::endl;
    // 此时访问 i_val 或 l_val 的结果是未定义的/无意义的
    // std::cout << "Reading i_val after storing double: " << data.i_val << std::endl; // 结果不可靠

    // 存储并使用 long 成员 (会覆盖之前的 double 值)
    data.l_val = 1234567890L;
    std::cout << "Stored as long: " << data.l_val << std::endl;

    // --- 追踪当前有效成员 ---
    // 通常需要一个额外的变量来记录当前哪个成员是有效的
    enum DataType { INT, LONG, DOUBLE };
    
    struct DataPacket {
        DataType type; // 记录当前存储的数据类型
        DataValue value; // 共用体存储实际值
    };

    DataPacket packet;
    packet.type = INT;
    packet.value.i_val = 255;

    // 根据类型访问
    if (packet.type == INT) {
        std::cout << "Packet contains int: " << packet.value.i_val << std::endl;
    } 
    // ... 其他类型的检查

    return 0;
}

#include <iostream>

struct Widget {
    char type; // 'I' for integer, 'F' for float
    union { // 匿名共用体
        int intVal;
        float floatVal;
    }; // 注意这里没有变量名
};

int main() {
    Widget w;
    w.type = 'I';
    w.intVal = 123; // 直接访问匿名共用体的成员

    if (w.type == 'I') {
        std::cout << "Widget value (int): " << w.intVal << std::endl;
    } else if (w.type == 'F') {
        // w.floatVal = 3.14f; // 如果要存 float
        // std::cout << "Widget value (float): " << w.floatVal << std::endl;
    }
    
    std::cout << "Size of Widget: " << sizeof(Widget) << std::endl; 
    // 大小通常是 char 的大小 + 最大成员(int 或 float)的大小 + 可能的对齐填充

    return 0;
}

enum spectrum {red, orange, yellow, green, blue, violet, indigo, ultraviolet};

#include <iostream>

enum spectrum {red, orange, yellow, green, blue, violet, indigo, ultraviolet};

int main() {
    spectrum band; // 声明一个 spectrum 类型的变量 band

    band = blue; // 将枚举量 blue 赋给 band (合法)

    std::cout << "Current band (enum value): " << band << std::endl; // 输出 blue 对应的整数值 5

    // band = 2000; // 错误! 不能直接将整数赋给枚举变量 (类型不匹配)
    // band = red + orange; // 错误! + 运算符未对枚举类型定义 (虽然 red 和 orange 有整数值)

    // 可以将枚举量赋给 int 变量 (枚举量会自动提升为 int)
    int colorCode = green; 
    std::cout << "Color code for green: " << colorCode << std::endl; // 输出 3

    // 可以强制将 int 转换为枚举类型 (需要显式转换，且需谨慎)
    band = static_cast<spectrum>(3); // 将 3 转换为 spectrum 类型 (对应 green)
    std::cout << "Band after cast: " << band << std::endl; // 输出 3

    // 比较
    if (band == green) {
        std::cout << "The band is green." << std::endl;
    }

    // 在循环中使用 (需要注意类型转换和范围)
    for (band = red; band <= ultraviolet; band = static_cast<spectrum>(band + 1)) {
        std::cout << "Processing band: " << band << std::endl;
    }

    return 0;
}

#include <iostream>

enum BitField {
    BIT_ZERO,       // 默认值为 0
    BIT_ONE,        // 默认值为 1
    BIT_TWO = 4,    // 显式赋值为 4
    BIT_THREE,      // 值为 BIT_TWO + 1 = 5
    BIT_FOUR = 8,   // 显式赋值为 8
    BIT_FIVE = 8,   // 显式赋值为 8 (与 BIT_FOUR 相同)
    BIT_SIX,        // 值为 BIT_FIVE + 1 = 9
    BIT_SEVEN = BIT_THREE + BIT_FOUR // 值为 5 + 8 = 13
};

int main() {
    std::cout << "BIT_ZERO: " << BIT_ZERO << std::endl;     // 0
    std::cout << "BIT_ONE: " << BIT_ONE << std::endl;       // 1
    std::cout << "BIT_TWO: " << BIT_TWO << std::endl;       // 4
    std::cout << "BIT_THREE: " << BIT_THREE << std::endl;   // 5
    std::cout << "BIT_FOUR: " << BIT_FOUR << std::endl;     // 8
    std::cout << "BIT_FIVE: " << BIT_FIVE << std::endl;     // 8
    std::cout << "BIT_SIX: " << BIT_SIX << std::endl;       // 9
    std::cout << "BIT_SEVEN: " << BIT_SEVEN << std::endl;   // 13

    BitField flags = BIT_THREE;
    std::cout << "Flags: " << flags << std::endl; // 5

    return 0;
}

#include <iostream>

enum OldEnum { A = 1, B = 2, C = 4 }; // 最大值 4, 范围可能是 0-7

// C++11 作用域内枚举
enum class NewEnum { X = 10, Y = 20, Z = 30 }; 
enum class Status : char { OK = 'O', Error = 'E', Pending = 'P' }; // 指定底层类型为 char

int main() {
    OldEnum oe;
    // oe = 7; // 编译错误 (通常不允许直接赋 int)
    oe = static_cast<OldEnum>(7); // 合法 (因为 7 在理论范围 0-7 内)
    std::cout << "OldEnum value: " << oe << std::endl; // 输出 7

    // oe = static_cast<OldEnum>(8); // 行为未定义或可能编译错误 (超出理论范围)

    NewEnum ne = NewEnum::Y; // 必须使用作用域解析符
    // int ne_val = ne; // 错误! 不能隐式转换为 int
    int ne_val = static_cast<int>(ne); // 需要显式转换
    std::cout << "NewEnum value as int: " << ne_val << std::endl; // 输出 20

    // ne = 20; // 错误! 不能将 int 赋给 enum class
    ne = static_cast<NewEnum>(10); // 需要显式转换
    std::cout << "NewEnum value after cast: " << static_cast<int>(ne) << std::endl; // 输出 10

    Status s = Status::OK;
    char s_char = static_cast<char>(s); // 转换为底层类型 char
    std::cout << "Status as char: " << s_char << std::endl; // 输出 O

    return 0;
}

typeName * pointerName; 

int * p_int;      // 声明一个指向 int 类型的指针 p_int
double * p_double; // 声明一个指向 double 类型的指针 p_double
char * p_char;    // 声明一个指向 char 类型的指针 p_char
std::string * p_str; // 声明一个指向 string 对象的指针 p_str

#include <iostream>
#include <string>

int main() {
    int updates = 6;
    int * p_updates; // 声明一个指向 int 的指针，未初始化 (危险!)

    // 初始化指针
    int * p_value = nullptr; // 初始化为空指针 (推荐)
    int * p_zero = 0;      // 初始化为空指针 (旧式)
    // NULL 宏通常在 <cstddef> 或其他 C 头文件中定义
    
    // 使用地址初始化
    p_updates = &updates; // 将 updates 变量的地址赋给 p_updates

    // 访问指针信息
    std::cout << "Value of updates: " << updates << std::endl;             // 输出 6
    std::cout << "Address of updates: " << &updates << std::endl;          // 输出 updates 的内存地址
    std::cout << "Value of p_updates (address): " << p_updates << std::endl; // 输出存储在 p_updates 中的地址 (同上)

    // 使用解引用运算符访问指针指向的值
    std::cout << "Value at *p_updates: " << *p_updates << std::endl; // 输出 6 (updates 的值)

    // 使用解引用运算符修改指针指向的值
    *p_updates = *p_updates + 1; // 将 p_updates 指向的值 (updates) 加 1
    std::cout << "Now updates has value: " << updates << std::endl; // 输出 7

    // 指向其他类型
    double price = 99.99;
    double * p_price = &price; // p_price 指向 price
    std::cout << "Value at *p_price: " << *p_price << std::endl; // 输出 99.99

    // int * p_wrong = &price; // 错误! 指针类型 (int*) 与变量类型 (double) 不匹配

    return 0;
}

#include <iostream>

int main() {
    int value = 10;
    int * p_value = &value;

    // 指针的值是地址 (一个数字)
    std::cout << "Address stored in p_value: " << p_value << std::endl; 

    // 不能直接将任意整数赋给指针
    // p_value = 1000; // 错误! 类型不匹配 (除非使用 reinterpret_cast，但通常不安全)
    
    p_value = nullptr; // 合法，赋空指针
    p_value = 0;       // 合法，赋空指针

    // 指针可以转换为整数 (通常使用 reinterpret_cast，不推荐)
    // uintptr_t address_as_int = reinterpret_cast<uintptr_t>(p_value); 
    // std::cout << "Address as integer: " << address_as_int << std::endl;

    // 整数不能直接转换为指针 (除了 0)
    int address_int = 2000;
    // int * p_from_int = address_int; // 错误!
    // int * p_from_int = reinterpret_cast<int*>(address_int); // 可以编译，但极度危险

    return 0;
}

pointerVariable = new typeName;
// 或者在声明时分配
typeName * pointerVariable = new typeName;
// 也可以带初始化器
typeName * pointerVariable = new typeName (initializer); // C++98/03
typeName * pointerVariable = new typeName {initializer}; // C++11 列表初始化

#include <iostream>
#include <new> // 为了 std::bad_alloc (虽然不一定需要显式包含) 和 std::nothrow

int main() {
    // 分配一个 int 的内存
    int * p_int = new int; // 在自由存储区分配一个 int 大小的内存
    if (p_int == nullptr) { // 理论检查 (对于普通 new，失败会抛异常)
        std::cout << "Memory allocation failed!" << std::endl;
        return 1;
    }
    *p_int = 101; // 通过指针访问并赋值

    // 分配一个 double 并初始化
    double * p_double = new double (99.99); // 分配并初始化为 99.99
    // 或者 C++11 列表初始化
    // double * p_double = new double {99.99}; 

    std::cout << "Dynamically allocated int: " << *p_int << std::endl;
    std::cout << "Dynamically allocated double: " << *p_double << std::endl;
    std::cout << "Address of int: " << p_int << std::endl;
    std::cout << "Address of double: " << p_double << std::endl;

    // --- 内存释放将在下一节讲解 ---
    // delete p_int; 
    // delete p_double;

    // 使用 nothrow 版本 (失败时返回 nullptr)
    int * p_lots_of_ints = new (std::nothrow) int[1000000000]; // 尝试分配巨大数组
    if (p_lots_of_ints == nullptr) {
        std::cout << "Huge memory allocation failed, but program continues." << std::endl;
    } else {
        std::cout << "Huge memory allocation succeeded (unlikely)." << std::endl;
        // delete[] p_lots_of_ints; // 如果成功，需要释放
    }

    return 0;
}

delete pointerVariable; 

#include <iostream>

int main() {
    // 1. 分配内存
    int * p_value = new int (42);
    double * p_temp = new double;
    *p_temp = 123.45;

    std::cout << "Before delete:" << std::endl;
    std::cout << " p_value points to: " << *p_value << " at address " << p_value << std::endl;
    std::cout << " p_temp points to: " << *p_temp << " at address " << p_temp << std::endl;

    // 2. 释放内存
    delete p_value; 
    delete p_temp;

    std::cout << "\nAfter delete:" << std::endl;
    // p_value 和 p_temp 现在是悬挂指针!
    std::cout << " p_value still holds address: " << p_value << std::endl; 
    // std::cout << " Accessing *p_value: " << *p_value << std::endl; // 危险! 未定义行为

    // 3. 将指针设为 nullptr (好习惯)
    p_value = nullptr;
    p_temp = nullptr;

    std::cout << "After setting to nullptr:" << std::endl;
    std::cout << " p_value holds: " << p_value << std::endl; // 输出 0 或类似表示空指针的值

    // 对 nullptr 调用 delete 是安全的
    delete p_value; // 无效果
    delete p_temp; // 无效果

    // 错误示例:
    int stack_var = 10;
    int * p_stack = &stack_var;
    // delete p_stack; // 严重错误! 不能 delete 栈内存

    int * p1 = new int;
    int * p2 = p1; // p1 和 p2 指向同一块内存
    delete p1;
    // delete p2; // 严重错误! 删除了同一块内存两次

    return 0;
}