#include <iostream>
using namespace std;
int main() {
    int a, b, sum;          // ① 声明3个装整数的盒子
    cin >> a >> b;           // ② 从键盘取两个数，存入a和b
    sum = a + b;             // ③ 计算a+b，结果放sum里
    cout << "a+b=" << sum;   // ④ 输出 "a+b=" 然后输出 sum 的值
    return 0;
}

假设输入：3 5（两个数之间用空格隔开，然后按回车）

① int a, b, sum; → 在内存里画了 3 个小格子，分别叫 a、b、sum。此时它们还没值。

② cin >> a >> b; → 你输入 "3 5" 回车，系统把 3 放到 a 格子里，5 放到 b 格子里。

③ sum = a + b; → 从 a 格子里拿 3，从 b 格子里拿 5，加起来得到 8，存到 sum 格子里。

④ cout << "a+b=" << sum; → 屏幕上显示：a+b=8

// 版本一：3个整数比大小
int max(int a, int b, int c) {
    if (b > a) a = b;
    if (c > a) a = c;
    return a;
}

// 版本二：3个浮点数比大小
float max(float a, float b, float c) {
    if (b > a) a = b;
    if (c > a) a = c;
    return a;
}

① int m = max(3, 7, 5); → 编译器一看：传了3个 int，好，我调 int 版本 → 返回 7

② float n = max(4.5, 9.1, 6.3); → 编译器一看：传了3个 float，调 float 版本 → 返回 9.1

③ 如果只写 int max(int a, int b) { } 和 float max(int a, int b, int c) { }，参数个数不同也算重载。

void swap(int &a, int &b) {  // int &a 的意思是 "a是实参的别名"
    int temp = a;               // 把 a 的值保存到临时变量
    a = b;                       // 把 b 的值赋给 a（其实改的是实参本身）
    b = temp;                    // 把保存的值赋给 b
}

int main() {
    int i = 3, j = 5;
    swap(i, j);
    // 现在 i=5, j=3 ✅ 真的交换了
    return 0;
}

① swap(i, j) 被调用时，参数传递相当于 int &a = i; int &b = j;（a 是小 i，b 是小 j）

② int temp = a; → temp = 3（把 i 的当前值 3 存起来）

③ a = b; → a = 5，但 a 是 i 的别名 → 所以 i 也变成了 5

④ b = temp; → b = 3，b 是 j 的别名 → j 变成了 3

结果：i=5, j=3 ✅ 交换成功！

// ① 值传递 — 交换失败 ❌
void swap1(int a, int b) { int t = a; a = b; b = t; }
// swap1(i, j) → i=3, j=5 没变！因为 a,b 是 i,j 的副本

// ② 指针传递 — 交换成功 ✅
void swap2(int *a, int *b) { int t = *a; *a = *b; *b = t; }
// swap2(&i, &j) → i=5, j=3 需要取地址

// ③ 引用传递 — 交换成功 ✅（最简洁直观）
void swap3(int &a, int &b) { int t = a; a = b; b = t; }
// swap3(i, j) → i=5, j=3 不用取地址，直接传变量

class Array_max {         // 声明一个"找数组最大值"的类
public:
    void set_value();      // 输入10个数
    void max_value();      // 找最大值
    void show_value();     // 输出结果
private:
    int array[10];          // 存放10个数的数组
    int max;                 // 存最大值
};

// ---- 类外定义成员函数 ----
void Array_max::set_value() {
    for (int i = 0; i < 10; i++)
        cin >> array[i];
}
void Array_max::max_value() {
    max = array[0];           // 先假设第一个最大
    for (int i = 1; i < 10; i++)  // 从第二个开始比
        if (array[i] > max) max = array[i];
}
void Array_max::show_value() {
    cout << "max=" << max;
}

int main() {
    Array_max arrmax;            // 创建对象
    arrmax.set_value();          // 调用方法：对象名.函数名
    arrmax.max_value();
    arrmax.show_value();
    return 0;
}

class A {
    int x, y;
public:
    void Setxy(int x, int y) {
        // this->x 表示"我这个对象的x"，后面的 x 是参数 x
        this->x = x;    // 相当于 对象.x = 传入的x
        this->y = y;
    }
    A* getThis() { return this; }  // 返回自己的地址
};

① 当你写 a.Setxy(3, 5)，编译器偷偷传了对象的地址 → 相当于 A::Setxy(&a, 3, 5)

② 函数内部 this 就是 &a

③ this->x = x 等价于 a.x = 3

④ 在成员函数里直接写 x = 3 时，x 前面其实隐含着 this->

class Time {
public:
    Time() {               // 构造函数名 = 类名，无返回值
        hour = 0;        // 初始化成员
        minute = 0;
        sec = 0;
    }
};
Time t1;                   // 自动调 Time()，t1的hour=0

