1
#define max_val(x,y) ((x)>(y))?(x):(y)
2
#define max_val(x,y) (((x)>(y))?(x):(y))

1
// 极其荒谬的逻辑：判断 10 > 5，如果是，返回 10；否则返回 5 + 20。
2
int result = ((10)>(5)) ? (10) : (5) + 20;

1
#include <iostream>
2
#include <stdexcept>
3

4
class ArrayStack {
5
private:
6
    int* data;         // 动态数组指针，紧紧指向堆区的一段连续物理内存
7
    size_t capacity;   // 栈当前的物理最大容量限制（水池有多大）
8
    size_t topIndex;   // 栈顶指针，其实就是下一个待插入元素的索引，恰好等同于栈内实际元素的个数
9

10
    // 核心私有机制：空间翻倍扩容策略 (Amortized Analysis 均摊复杂度核心)
11
    void expand() {
12
        // 采用经典的 2 倍扩容法。如果是空栈，先给个基础容量 1。
13
        size_t newCap = (capacity == 0) ? 1 : capacity * 2;
14

15
        // 1. 内存分配：在堆区申请更大的新空间
16
        // ⚠️ 异常安全：如果这里 new 失败抛出 bad_alloc 异常，旧的 data 依然完好无损，这叫“强异常安全保证”！
17
        int* newData = new int[newCap];
18

19
        // 2. 数据迁移：将旧数据安全拷贝至新空间 (在实际工程中，对于复杂对象这里应使用 std::move)
20
        for (size_t i = 0; i < topIndex; ++i) {
21
            newData[i] = data[i];
22
        }
23

24
        // 3. 释放旧魂：销毁旧的内存空间，绝对不能漏掉 []，否则会引发内存泄漏！
25
        delete[] data;
26

27
        // 4. 指针重定向与水位线更新
28
        data = newData;
29
        capacity = newCap;
30
    }
31

32
public:
33
    // 构造函数：遵循“初始化列表”规范，性能更优
34
    ArrayStack() : data(nullptr), capacity(0), topIndex(0) {}
35

36
    // 析构函数：由于类内部管理了堆内存 (Resource Acquisition Is Initialization 思想精髓)，对象销毁时必须负责扫尾
37
    ~ArrayStack() {
38
        delete[] data;
39
    }
40

41
    // 入栈操作：时间复杂度 O(1) 或 O(N)[仅在偶尔发生扩容的那一次]
42
    void push(int x) {
43
        if (topIndex == capacity) {
44
            expand(); // 容量见底，呼叫扩容机制
45
        }
46
        data[topIndex++] = x; // 先将 x 放入 data[topIndex] 位置，随后 topIndex 递增
47
    }
48

49
    // 出栈操作：逻辑删除，只需移动指针，真正的绝对 O(1)
50
    void pop() {
51
        if (topIndex > 0) {
52
            topIndex--; // 并没有真的去清空那一块内存，只是指针下移，下一次 push 覆盖即可
53
        }
54
    }
55

56
    // 访问栈顶元素：带有安全的越界检查防御
57
    int top() const {
58
        if (topIndex == 0) {
59
            throw std::out_of_range("Fatal Error: Attempt to access top of an empty stack!");
60
        }
61
        return data[topIndex - 1];
62
    }
63

64
    // 获取当前大小
65
    size_t size() const {
66
        return topIndex;
67
    }
68
};

1
#include <iostream>
2
#include <stdexcept>
3

4
// 定义链表节点结构体：每个节点都是一个独立自治的数据包
5
struct Node {
6
    int val;        // 数据域：真正承载的业务数据
7
    Node* next;     // 指针域：指向下一个节点的寻址线索
8

9
    // 节点初始化构造函数
10
    Node(int v) : val(v), next(nullptr) {}
11
};
12

13
class LinkedStack {
14
private:
15
    // 对于链表栈，我们只需要握住一根绳子的线头即可，那就是栈顶。
16
    Node* head; // 头指针，永远指向链表的物理头部（逻辑上的栈顶）
17
    size_t count; // 额外维护一个计数器，使得 size() 操作是 O(1) 而不是 O(N) 去数链表
18

19
public:
20
    // 构造函数：天地混沌初开，链表为空
21
    LinkedStack() : head(nullptr), count(0) {}
22

23
    // 析构逻辑：与数组只需 delete[] 一次不同，链表必须从头到尾、顺藤摸瓜地斩断并释放每一个节点的独立内存
24
    ~LinkedStack() {
25
        while(head != nullptr) {
26
            pop(); // 借用 pop 逻辑销毁节点
27
        }
28
    }
29

30
    // 入栈：经典的“头插法”
31
    // 无论目前有多少元素，时间复杂度都是绝对雷打不动的 O(1)
32
    void push(int x) {
33
        Node* newNode = new Node(x); // 1. 在茫茫堆区中诞生一个新节点
34
        newNode->next = head;        // 2. 新节点的缆绳挂向当前的栈顶节点
35
        head = newNode;              // 3. 栈顶标识发生权力交接，新节点正式加冕为新栈顶
36
        count++;
37
    }
38

39
    // 出栈：摘取头部节点并将其从堆区抹除
40
    void pop() {
41
        if (!head) return;           // 防御性编程：空栈保护，防止操作空指针导致段错误
42

43
        Node* temp = head;           // 1. 暂存即将要销毁的当前栈顶，防止指针丢失
44
        head = head->next;           // 2. 栈顶指针顺着线索下移交接给第二顺位节点
45
        delete temp;                 // 3. 回收旧栈顶的物理内存，干干净净
46
        count--;
47
    }
48

49
    // 获取栈顶数据
50
    int top() const {
51
        if (!head) {
52
            throw std::out_of_range("Fatal Error: Stack is empty");
53
        }
54
        return head->val;
55
    }
56

57
    // 获取栈深
58
    size_t size() const {
59
        return count;
60
    }
61
};

1
#include <string>
2

3
// 声明一个银行账户类
4
class Account {
5
private:
6
    // 【敏感数据区，严禁外部直接触碰】
7
    std::string ownerName;  // 储户姓名
8
    std::string accountNum; // 账户号码
9
    double balance;         // 核心资产：账户余额。如果是 public，黑客可以直接执行 account.balance = 99999999; 导致系统崩溃。
10

11
public:
12
    // 【公开的业务接口区，外界与之交互的唯一合法渠道】
13

14
    // 构造函数：强制的诞生规则
15
    // 开户时，强制要求外界必须提供姓名、账号和初始金额，杜绝了“无主孤魂”账户的产生。
16
    Account(std::string name, std::string acc, double initialBalance);
17

18
    // 查询功能：常函数（const member function）
19
    // 尾部的 const 是向编译器和调用者签订的契约：“我发誓，这个函数只会只读打印数据，绝不会偷偷修改账户的任何内部状态”。
20
    void display() const;
21

22
    // 存款接口：虽然是向账户内加钱，但也必须通过该方法
23
    // 在这里我们可以未来加入日志记录、大额反洗钱告警等业务逻辑，这是 public 暴露字段所做不到的。
24
    void deposit(double amt);
25

26
    // 取款接口：包含严苛的防御性业务逻辑判断
27
    // 外部请求取款时，我们在内部校验 (amt > balance)。如果余额不足，拒绝操作并返回 false。
28
    // 这保证了对象的核心数据 invariants (不变量：余额不能为负数) 永远合法。
29
    bool withdraw(double amt);
30
};