#include <iostream>
#include <string>
using namespace std;
// 前置聲明：僅依賴類名，無需完整定義，耦合極低
class student;
class manager {
public:
    // 函數(shù)形參：依賴關(guān)系
    bool addStu(student s);
    bool delStu(student s);
};
// 完整類定義
class student {
    int sid;
    string name;
public:
    student(int sid, string name):sid(sid),name(name){}
    friend class manager;
};
bool manager::addStu(student s) {
    cout << "正在添加學(xué)生:" << s.sid << "(" << s.name << ")" << endl;
    return true;
}
bool manager::delStu(student s) {
    cout << "正在刪除學(xué)生:" << s.sid << "(" << s.name << ")" << endl;
    return false;
}
int main() {
    manager m;
    student s1(1001, "李明"), s2(1003, "王明");
    m.addStu(s1);
    m.addStu(s2);
    m.delStu(s1);
    return 0;
}

#include <iostream>
#include <string>
using namespace std;
class Point;
class Line {
    // 成員指針：長期持有Point對象，【關(guān)聯(lián)關(guān)系】
    Point* p1, * p2;
public:
    Line():p1(nullptr),p2(nullptr){}
    // 函數(shù)參數(shù)：臨時接收Point對象，【依賴關(guān)系】
    void addPoint1(Point *p){
        p1 = p;
    }
    void addPoint2(Point* p) {
        p2 = p;
    }
    void draw();
};
class Point {
    int x, y;
public:
    Point(int x, int y):x(x),y(y){}
    friend class Line;
};
void Line::draw() {
    cout << "S(" << p1->x << "," << p1->y << ")";
    cout << string(20, '-');
    cout << "E(" << p2->x << "," << p2->y << ")" << endl;
}
int main() {
    // Point對象獨立創(chuàng)建、獨立銷毀
    Point p1(0, 0), p2(10, 10);
    Line line;
    line.addPoint1(&p1);
    line.addPoint2(&p2);
    line.draw();
    return 0;
}

#include <iostream>
using namespace std;
class Point;
class Rect {
    // 從屬對象指針，組合關(guān)系核心成員
    Point* s;
    int w, h;
public:
    // 整體構(gòu)造時：主動創(chuàng)建部分對象
    Rect(int x, int y, int w, int h) {
        s = new Point(x, y);
        this->w = w;
        this->h = h;
    }
    // 整體析構(gòu)時：主動銷毀部分對象，釋放堆內(nèi)存
    ~Rect() {
        delete s;
    }
};
class Point {
    int x, y;
public:
    Point(int x, int y):x(x),y(y){}
};
int main() {
    // Rect創(chuàng)建即創(chuàng)建Point，Rect銷毀即銷毀Point
    Rect rect(2, 2, 100, 200);
    return 0;
}

#include <iostream>
using namespace std;
// 類模板：通用代碼藍(lán)圖，無真實類定義
template<typename T>
class Add {
    T a, b;
public:
    Add(T a, T b):a(a),b(b){}
    T getResult() {
        return a + b;
    }
};
int main() {
    // 模板具體化：編譯期生成對應(yīng)類型的真實類
    Add<int> a1(10, 20);
    Add<float> a2(2.15, 3.16);
    Add<double>  a3(2.11, 3.33);
    cout << a1.getResult() << endl;
    cout << a2.getResult() << endl;
    cout << a3.getResult() << endl;
    return 0;
}

