#include <iostream>
using namespace std;
class MyClass {
    // 未寫關鍵字，class默認private
    int default_val = 0; 
public:
    int pub_val = 10;    // 公有成員
    void pub_func() {
        // 類內(nèi)：能訪問所有成員（public/private/protected）
        cout << "類內(nèi)訪問 private_val: " << pri_val << endl;
        cout << "類內(nèi)訪問 protected_val: " << pro_val << endl;
        cout << "類內(nèi)訪問 default_val: " << default_val << endl;
    }
private:
    int pri_val = 20;    // 私有成員
    void pri_func() { cout << "私有函數(shù)" << endl; }
protected:
    int pro_val = 30;    // 受保護成員
    void pro_func() { cout << "受保護函數(shù)" << endl; }
};
// 派生類（子類）
class Derived : public MyClass {
public:
    void derived_func() {
        // 派生類：能訪問基類的public/protected，不能訪問private
        cout << "派生類訪問 pub_val: " << pub_val << endl;       // ? 允許
        cout << "派生類訪問 pro_val: " << pro_val << endl;       // ? 允許
        // cout << "派生類訪問 pri_val: " << pri_val << endl;    // ? 禁止：private不可訪問
        pro_func();                                             // ? 允許調(diào)用protected函數(shù)
        // pri_func();                                          // ? 禁止調(diào)用private函數(shù)
    }
};
int main() {
    MyClass obj;
    // 類外：僅能訪問public成員
    cout << "類外訪問 pub_val: " << obj.pub_val << endl;         // ? 允許
    // cout << "類外訪問 pro_val: " << obj.pro_val << endl;     // ? 禁止：protected不可訪問
    // cout << "類外訪問 pri_val: " << obj.pri_val << endl;     // ? 禁止：private不可訪問
    obj.pub_func();                                             // ? 允許調(diào)用public函數(shù)
    // obj.pro_func();                                          // ? 禁止調(diào)用protected函數(shù)
    // obj.pri_func();                                          // ? 禁止調(diào)用private函數(shù)
    Derived d_obj;
    d_obj.derived_func();                                       // ? 派生類內(nèi)部邏輯正常執(zhí)行
    return 0;
}

#include <iostream>
using namespace std;
class MyClass {
private:
    int m_val = 10;
public:
    // 訪問同類型另一個對象的private成員
    void accessAnotherObj(MyClass& other) {
        cout << "訪問另一個對象的private成員：" << other.m_val << endl; // ? 允許
        other.m_val = 20; // ? 可修改
    }
    int getVal() const { return m_val; }
};
int main() {
    MyClass a, b;
    a.accessAnotherObj(b); // 輸出：訪問另一個對象的private成員：10
    cout << "修改后b的val：" << b.getVal() << endl; // 輸出：20
    return 0;
}

#include <iostream>
using namespace std;
// 基類
class Base {
public:
    int pub_val = 1;
protected:
    int pro_val = 2;
private:
    int pri_val = 3;
};
// 1. public繼承（開發(fā)中99%的場景，推薦）
class DerivedPub : public Base {
public:
    void show() {
        cout << "pub_val: " << pub_val << endl;  // ? public → public
        cout << "pro_val: " << pro_val << endl;  // ? protected → protected
        // cout << pri_val << endl;              // ? 始終不可訪問
    }
};
// 2. protected繼承
class DerivedPro : protected Base {
public:
    void show() {
        cout << "pub_val: " << pub_val << endl;  // ? public → protected
        cout << "pro_val: " << pro_val << endl;  // ? protected → protected
    }
};
// 3. private繼承
class DerivedPri : private Base {
public:
    void show() {
        cout << "pub_val: " << pub_val << endl;  // ? public → private
        cout << "pro_val: " << pro_val << endl;  // ? protected → private
    }
};
int main() {
    DerivedPub d_pub;
    cout << d_pub.pub_val << endl;  // ? public繼承后，基類public仍為public，類外可訪問
    // cout << d_pub.pro_val << endl; // ? protected，類外不可訪問
    DerivedPro d_pro;
    // cout << d_pro.pub_val << endl; // ? public繼承后變?yōu)閜rotected，類外不可訪問
    DerivedPri d_pri;
    // cout << d_pri.pub_val << endl; // ? public繼承后變?yōu)閜rivate，類外不可訪問
    return 0;
}