class Box {
public:
    // 初始化表写法 :height(h) 相当于在体内写 height = h
    Box(int h, int w, int len): height(h), width(w), length(len) {}
// 等价于 ↓
//  Box(int h, int w, int len) { height = h; width = w; length = len; }

    int volume() { return height * width * length; }
private:
    int height, width, length;
};

Box box1(12, 25, 30);     // 传参，自动调 Box(12,25,30)
cout << box1.volume();    // 12×25×30 = 9000

① 执行 Box box1(12,25,30); → 在内存中创建了一个 Box 对象

② 自动调用构造函数 → 初始化表 : height(12), width(25), length(30) → 三个格子分别存入 12、25、30

③ box1.volume() → 计算 12 × 25 × 30 = 9000 ← 输出结果

class Box {
public:
    Box() { height=10; width=10; length=10; }           // 无参 → 默认10
    Box(int h, int w, int len): height(h), width(w), length(len) {}  // 有参
};

Box box1;                      // 调无参 → 10,10,10
Box box2(15, 30, 25);          // 调有参 → 15,30,25

一个类可以有多个构造函数，但创建对象时只执行其中一个，系统根据参数匹配。

class Student {
public:
    Student(int n, string nam, char s) {     // 构造函数
        num = n;  name = new string(nam);  sex = s;
        cout << "Constructor called." << endl;
    }
    ~Student() {                                    // 析构函数
        delete name;      // 清理 new 出来的内存
        cout << "Destructor called." << endl;
    }
private:
    int num;  string *name;  char sex;
};

int main() {
    Student *s1 = new Student(10010, "Wang", 'f');
    delete s1;              // → 调用析构函数 ❗

    Student s2(10011, "Zhang", 'm');
    // main 结束 → 自动调 s2 的析构函数
}

Constructor called. （s1 创建）→ Destructor called.（delete s1）→ Constructor called.（s2 创建）→ Destructor called.（main 结束，s2 销毁）

class Time {
public:
    Time(int h, int m, int s): hour(h), minute(m), sec(s) {}
    void show_time() const {     // const 放在函数后面，承诺不改数据
        cout << hour << ":" << minute << ":" << sec;
    }
private:
    int hour, minute, sec;
};

const Time t1(10, 20, 30);   // 常对象
t1.show_time();                  // ✅ 常对象只能调用常成员函数
// t1.hour = 12;               ❌ 常对象的成员不能修改

class Complex {
public:
    Complex(double r, double i): real(r), imag(i) {}
    Complex operator+(Complex &c2) {          // 重载 + 号
        return Complex(real + c2.real, imag + c2.imag);
    }
private:
    double real, imag;
};

// 使用：
Complex c1(3, 4), c2(5, -10), c3;
c3 = c1 + c2;      // 编译器解释为 c1.operator+(c2)
// 相当于 c3.real = 3+5 = 8, c3.imag = 4+(-10) = -6

① c1 + c2 被系统翻译为 c1.operator+(c2)（成员函数形式，c1 是调用者，c2 是参数）

② 进入函数：return Complex(real + c2.real, imag + c2.imag);

③ real 是谁？就是 c1 的 real（因为 c1 调用的这个函数，函数的 real 就是 c1 的成员）

④ 计算：real(3) + c2.real(5) = 8，imag(4) + c2.imag(-10) = -6

⑤ 返回新创建的 Complex(8, -6)，赋值给 c3

结果：c3 = (8, -6i) ✅

class Complex {
    friend ostream& operator<<(ostream &out, Complex &c);  // 声明为友元
    friend istream& operator>>(istream &in, Complex &c);
private:
    double real, imag;
};

// 输出：必须返回 ostream& 才能连续输出（如 cout << a << b）
ostream& operator<<(ostream &out, Complex &c) {
    out << "(" << c.real << "," << c.imag << "i)";
    return out;
}
// 输入
istream& operator>>(istream &in, Complex &c) {
    cout << "输入实部和虚部:";
    in >> c.real >> c.imag;
    return in;
}

// 使用：
Complex c1(3, 4);
cout << c1;              // 输出 (3,4i)
cin >> c1;               // 输入实部和虚部

① 必须返回 ostream&（引用）而不是 ostream（值）—— 因为 ostream 不允许复制

② 必须返回 return out; — 才能实现 cout << a << b 链式调用（第一次返回的 out 接着给第二次用）

③ 为什么必须是友元？因为第一个参数是 ostream&，不是你的类，没法写成成员函数。

class String {
    friend bool operator>(String &s1, String &s2);
    friend bool operator<(String &s1, String &s2);
    friend bool operator==(String &s1, String &s2);
private:
    char *p;
public:
    String(char *str): p(str) {}
};

bool operator>(String &s1, String &s2) {
    return strcmp(s1.p, s2.p) > 0;  // 用 strcmp 比较 C 风格字符串
}
// 使用：
String s1("Hello"), s2("Book");
cout << (s1 > s2);   // 1 (true)，因为 'H' > 'B'