#include <iostream>
using namespace std;
class A {
    int v;  // 私有成員，任何繼承都無法直接訪問
protected:
    void hi() {
        cout << " hi A(): " << endl;
    }
public:
    A(int v):v(v){
        cout << " A(int v): " << this << endl;
    }
    void hello() {
        hi();
        cout << "v is " << v << endl;
    }
    ~A() {
        cout << "~A(): " << this << endl;
    }
};
// 不顯式指定訪問限定符，默認(rèn)private繼承
class B : A {
public:
    B() :A(0) {
        cout << "  B(): " << this << endl;
    }
    B(int v) : A(v) {
        cout << " B(int v)" << endl;
    }
    // 重寫父類方法，擴展子類邏輯
    void hello() {
        cout << "-----B----" << endl;
        A::hello();
    }
    ~B() {
        cout << "~B():" << this << endl;
    }
};
int main() {
    B b;
    B b2(20);
    b.hello();
    b2.hello();
    cout << "---over---" << endl;
    return 0;
}

#include <iostream>
class Base {
public:
    Base() { std::cout << "1. 父類構(gòu)造" << std::endl; }
};
class Member {
public:
    Member() { std::cout << "2. 子類成員變量構(gòu)造" << std::endl; }
};
class Derived : public Base {
private:
    Member m;
public:
    Derived() : m() { 
        std::cout << "3. 子類構(gòu)造函數(shù)體執(zhí)行" << std::endl;
    }
};
int main() {
    Derived d;
    return 0;
}
//輸出：
//    1. 父類構(gòu)造
//    2. 子類成員變量構(gòu)造
//    3. 子類構(gòu)造函數(shù)體執(zhí)行

#include <iostream>
class Base {
public:
    Base() { std::cout << "構(gòu)造: 父類" << std::endl; }
    ~Base() { std::cout << "析構(gòu): 父類" << std::endl; }
};
class Member {
public:
    Member() { std::cout << "構(gòu)造: 子類成員變量" << std::endl; }
    ~Member() { std::cout << "析構(gòu): 子類成員變量" << std::endl; }
};
class Derived : public Base {
private:
    Member m;
public:
    Derived() : m() { 
        std::cout << "構(gòu)造: 子類構(gòu)造函數(shù)體" << std::endl; 
    }
    ~Derived() { 
        std::cout << "析構(gòu): 子類析構(gòu)函數(shù)體" << std::endl; 
    }
};
int main() {
    Derived d;
    return 0;
}
//輸出：
//    構(gòu)造: 父類
//    構(gòu)造: 子類成員變量
//    構(gòu)造: 子類構(gòu)造函數(shù)體
//    析構(gòu): 子類析構(gòu)函數(shù)體
//    析構(gòu): 子類成員變量
//    析構(gòu): 父類

#include <iostream>
using namespace std;
// 父類
class Parent {
public:
    void show() {
        cout << "我是父類的show()函數(shù)" << endl;
    }
};
// 子類重寫（隱藏）父類同名函數(shù)
class Child : public Parent {
public:
    void show() {
        cout << "我是子類的show()函數(shù)" << endl;
        // 主動調(diào)用父類被隱藏的同名函數(shù)
        Parent::show();
    }
};
int main() {
    Child c;
    // 默認(rèn)調(diào)用子類重寫的函數(shù)（就近原則）
    c.show();
    // 強制指定調(diào)用父類同名函數(shù)
    c.Parent::show();
    return 0;
}

class Father { int a; };
class Son : public Father { int b; };
Son son;  // 聲明一個子類對象

son 對象的地址（0x100） →  ┌─────────────┐
                          │ Father::a   │  ← 這就是父類子對象
                          ├─────────────┤
                          │ Son::b      │
                          └─────────────┘

#include <iostream>
#include <string>
using namespace std;
class Person {
    int pid;
    string name;
public:
    Person(int pid, string name):pid(pid),name(name){}
    void show() {
        cout << pid << "," << name;
    }
protected:
    void setPid(int pid) {
        this->pid = pid;
    }
};
class Student : public Person {
    string clsName;
    float score;
public:
    Student(int pid, string name, string clsName,float score): Person(pid,name), clsName(clsName),score(score){}
    void show() {
        Person::show();
        cout << "," << clsName << "," << score << endl;
    }
    void updatePid(int pid) {
        // 通過父類protected接口修改父類私有成員
        setPid(pid);
    }
};
int main() {
    Person p(1, "Disen");
    Student s(1, "Disen", "C++2603", 100);
    cout << "Person 父類內(nèi)存大?。? << sizeof(p) << endl;   // x86:32字節(jié)
    cout << "Student 子類內(nèi)存大小：" << sizeof(s) << endl;  // x86:64字節(jié)
    s.show();
    s.updatePid(1001);
    s.show();
    return 0;
}