#include <iostream>
using namespace std;
// 頂層基類
class A {
public:
    int pub_a = 1;
protected:
    int pro_a = 2;
};
// 第二層：B public繼承A
class B : public A {
public:
    void showB() {
        cout << "B中訪問A的pub_a：" << pub_a << endl; // ? public→public
        cout << "B中訪問A的pro_a：" << pro_a << endl; // ? protected→protected
    }
};
// 第三層：C protected繼承B
class C : protected B {
public:
    void showC() {
        // A的pub_a：A→B（public）→C（protected）→ 最終C中是protected
        cout << "C中訪問A的pub_a：" << pub_a << endl; // ? 允許（C內(nèi)可訪問protected）
        // A的pro_a：A→B（protected）→C（protected）→ 最終C中是protected
        cout << "C中訪問A的pro_a：" << pro_a << endl; // ? 允許
    }
};
// 第四層：D private繼承C
class D : private C {
public:
    void showD() {
        // A的pub_a：經(jīng)過三層繼承后變?yōu)閜rivate
        cout << "D中訪問A的pub_a：" << pub_a << endl; // ? D內(nèi)可訪問private
    }
};
int main() {
    C c;
    // cout << c.pub_a << endl; // ? C中pub_a是protected，類外不可訪問
    D d;
    // cout << d.pub_a << endl; // ? D中pub_a是private，類外不可訪問
    return 0;
}

#include <iostream>
using namespace std;
class MyClass {
private:
    static int s_pri_val; // 靜態(tài)私有成員
protected:
    static int s_pro_val; // 靜態(tài)受保護成員
public:
    static int s_pub_val; // 靜態(tài)公有成員
    static void showStatic() {
        // 類內(nèi)可訪問所有靜態(tài)成員
        cout << "靜態(tài)私有：" << s_pri_val << endl;
        cout << "靜態(tài)受保護：" << s_pro_val << endl;
    }
};
// 靜態(tài)成員必須類外初始化
int MyClass::s_pri_val = 10;
int MyClass::s_pro_val = 20;
int MyClass::s_pub_val = 30;
// 派生類
class Derived : public MyClass {
public:
    static void showDerivedStatic() {
        // 派生類可訪問基類的static protected/public
        cout << "派生類訪問靜態(tài)受保護：" << s_pro_val << endl; // ?
        cout << "派生類訪問靜態(tài)公有：" << s_pub_val << endl;   // ?
        // cout << s_pri_val << endl; // ? 靜態(tài)私有仍不可訪問
    }
};
int main() {
    // 類外僅能訪問靜態(tài)公有成員
    cout << MyClass::s_pub_val << endl; // ? 30
    // cout << MyClass::s_pro_val << endl; // ? 靜態(tài)受保護，類外不可訪問
    // cout << MyClass::s_pri_val << endl; // ? 靜態(tài)私有，類外不可訪問
    Derived::showDerivedStatic(); // ? 派生類內(nèi)可訪問靜態(tài)受保護
    return 0;
}

#include <iostream>
using namespace std;
class Base {
protected:
    int m_val = 10;
};
class DerivedA : public Base {
public:
    // 錯誤場景：DerivedA試圖訪問DerivedB對象的protected成員
    void accessDerivedB(DerivedB& b) {
        // cout << b.m_val << endl; // ? 禁止：不能訪問其他子類對象的protected
    }
    // 正確場景：訪問自己的protected成員
    void accessSelf() {
        cout << m_val << endl; // ? 允許
    }
};
class DerivedB : public Base {}; // 另一個子類
int main() {
    DerivedA a;
    DerivedB b;
    a.accessSelf(); // ? 輸出10
    // a.accessDerivedB(b); // ? 編譯報錯
    return 0;
}