class Student1: public Student {     // 继承 Student
private:
    int age;
    string addr;
public:
    // 总参数表: 先用一部分参数调基类构造函数，剩下的初始化自己的成员
    Student1(int n, string nam, int a, string ad):
        Student(n, nam),          // 调基类构造函数
        age(a),  addr(ad)         // 初始化自己的成员
    { }
};

// 多层派生时写的规则：只调用直接基类
Student2(int n, string nam, int a, int s):
    Student1(n, nam, a), score(s) { }         // ✅ 正确（只调直接基类 Student1）
// Student2(n, nam, a, s): Student(n, nam), Student1(n, nam, a), score(s) {}  ❌ 错误

class Teacher {
protected:  string name; int age; string title;
};
class Student {
protected:  string name1; char sex; float score;
};

// 多重继承：Graduate 同时继承 Teacher 和 Student
class Graduate: public Teacher, public Student {
    float wage;
public:
    // 构造：初始化表中列出所有基类的构造函数
    Graduate(string nam, int a, char s, string t, float sco, float w):
        Teacher(nam, a, t), Student(nam, s, sco), wage(w) {}
};

按照声明派生类时基类的出现顺序——先 Teacher 后 Student。所以：Teacher() → Student() → Graduate()

class Base {
public:
    virtual void display() { cout << "Base::display()" << endl; }
};
class B1: public Base {
public:
    virtual void display() { cout << "B1::display()" << endl; }  // 自动成为虚函数
};
class D1: public B1 {
public:
    virtual void display() { cout << "D1::display()" << endl; }
};

// 👇 核心：用一个函数，传不同的对象指针
void fun(Base *ptr) {
    ptr->display();     // 动态关联！运行的时候才知道调哪个
}

int main() {
    Base b0;  B1 b1;  D1 d1;
    fun(&b0);    // 输出: Base::display()
    fun(&b1);    // 输出: B1::display()
    fun(&d1);    // 输出: D1::display()
}

① virtual void display() — 加上 virtual，表示这个函数以后可能被派生类"覆盖"（override）

② fun(Base *ptr) — 参数是基类指针，可以接受任何派生类对象的地址（因为派生类对象也是基类对象）

③ ptr->display() — 如果没加 virtual，不管 ptr 指向谁，永远调 Base 的 display

④ 加了 virtual 后 → 系统在运行时检查 ptr 实际指向的对象类型，调用对应版本的 display

这就是"一个接口，多种方法"的多态！

class Shape {               // 抽象基类
public:
    virtual void area() = 0;   // 纯虚函数，=0 表示"我不实现，子类去实现"
};

class Circle: public Shape {
    float r;
public:
    Circle(float rr): r(rr) {}
    void area() { cout << 3.14 * r * r; }  // 派生类必须实现
};

// Shape s;     ❌ 抽象类不能创建对象
Shape *p;          // ✅ 可以声明指针
Circle c(15);
p = &c;
p->area();         // 调 Circle 的 area() → 3.14×15×15 = 706.5

抽象类的设计意图：定一套标准（接口），所有子类必须遵守。就像驾照考试规则全国统一，但每个考场具体执行。

class Shape {                                      // 抽象基类
public:
    virtual float area() const { return 0.0; }    // 虚函数
    virtual float volume() const { return 0.0; }  // 虚函数
    virtual void shapeName() const = 0;          // 纯虚函数
};

class Point: public Shape {                         // 点 → 公有继承 Shape
protected: float x, y;
public:
    Point(float a = 0, float b = 0): x(a), y(b) {}
    virtual void shapeName() const { cout << "Point:"; }  // 实现纯虚函数
};

class Circle: public Point {                          // 圆 → 继承 Point
protected: float radius;
public:
    Circle(float x, float y, float r): Point(x, y), radius(r) {}
    virtual float area() const { return 3.14159 * radius * radius; }
    virtual void shapeName() const { cout << "Circle:"; }
};

class Cylinder: public Circle {                        // 圆柱 → 继承 Circle
    float height;
public:
    Cylinder(float x, float y, float r, float h): Circle(x, y, r), height(h) {}
    virtual float area() const { return 2 * Circle::area() + 2 * 3.14159 * radius * height; }
    virtual float volume() const { return Circle::area() * height; }
    virtual void shapeName() const { cout << "Cylinder:"; }
};

// 使用：基类指针 → 动态关联
Shape *pt;
pt = &point;  pt->shapeName();  // Point:
pt = &circle; pt->shapeName();  // Circle:
pt = &cyl;    pt->shapeName();  // Cylinder:
// area() 和 volume() 同样动态关联

这个例子完美展示了：抽象基类(Shape)定义统一接口 → 派生类逐层实现具体功能 → 基类指针实现多态。是理解虚函数+抽象类的最佳范例。