#include <iostream>
using namespace std;
class Stack {
public:
    // 初始化栈
    void Init(int n = 4) {
        array = new int[n];
        capacity = n;
        top = 0;
    }
    // 将元素推入栈
    void Push(int x) {
        array[top++] = x;
    }
    // 获取栈顶元素
    int Top() {
        if (top > 0) {
            return array[top - 1];
        }
        return -1; // 栈为空时返回-1
    }
    // 销毁栈
    void Destroy() {
        delete[] array;
        array = nullptr;
        top = capacity = 0;
    }
private:
    int* array;      // 栈数据数组
    size_t capacity; // 栈容量
    size_t top;      // 栈顶指针
};
int main() {
    Stack st;
    st.Init();
    st.Push(1);
    st.Push(2);
    cout << st.Top() << endl;
    st.Destroy();
    return 0;
}

struct ExampleClass {
    int a; // 默认 private
};

struct ExampleStruct {
    int a; // 默认 public
};

class Date {
public:
    void Init(int year, int month, int day) {
        _year = year;
        _month = month;
        _day = day;
    }
private:
    int _year;
    int _month;
    int _day;
};
int main() {
    Date d;
    d.Init(2024, 3, 31);
    // 无法直接访问 _year, _month, _day，因为它们是私有成员
    return 0;
}

#include <iostream>
using namespace std;
class Stack {
public:
    void Init(int n = 4);
private:
    int* array;
    size_t capacity;
    size_t top;
};
// 在类外定义成员函数
void Stack::Init(int n) {
    array = new int[n];
    capacity = n;
    top = 0;
}
int main() {
    Stack st;
    st.Init();
    return 0;
}

#include <iostream>
using namespace std;
class Date {
public:
    void Init(int year, int month, int day) {
        _year = year;
        _month = month;
        _day = day;
    }
    void Print() {
        cout << _year << "/" << _month << "/" << _day << endl;
    }
private:
    int _year;
    int _month;
    int _day;
};
int main() {
    Date d1;
    d1.Init(2024, 3, 31);
    d1.Print();
    return 0;
}

#include <iostream>
using namespace std;
class A {
private:
    char _ch; // 1 字节
    int _i;   // 4 字节
};
int main() {
    A a;
    cout << sizeof(a) << endl; // 输出8字节，因内存对齐
    return 0;
}

class Date {
public:
    void Init(int year, int month, int day) {
        this->_year = year; // 使用 this 指针
        this->_month = month;
        this->_day = day;
    }
    void Print() {
        cout << this->_year << "/" << this->_month << "/" << this->_day << endl;
    }
private:
    int _year;
    int _month;
    int _day;
};
int main() {
    Date d1;
    d1.Init(2024, 3, 31);
    d1.Print();
    return 0;
}

class Person {
public:
    Person& SetName(const string& name) {
        this->name = name;
        return *this;
    }
    Person& SetAge(int age) {
        this->age = age;
        return *this;
    }
    void Display() {
        cout << "Name: "
 << name << ", Age: " << age << endl;
    }
private:
    string name;
    int age;
};
int main() {
    Person p;
    p.SetName("Alice").SetAge(30).Display();
    return 0;
}

#include <stdio.h>
#include <stdlib.h>
#include <stdbool.h>
#include <assert.h>
typedef int STDataType;
typedef struct Stack {
    STDataType* a;
    int top;
    int capacity;
} ST;
// 初始化栈
void STInit(ST* ps) {
    assert(ps);
    ps->a = NULL;
    ps->top = 0;
    ps->capacity = 0;
}
// 销毁栈
void STDestroy(ST* ps) {
    assert(ps);
    free(ps->a);
    ps->a = NULL;
    ps->top = ps->capacity = 0;
}
// 入栈
void STPush(ST* ps, STDataType x) {
    assert(ps);
    // 栈满时扩容
    if (ps->top == ps->capacity) {
        int newcapacity = ps->capacity == 0 ? 4 : ps->capacity * 2;
        STDataType* tmp = (STDataType*)realloc(ps->a, newcapacity * sizeof(STDataType));
        if (tmp == NULL) {
            perror("realloc fail");
            return;
        }
        ps->a = tmp;
        ps->capacity = newcapacity;
    }
    ps->a[ps->top] = x;
    ps->top++;
}
// 检查栈是否为空
bool STEmpty(ST* ps) {
    assert(ps);
    return ps->top == 0;
}
// 出栈
void STPop(ST* ps) {
    assert(ps);
    assert(!STEmpty(ps));
    ps->top--;
}
// 获取栈顶元素
STDataType STTop(ST* ps) {
    assert(ps);
    assert(!STEmpty(ps));
    return ps->a[ps->top - 1];
}
// 获取栈的大小
int STSize(ST* ps) {
    assert(ps);
    return ps->top;
}
int main() {
    ST s;
    STInit(&s);
    STPush(&s, 1);
    STPush(&s, 2);
    STPush(&s, 3);
    STPush(&s, 4);
    while (!STEmpty(&s)) {
        printf("%d\n", STTop(&s));
        STPop(&s);
    }
    STDestroy(&s);
    return 0;
}

#include <iostream>
#include <cassert>
using namespace std;
typedef int STDataType;
class Stack {
public:
    // 构造函数：初始化栈
    Stack(int n = 4) {
        _a = new STDataType[n];
        _capacity = n;
        _top = 0;
    }
    // 析构函数：释放内存
    ~Stack() {
        delete[] _a;
        _a = nullptr;
    }
    // 入栈
    void Push(STDataType x) {
        if (_top == _capacity) {
            Expand(); // 栈满时扩容
        }
        _a[_top++] = x;
    }
    // 出栈
    void Pop() {
        assert(_top > 0); // 保证栈不为空
        --_top;
    }
    // 获取栈顶元素
    STDataType Top() const {
        assert(_top > 0);
        return _a[_top - 1];
    }
    // 检查栈是否为空
    bool Empty() const {
        return _top == 0;
    }
    // 获取栈的大小
    size_t Size() const {
        return _top;
    }
private:
    STDataType* _a;      // 动态数组存储栈元素
    size_t _capacity;    // 栈的容量
    size_t _top;         // 栈顶指针
    // 辅助函数：扩容栈
    void Expand() {
        size_t newCapacity = _capacity * 2;
        STDataType* newArray = new STDataType[newCapacity];
        for (size_t i = 0; i < _top; ++i) {
            newArray[i] = _a[i];
        }
        delete[] _a;
        _a = newArray;
        _capacity = newCapacity;
    }
};
int main() {
    Stack s;
    s.Push(1);
    s.Push(2);
    s.Push(3);
    s.Push(4);
    cout << "栈顶元素: " << s.Top() << endl; // 输出4
    s.Pop();
    cout << "栈顶元素: " << s.Top() << endl; // 输出3
    cout << "栈的大小: " << s.Size() << endl; // 输出3
    // 继续弹出栈中元素
    while (!s.Empty()) {
        cout << s.Top() << " ";
        s.Pop();
    }
    cout << endl;
    return 0;
}