#include <iostream>
using namespace std;
class MyClass {
private:
    int pri_val = 100;
    // 聲明友元函數(shù)：僅授權showPrivate函數(shù)訪問當前類的私有成員
    friend void showPrivate(MyClass& obj);
};
// 友元函數(shù)：可以直接訪問MyClass的private成員（無需通過public接口）
void showPrivate(MyClass& obj) {
    cout << "訪問private成員: " << obj.pri_val << endl; // ? 允許
}
int main() {
    MyClass obj;
    showPrivate(obj); // 輸出：訪問private成員: 100
    return 0;
}

#include <iostream>
using namespace std;
class A {
    // 聲明B為友元類：B的所有成員函數(shù)都能訪問A的私有/受保護成員
    friend class B; 
private:
    int m_val = 100;
};
class B {
public:
    // B的公有成員函數(shù)：訪問A的私有成員
    void accessA(A& a) {
        cout << a.m_val << endl; // ? 允許
    }
private:
    // B的私有成員函數(shù)：同樣能訪問A的私有成員（友元類的所有成員函數(shù)都有權限）
    void privateAccessA(A& a) {
        a.m_val = 200; // ? 允許修改
    }
};
int main() {
    A a;
    B b;
    b.accessA(a); // 輸出：100
    return 0;
}

#include <iostream>
using namespace std;
// 前置聲明：必須先聲明A，才能在B的成員函數(shù)參數(shù)中使用A的引用
class A;
class B {
public:
    // 先聲明需要授權的成員函數(shù)（僅該函數(shù)需要訪問A的私有成員）
    void onlyThisFuncCanAccessA(A& a); 
};
class A {
    // 僅授權B類的onlyThisFuncCanAccessA成員函數(shù)訪問當前類的私有成員
    friend void B::onlyThisFuncCanAccessA(A& a);
private:
    int m_val = 500;
};
// 實現(xiàn)授權的成員函數(shù)：可直接訪問A的私有成員
void B::onlyThisFuncCanAccessA(A& a) {
    cout << a.m_val << endl; // ? 允許
}
int main() {
    A a;
    B b;
    b.onlyThisFuncCanAccessA(a); // 輸出：500
    return 0;
}

// 錯誤
class Student {
public:
    int m_age; // 外部可直接賦值 m_age = -5，數(shù)據(jù)完全不安全
};
// 正確
class Student {
private:
    int m_age;
public:
    void setAge(int age) {
        if (age >= 0 && age <= 120) m_age = age; // 帶校驗的寫接口
    }
    int getAge() const { return m_age; } // 只讀接口
};

// 錯誤
class Base {
public:
    int m_id; // 本應給子類復用的成員，被外部隨意修改
};
// 正確
class Base {
protected:
    int m_id;
public:
    int getId() const { return m_id; } // 僅暴露只讀接口
};

// 錯誤：授權多個類/函數(shù)，封裝形同虛設
class A {
    friend class B;
    friend class C;
    friend void func1();
    friend void func2();
private:
    int m_data;
};
// 正確：僅授權必要的函數(shù)/類
class A {
    friend void onlyNecessaryFunc(A& a);
private:
    int m_data;
};

#include <iostream>
using namespace std;
class Base {
private:
    virtual void func() { cout << "Base::func" << endl; }
public:
    void callFunc() { func(); } // 公有接口調(diào)用私有虛函數(shù)
};
class Derived : public Base {
private:
    void func() override { cout << "Derived::func" << endl; }
};
int main() {
    Base* ptr = new Derived();
    ptr->callFunc(); // 輸出：Derived::func
    delete ptr;
    return 0;
}