复合类型：数组、字符串、结构体与枚举

#include <iostream>

int main() {
    int scores[5] = {90, 85, 77, 60, 100};   // 完整初始化
    int zeros[10] = {};                       // 全部置 0（C++11 也支持 = {0}）
    int partial[5] = {1, 2};                  // 其余元素补 0：{1, 2, 0, 0, 0}
    int guessed[] = {3, 1, 4, 1, 5};          // 让编译器数元素个数：长度 5

    scores[0] = 95;                           // 下标从 0 开始：首元素是 [0]
    std::cout << scores[4] << '\n';           // 最后一个元素是 [长度-1]

    int n = sizeof(scores) / sizeof(scores[0]);  // 元素个数的经典写法
    std::cout << "n = " << n << '\n';
}

void printAll(int arr[], int count) {   // 这里的 int arr[] 实际是 int*
    // sizeof(arr) 是指针大小，不是数组大小！
    for (int i = 0; i < count; ++i) {
        std::cout << arr[i] << ' ';
    }
}

int main() {
    int scores[5] = {90, 85, 77, 60, 100};
    printAll(scores, 5);    // 数组名退化为首元素地址传入
}

char cstr[] = "hello";        // 实际 6 个元素：h e l l o \0
std::cout << sizeof(cstr);    // 6：含结尾的 '\0'
char fixed[10] = "hi";        // 前 3 个用掉，其余补 '\0'

#include <iostream>
#include <string>

int main() {
    std::string s = "hello";
    std::string t = s + " world";       // 拼接：+ 直接用
    std::cout << t.length() << '\n';    // 11：长度自己知道，不靠 '\0'

    if (s == "hello") { }               // == 比较内容（C 的 == 比较地址！）
    std::cout << t.substr(6) << '\n';   // "world"：取子串
    std::cout << t.find("world") << '\n';  // 6：子串位置，找不到返回 npos
}

#include <array>
#include <vector>
#include <iostream>

int main() {
    std::array<int, 5> fixed = {1, 2, 3, 4, 5};   // 定长：长度是类型的一部分
    std::vector<int> grow;                         // 变长：自动扩容

    grow.push_back(10);                            // 追加元素
    grow.push_back(20);
    std::cout << grow.size() << '\n';              // 2：随时可问长度

    for (int x : fixed) std::cout << x << ' ';     // 范围 for 通吃两者
    for (size_t i = 0; i < grow.size(); ++i) {
        std::cout << grow[i] << ' ';               // 下标访问与裸数组一样
    }
}

#include <iostream>
#include <string>

struct Item {                 // 先定义类型：描述"长什么样"
    std::string name;
    int count;
    double weight;
};

int main() {
    Item potion{"治疗药水", 3, 0.5};        // 聚合初始化：按字段顺序一一对应
    Item empty{};                            // 全字段零值/默认构造

    potion.count += 2;                       // 点号访问成员
    std::cout << potion.name << " x" << potion.count << '\n';

    Item copy = potion;                      // 整体拷贝：每个字段各复制一份
    copy.name = "副本药水";
    std::cout << potion.name << ' ' << copy.name << '\n';
}

#include <iostream>
#include <string>
#include <array>

struct Item {
    std::string name;
    int count;
};

struct Character {
    std::string name;
    int hp;
    std::array<Item, 8> bag;    // 背包固定 8 格
    int bagUsed = 0;            // 已用格数
};

bool addItem(Character& c, const Item& it) {   // 引用传参：真往背包里放
    if (c.bagUsed >= (int)c.bag.size()) return false;   // 背包满
    c.bag[c.bagUsed++] = it;
    return true;
}

int main() {
    Character hero{"勇者", 100, {}};
    addItem(hero, {"剑", 1});
    addItem(hero, {"治疗药水", 5});
    for (int i = 0; i < hero.bagUsed; ++i) {
        std::cout << hero.bag[i].name << " x" << hero.bag[i].count << '\n';
    }
}

struct Flags {
    unsigned int visible : 1;    // 只占 1 位
    unsigned int movable : 1;
    unsigned int locked : 2;     // 占 2 位：0~3 四个状态
    unsigned int : 0;            // 填充到下一边界
    unsigned int rarity : 3;     // 0~7
};

// 谁记得 2 是什么意思？
int result = fight(2);

#include <iostream>

enum Color { RED, GREEN, BLUE };            // 传统 enum：名字进全局，隐式转 int
enum class Weapon { SWORD, BOW, STAFF };    // 作用域枚举：Weapon::SWORD

int main() {
    Color c = GREEN;
    int n = c;                   // 传统枚举可隐式转 int（值 1）

    Weapon w = Weapon::BOW;
    // int m = w;               // 错：enum class 不隐式转换
    int m = static_cast<int>(w); // 需要整数时显式转换
    std::cout << n << ' ' << m << '\n';

    // 与 switch 天作之合（035 篇）：
    switch (w) {
        case Weapon::SWORD: std::cout << "近战\n"; break;
        case Weapon::BOW:   std::cout << "远程\n"; break;
        case Weapon::STAFF: std::cout << "法系\n"; break;
    }
}

#include <iostream>
#include <utility>   // std::swap

void bubbleSort(int a[], int n) {
    for (int i = 0; i < n - 1; ++i) {          // 共 n-1 轮
        for (int j = 0; j < n - 1 - i; ++j) {  // 每轮比到"已沉底"之前
            if (a[j] > a[j + 1]) {
                std::swap(a[j], a[j + 1]);     // 相邻逆序就交换：大的往后冒
            }
        }
    }
}

void selectionSort(int a[], int n) {
    for (int i = 0; i < n - 1; ++i) {
        int minIdx = i;
        for (int j = i + 1; j < n; ++j) {      // 在未排序区找最小
            if (a[j] < a[minIdx]) minIdx = j;
        }
        if (minIdx != i) std::swap(a[i], a[minIdx]);  // 每轮只换一次
    }
}

// 回文：正读反读一致（用首尾双指针，不用额外数组）
bool isPalindrome(const std::string& s) {
    int lo = 0, hi = (int)s.size() - 1;
    while (lo < hi) {
        if (s[lo] != s[hi]) return false;
        ++lo; --hi;
    }
    return true;
}

// 二维数组行列互换：b[j][i] = a[i][j]
void transpose(int a[3][3], int b[3][3]) {
    for (int i = 0; i < 3; ++i)
        for (int j = 0; j < 3; ++j)
            b[j][i] = a[i][j];
}

#include <iostream>
#include <cstring>
int main() {
    char name[5] = "Tom";
    strcat(name, " Anderson");
    std::cout << name << '\n';
    std::cout << (name == "Tom" ? "same" : "diff") << '\n';
}

#include <iostream>
#include <string>
int main() {
    std::string name = "Tom";
    name += " Anderson";                    // string 自动扩容，无越界
    std::cout << name << '\n';
    std::cout << (name == "Tom" ? "same" : "diff") << '\n';  // == 比内容
}

// 简单版：借助第二个数组
void rotateSimple(const int a[], int n, int p, int b[]) {
    for (int i = 0; i < n; ++i) {
        b[(i + p) % n] = a[i];    // 原第 i 个元素的新位置
    }
}

// 原地版：三次反转
void reverse(int a[], int lo, int hi) {
    while (lo < hi) std::swap(a[lo++], a[hi--]);
}
void rotateInPlace(int a[], int n, int p) {
    reverse(a, 0, n - 1);
    reverse(a, 0, p - 1);
    reverse(a, p, n - 1);
}