#include <iostream>
using namespace std;
class P {
    int v;
public:
    P():v(0){ 
       cout << "P(): " << this << "->" << v << endl;
    }
    P(int v):v(v){
        cout << "P(int): " << this  << "->" << v << endl;
    }
    P(const P& o) {
        cout << "P(const P& o): " << this << " copy from " << &o << endl;
        v = o.v;
    }
    P& operator=(const P& o) {
        if (this == &o) return *this;
        v = o.v;
        return *this;
    }
    friend class C;
};
class C : public P {
    int m;
public:
    C(int v, int m) : P(v), m(m) {
        cout << " C(int v, int m):" << this << "->" << v << "," << m << endl;
    }
    // 主動調(diào)用父類拷貝構(gòu)造，完整拷貝父類成員
    C(const C& o): P(o){
        m = o.m;
        cout << "C(const C& o): " << this << " copy from " << &o << endl;
    }
    // 主動調(diào)用父類賦值重載，完整覆蓋父類數(shù)據(jù)
    C& operator=(const C& o) {
        if (this == &o) return *this;
        P::operator=(o); 
        m = o.m;
        return *this;
    }
    void show() {
        cout << "v:" << v << ", m:" << m << endl;
    }
    void update(int v, int m) {
        this->v = v;
        this->m = m;
    }
};
int main() {
    C c1(2, 10);
    C c2 = c1;
    c1.show();
    c2.show();
    c2.update(100, 50);
    c2.show();
    c1 = c2;
    c1.show();
    return 0;
}

#include <iostream>
#include <cstring>
#include <string>
using namespace std;
// 父類：含堆內(nèi)存成員
class Book {
    char* name;
    float price;
public:
    // 普通構(gòu)造
    Book(const string &name, float price):price(price){
        this->name = new char[64] {0};
        memcpy(this->name, name.c_str(), name.size());
    }
    // 父類深拷貝構(gòu)造
    Book(const Book & o){
        this->name = new char[64] {0};
        memcpy(this->name, o.name, strlen(o.name));
        price = o.price;
    }
    // 父類深拷貝賦值
    Book& operator=(const Book& o) {
        if (this == &o) return *this;
        // 釋放自身舊內(nèi)存，避免內(nèi)存泄漏
        if (name != nullptr) delete[] name;
        // 重新開辟內(nèi)存，深度拷貝數(shù)據(jù)
        name = new char[64] {0};
        memcpy(this->name, o.name, strlen(o.name));
        price = o.price;
        return *this;
    }
    // 父類析構(gòu)釋放堆內(nèi)存
    ~Book() {
        delete[] name;
    }
    friend ostream& operator<<(ostream& out, Book& b) {
        cout << b.name << "|" << b.price;
        return out;
    }
};
// 子類：繼承父類，新增自有堆內(nèi)存成員
class ITBook : public Book {
    char* author;
    int codelines;
public:
    // 子類構(gòu)造
    ITBook(const string& name, const string& author,
        float price, int codelines): Book(name, price),codelines(codelines) {
        this->author = new char[64] {0};
        memcpy(this->author, author.c_str(), author.size());
    }
    // 子類深拷貝構(gòu)造：先拷貝父類，再拷貝子類
    ITBook(const ITBook& o):Book(o),codelines(o.codelines) {
        this->author = new char[64] {0};
        memcpy(this->author, o.author, strlen(o.author));
    }
    // 子類深拷貝賦值
    ITBook & operator=(const ITBook& o){
        if (this == &o) return *this;
        if (author != nullptr) delete[] author;
        // 復(fù)用父類賦值邏輯
        Book::operator=(o);
        author = new char[64] {0};
        memcpy(this->author, o.author, strlen(o.author));
        codelines = o.codelines;
        return *this;
    }
    friend ostream& operator<<(ostream& out, ITBook& b) {
        cout << (Book&)b;
        cout << " | " << b.author << " | " << b.codelines;
        return out;
    }
    // 子類析構(gòu)釋放自有堆內(nèi)存
    ~ITBook() {
        delete[] author;
    }
};
int main() {
    ITBook b1("C++ 2026", "Disen", 55.85, 5000);
    ITBook b2 = b1;       // 觸發(fā)深拷貝構(gòu)造
    ITBook b3("Linux 2026", "蘇sir", 85.85, 1000);
    b2 = b3;              // 觸發(fā)深拷貝賦值
    cout << b1 << endl;
    cout << b2 << endl;
    return 0;
}

#include <iostream>
using namespace std;
class F {
    static const int I = 100;
public:
    static int getVal() {
        return I;
    }
};
class H: public F{
public:
    // 隱藏父類靜態(tài)函數(shù)，無多態(tài)特性
    static int getVal() {
        return F::getVal() + 100;
    }
};
int main() {
    H h;
    cout <<"H:" << h.getVal() << endl;
    cout << "H:" << H::getVal() << endl;
    cout <<"F:" << F::getVal() << endl;
    // 地址不同，證明是兩個獨立函數(shù)
    cout << &F::getVal << "==" << &H::getVal << endl;
    return 0;
}

#include <iostream>
using namespace std;
class A {
    int v;
public:
    A(int v):v(v){}
    friend class B; // B是A的友元
};
// 子類繼承A，新增私有成員x
class C : public A {
    int x;
public:
    C(int v, int x):A(v),x(x){}
};
class B {
public:
    void showA(A& a) {
        cout << "A:v=" << a.v << endl;
    }
    void showC(C& c) {
        // 可訪問繼承自A的私有成員
        cout << "C:v=" << c.v << endl; 
        // 報錯！友元不可繼承，無法訪問子類獨有私有成員x
        // cout << "C:x=" << c.x  << endl;
    }
};
int main() {
    A a(21);
    C c(25, 34);
    B b;
    b.showA(a);
    b.showA(c);
    b.showC(c);
    return 0;
}

#include <iostream>
#include <string>
using namespace std;
class Phone {
public:
    void sendMsg(const string& phone,const string& msg) {
        cout << "向 " << phone << "發(fā)送：" << msg << endl;
    }
    void call(const string& phone) {
        cout << "正在給" << phone << " 打電話" << endl;
    }
};
class  L2Phone {
public:
    void sendMsg(const string& phone, const string& msg) {
        cout << "VV 向 " << phone << "發(fā)送 " << msg << endl;
    }
    void sendColorMsg() {
        cout << "sendColorMsg()" << endl;
    }
};
class L3Phone {
public:
    void sendMsg(const string& phone, const string& msg) {
        cout << "CC 向 " << phone << "發(fā)送 " << msg << endl;
    }
    void playMp3() {
        cout << "playMp3()" << endl;
    }
    void playMp4() {
        cout << "playMp4()" << endl;
    }
};
// 多重繼承：同時復(fù)用三個父類功能
class MIPhone: public Phone,public L2Phone,public L3Phone {
public:
    MIPhone() {
        cout << "Welcome XiaoMi Phone" << endl;
    }
};
int main() {
    MIPhone p;
    p.call("17791692095");
    // 顯式指定父類，解決同名函數(shù)二義性
    p.L2Phone::sendMsg("17791692095", "晚上吃什么?");
    p.playMp4();
    p.playMp3();
    return 0;
}