《C++进阶之继承多态》【final + 继承与友元 + 继承与静态成员 + 继承模型 + 继承和组合】

class NonInheritable
{
private:
	NonInheritable()  // 私有构造函数，外部无法直接调用
	{ }
    
	NonInheritable(const NonInheritable&) = delete;  // 若需要拷贝构造，也设为私有（可选）
    
public:
	static NonInheritable create()  // 静态函数，提供创建对象的唯一入口
	{
		return NonInheritable();
	}
};

// 错误：派生类 Sub 构造时，需调用基类 NonInheritable 的构造函数，但基类构造函数私有，无法访问
class Sub : public NonInheritable
{

};

class FinalClass final 
{ 
    // ... 
};

// 错误：编译报错，无法继承 final 修饰的类
class SubClass : public FinalClass 
{

}; 

#include <iostream>
using namespace std;


/*---------------------定义：“基类：Base类”---------------------*/
class Base
{
    friend class FriendClass;   //声明 FriendClass 为友元类，允许其访问 Base 的私有成员
private:
    int _baseData = 10; // 基类私有成员
};


/*---------------------定义：“派生类：Derived类”---------------------*/
class Derived : public Base
{
private:
    int _derivedData = 20; // 派生类新增私有成员
};


/*---------------------定义：“友元类：FriendClass类”---------------------*/
class FriendClass
{
public:
    
    void access(Base& b)
    {
        cout << "访问Base::_baseData: " << b._baseData << endl; //可访问 Base 对象的私有成员 _baseData
    }

    void access(Derived& d)
    {
        cout << "访问Derived::_baseData (inherited): " << d._baseData << endl; //可访问 Derived 对象中从 Base 继承的私有成员 _baseData
        
        cout << "访问Derived::_derivedData: " << d._derivedData << endl;  //但无法访问 Derived 自身新增的私有成员 _derivedData
        // 错误：FriendClass 不是 Derived 的友元，无法访问 _derivedData
    }
};

int main()
{
    //1.创建：“基类 + 派生类 + 基类的友元类”的对象
    Base b;
    Derived d;
    FriendClass fc;

    //2.调用友元函数访问 Base 对象的私有成员
    fc.access(b);  

    //3.调用友元函数访问 Derived 对象的私有成员
    fc.access(d); // 只能访问从 Base 继承的部分，无法访问 Derived 自身新增的私有成员
    return 0;
}

#include <iostream>
using namespace std;


/*---------------------定义：“基类：Base类”---------------------*/
class Base
{
    friend void friendFunc(Base& b); //声明 friendFunc 为友元函数，允许其访问 Base 的私有成员

private:
    int _baseData = 10; // 基类私有成员
};


/*---------------------定义：“派生类：Derived类”---------------------*/
class Derived : public Base
{
private:
    int _derivedData = 20; // 派生类新增私有成员

    // friend void friendFunc(Derived& d); //注意：若不单独声明，friendFunc 无法访问 Derived 的私有成员
};


/*---------------------定义：“友元函数：friendFunc函数”---------------------*/

void friendFunc(Base& b)
{
    cout << "访问Base::_baseData: " << b._baseData << endl; //可访问 Base 对象的私有成员
}

// 测试函数：演示友元关系的非继承性
void test()
{
    //1.创建派生类的对象d
    Derived d;

    //2.调用友元函数
    // friendFunc(d); // 错误：friendFunc 不是 Derived 的友元，无法访问其私有成员

    friendFunc(static_cast<Base&>(d)); // 正确：可将 Derived 对象隐式转换为 Base&，但只能访问 Base 部分
    //注意：friendFunc 接受 Base& 参数，Derived 对象可隐式转换为 Base&
}

int main()
{
    //1.创建：“基类 + 派生类”的对象
    Base b;
    Derived d;

    //2.调用友元函数访问 Base 对象的私有成员（合法）
    friendFunc(b); 

    //3.调用测试函数，验证对 Derived 对象的访问限制
    test();
    return 0;
}

#include <iostream>
#include <string>
using namespace std;

// 前向声明
class Student;


/*---------------------定义：“基类：Person类”---------------------*/
class Person
{
public:
	friend void Display(const Person& p, const Student& s); // 声明 Display 为友元函数，允许访问 Person 的 protected 成员

protected:
	string _name;  // 姓名
};



/*---------------------定义：“派生类：Student类”---------------------*/
class Student : public Person
{
protected:
	int _num;  // 学号
};


/*---------------------定义：“友元函数：Display函数”---------------------*/

void Display(const Person& p, const Student& s)
{
	//1.访问 Person 的 protected 成员 _name
	cout << p._name << endl;

	//2.尝试访问 Student 的 protected 成员 _num（此处会触发编译错误）
	cout << s._num << endl;
}

int main()
{
	//1.创建：“基类 + 派生类”的对象
	Person p;
	Student s;

	//2.调用友元函数，触发访问权限检查
	Display(p, s);

	return 0;
}

#include <iostream>
using namespace std;


/*---------------------定义：“基类：Base类”---------------------*/
class Base
{
public:
	//1.声明基类的静态变量
	static int s_value;
};
//2.初始化基类的静态变量
int Base::s_value = 10;


/*---------------------定义：“派生类：Derived1类”---------------------*/
class Derived1 : public Base
{

};

/*---------------------定义：“派生类：Derived2类”---------------------*/
class Derived2 : public Base
{

};

int main()
{
	//1.输出“修改前”基类和派生类的静态变量s_value ---> 所有类共享同一静态变量
	cout << "输出“修改前”基类和派生类的静态变量s_value" << endl;
	cout << "Base::s_value=" << Base::s_value << endl;
	cout << "Derived1::s_value=" << Derived1::s_value << endl;
	cout << "Derived2::s_value=" << Derived2::s_value << endl << endl;

	//2.输出“修改后”基类和派生类的静态变量s_value ---> 修改静态变量会影响所有类
	cout << "输出“修改后”基类和派生类的静态变量s_value" << endl;
	Derived1::s_value = 20; //s_value 在内存中只有一份，无论通过基类还是派生类访问，操作的都是同一个变量。
	cout << "Base::s_value=" << Base::s_value << endl;
	cout << "Derived2::s_value=" << Derived2::s_value << endl;

	return 0;
}

#include <iostream>
#include <string>
using namespace std;

/*---------------------定义：“基类：Base类”---------------------*/
class Person
{
public:
    string _name;       //非静态成员变量的类内定义
    static int _count;  //静态成员变量的类内声明
};

//静态成员变量类外初始化
int Person::_count = 0;


/*---------------------定义：“派生类：Derived类”---------------------*/
class Student : public Person
{
protected:
    int _stuNum;
};

int main()
{
    /*-----------------创建对象-----------------*/

    //1.创建：“基类 + 派生类”的对象
    Person p;
    Student s;

    /*-----------------打印验证-----------------*/

    //1.验证非静态成员 _name：派生类对象和基类对象各有一份，地址不同
    cout << "验证非静态成员 _name" << endl;
    cout << &p._name << endl;
    cout << &s._name << endl << endl;

    //2.验证静态成员 _count：派生类和基类共用同一份，地址相同
    cout << "验证静态成员 _count" << endl;
    cout << &p._count << endl;
    cout << &s._count << endl << endl;


    /*-----------------类名访问-----------------*/

    //3.公有静态成员，基类和派生类通过类作用域访问
    cout << "通过类名访问静态成员变量 _count" << endl;
    cout << Person::_count << endl;
    cout << Student::_count << endl;

    return 0;
}

#include <iostream>
using namespace std;

/*---------------------定义：“基类：Base类”---------------------*/
class Base 
{
public:
    static void print() 
    {
        cout << "Base::staticPrint()" << endl;
    }
};

/*---------------------定义：“派生类：Derived类”---------------------*/
class Derived : public Base 
{

};

int main() 
{
    //1.直接通过类名调用静态函数
    Base::print();    
    Derived::print(); 

    //2.也可通过对象调用（但不推荐，易混淆）
    Derived d;
    d.print();      

    return 0;
}

/*-----------------------------语法-----------------------------*/
class 基类 
{
    // 基类成员
};

class 派生类 : 继承方式 基类 
{
    // 派生类新增成员
};


/*-----------------------------示例-----------------------------*/
class Person 
{ 
    /* ... */ 
};

class Student : public Person  // 单继承
{ 
    /* ... */ 
}; 

class Base
{
   	int _baseData;  // 基类成员
};

class Derived : public Base
{
   	int _derivedData;  // 派生类新增成员
};

Derived 对象内存：
+-------------------+
|   Base 部分        | 
|   _baseData       |  // 基类成员，先存储
+-------------------+
|   Derived 部分     |
|   _derivedData    |  // 派生类新增成员，后存储
+-------------------+

class Base
{
public:
	int publicData;
protected:
	int protectedData;
private:
	int privateData;
};

class Derived : public Base
{
public:
	void test()
	{
		publicData = 1;      // 允许：基类 public 成员
		protectedData = 2;  // 允许：基类 protected 成员
		// privateData = 3;  // 错误：基类 private 成员不可访问
	}
};

int main()
{
	Derived d;
	d.publicData = 10;      // 允许：public 成员可通过对象访问
	// d.protectedData = 20; // 错误：protected 成员不可通过对象访问
	return 0;
}

/*-----------------------------语法-----------------------------*/
class 基类1 
{ 
    /* ... */ 
};

class 基类2 
{ 
    /* ... */ 
};

class 派生类 : 继承方式1 基类1, 继承方式2 基类2 
{
    // 派生类新增成员
};




/*-----------------------------示例-----------------------------*/

class Student
{ 
    /* 基类1 */ 
};
class Teacher
{ 
    /* 基类2 */ 
};


class Assistant : public Student, public Teacher 
{ 
    /* 派生类 */ 
}

class Base1
{
   	int _data1;
};

class Base2
{
   	int _data2;
};



class Derived : public Base1, public Base2
{
   	int _derivedData;
};

Derived 对象内存：
+-------------------+
|   Base1 部分       | 
|   _data1          |  // 第一个基类，先存储
+-------------------+
|   Base2 部分       |
|   _data2          |  // 第二个基类，后存储
+-------------------+
|   Derived 部分     |
|   _derivedData    |  // 派生类新增成员
+-------------------+

/*-----------------------------语法-----------------------------*/

class Person
{ 
    /* 公共基类 */ 
};


class Student : public Person 
{ 
    /* 中间类1 */ 
};
class Teacher : public Person 
{ 
    /* 中间类2 */ 
};


class Assistant : public Student, public Teacher 
{ 
    /* 最终派生类 */ 
}

class Person
{
public:
 	string _name;
};


class Student : public Person
{
 	/* ... */
};
class Teacher : public Person
{
 	/* ... */
};


class Assistant : public Student, public Teacher
{
 	/* ... */
};

Assistant 对象内存：
+-------------------+
|   Student 部分     | 
|   Person::_name   |  // 第一份 _name
+-------------------+
|   Teacher 部分     |
|   Person::_name   |  // 第二份 _name
+-------------------+
|   Assistant 部分   |
+-------------------+

Assistant ta;
ta._name = "Alice"; 		 // 错误：哪份 _name？Student 的还是 Teacher 的？
ta.Student::_name = "Alice"; // 显式指定路径，可解决歧义

class Person
{
public:
	string _name;
};


class Student : public Person
{
	/* ... */
};
class Teacher : public Person
{
	/* ... */
};


class Assistant : public Student, public Teacher
{
	/* ... */
};


int main()
{
	Assistant ta;
	// 错误：编译器不知道访问 Student::_name 还是 Teacher::_name
	ta._name = "jack";

	return 0;
}

class Person
{
public:
   	string _name;
};


class Student : virtual public Person  // Student 虚继承 Person
{
   	/* ... */
};
class Teacher : virtual public Person  // Teacher 虚继承 Person
{
   	/* ... */
};


class Assistant : public Student, public Teacher // Assistant 继承 Student 和 Teacher
{
   	/* ... */
};

Assistant 对象内存：
+------------------------+
| Student 部分（含 vbptr） | 
+------------------------+
| Teacher 部分（含 vbptr） | 
+------------------------+
| Person 部分（_name）    |  // 仅一份
+------------------------+
| Assistant 新增成员      | 
+------------------------+

#include <iostream>
#include <string>  
using namespace std;

/*---------------------定义：“基类：Person类”---------------------*/
class Person
{
public:
    Person(const string& name) 
        : _name(name)
    {
        cout << "Person 构造函数，name = " << _name << endl;
    }
    string _name;  // 姓名
};

/*---------------------定义：“中间派生类：Student类”---------------------*/
class Student : virtual public Person
{
public:
    Student(const string& name) 
        : Person(name)
    {
        cout << "Student 构造函数" << endl;
    }
};

/*---------------------定义：“中间派生类：Teacher类”---------------------*/
class Teacher : virtual public Person
{
public:
    Teacher(const string& name) 
        : Person(name)
    {
        cout << "Teacher 构造函数" << endl;
    }
};


/*---------------------定义：“最终派生类：Assistant类”---------------------*/
class Assistant : public Student, public Teacher
{
public:
    Assistant(const string& name) 
        :Person(name)  
        ,Student(name)
        ,Teacher(name)
    {
        cout << "Assistant 构造函数" << endl;
    }

    /* 构造函数：
    *  
    *    1.显式初始化虚基类 Person（这是必要的，否则会调用 Person 的默认构造函数）
    *    2.调用 Student 和 Teacher 的构造函数（但它们对 Person 的初始化会被忽略）
    */
};

int main()
{
    cout << "=== 创建助教对象 ===" << endl;
    Assistant assistant("张三");

    /* 创建 Assistant 对象时的构造顺序：
    *  
    *     1.虚基类 Person（由 Assistant 直接初始化）
    *     2.非虚基类 Student（其对 Person 的初始化被忽略）
    *     3.非虚基类 Teacher（其对 Person 的初始化被忽略）
    *     4.Assistant 自身
    */
    cout << "\n=== 访问姓名信息 ===" << endl;
    cout << "姓名: " << assistant._name << endl;     // 由于虚继承，_name 仅存在一份实例，无需指定作用域，直接访问

    cout << "学生姓名: " << assistant.Student::_name << endl;
    cout << "教师姓名: " << assistant.Teacher::_name << endl; // 以上两种方式通过作用域限定符访问，但实际上指向同一内存位置

    cout << "\n=== 程序结束 ===" << endl;
    return 0;
}

#include <iostream>
#include <string>  
using namespace std;

/*---------------------定义：“公共基类：Person类”---------------------*/
class Person 
{
public:
    //1.实现：“构造函数”---> 用 C 风格字符串初始化姓名
    Person(const char* name)
        : _name(name)   // 初始化列表初始化成员 _name
    {
        cout << "Person 构造函数调用，姓名：" << _name << endl;
    }

    string _name;  // 姓名
};




/*---------------------定义：“中间派生类：Student类”---------------------*/
class Student : virtual public Person 
{
public:
    //1.实现：“构造函数”---> 初始化 Person 基类、学号
    Student(const char* name, int num)
        : Person(name)  // 调用 Person 构造函数初始化从公共基类继承的部分
        , _num(num)     // 初始化学号成员
    {
        cout << "Student 构造函数调用，学号：" << _num << endl;
    }

protected:
    int _num;  // 学号
};

/*---------------------定义：“中间派生类：Teacher类”---------------------*/
class Teacher : virtual public Person 
{
public:
    //1.实现：“构造函数”---> 初始化 Person 基类、职工编号
    Teacher(const char* name, int id)
        : Person(name)  // 调用 Person 构造函数初始化公共基类部分
        , _id(id)       // 初始化职工编号成员
    {
        cout << "Teacher 构造函数调用，职工编号：" << _id << endl;
    }

protected:
    int _id;  // 职工编号
};

/*---------------------定义：“最终派生类：Assistant类”---------------------*/
class Assistant : public Student, public Teacher 
{
public:
    //1.实现：“构造函数”---> 需显式初始化公共基类 Person，再初始化 Student、Teacher
    Assistant(const char* name1, const char* name2, const char* name3)
        : Person(name3)       // 直接初始化公共基类 Person，这是虚继承的关键要求
        , Student(name1, 1)   // 调用 Student 构造函数，学号固定传 1（示例逻辑）
        , Teacher(name2, 2)   // 调用 Teacher 构造函数，职工编号固定传 2（示例逻辑）
    {
        cout << "Assistant 构造函数调用" << endl;
    }

protected:
    string _majorCourse;  // 主修课程
};

int main() 
{
    cout << "----------创建 Assistant 对象:----------" << endl;
    Assistant a("张三", "李四", "王五");

    cout << "----------打印Assistant 对象中 Person 部分的姓名:----------" << endl;
    cout << a._name << endl;  
    //注意：由于虚继承，Person 的 _name 由 Assistant 构造函数中 Person(name3) 决定
    //所以 _name 的值是 "王五"

    return 0;
}

//basic_ostream 类模板：表示基本输出流
template<class CharT, class Traits = std::char_traits<CharT>>
class basic_ostream : virtual public std::basic_ios<CharT, Traits>
{

};


//basic_istream 类模板：表示基本输入流
template<class CharT, class Traits = std::char_traits<CharT>>
class basic_istream : virtual public std::basic_ios<CharT, Traits>
{

};


/* 注意事项：
*		1.CharT 表示字符类型（如：char、wchar_t 等）
*		2.Traits 表示字符特性，默认使用标准库的 char_traits，用于提供字符相关的基本操作（如：比较、复制等）
*
*  作用：
*		1.虚继承自 basic_ios<CharT, Traits>，目的是在多重继承场景下（如：basic_iostream）避免基类 basic_ios 的成员重复
*		2.同样虚继承自 basic_ios<CharT, Traits>，和 basic_ostream 配合解决多重继承时的基类成员冗余问题
*/

#include <iostream>  
using namespace std; 

class Base1 
{
public:
    int _b1;
};

class Base2 
{
public:
    int _b2;
};


class Derive : public Base1, public Base2 
{
public:
    int _d;
};


int main()
{
    // 创建 Derive 类的对象 d，该对象包含 Base1、Base2 以及自身的成员
    Derive d;

    // 定义 Base1 类型指针 p1，指向 Derive 对象 d 中从 Base1 继承的部分
    // 因为 Derive 公有继承 Base1，所以可以安全地将 Derive 对象指针转换为 Base1 指针
    Base1* p1 = &d;

    // 定义 Base2 类型指针 p2，指向 Derive 对象 d 中从 Base2 继承的部分
    // 同理，Derive 公有继承 Base2，可转换为 Base2 指针
    Base2* p2 = &d;

    // 定义 Derive 类型指针 p3，直接指向 Derive 对象 d 的起始地址
    Derive* p3 = &d;

    return 0;
}

Derive 对象 d 的内存：
+-------------------+
|  Base1 部分        |  // 包含 _b1
+-------------------+
|  Base2 部分        |  // 包含 _b2
+-------------------+
|  Derive 自身 _d    |
+-------------------+

class Base
{
	/* 基类成员 */
};

class Derived : public Base
{
	/* 派生类成员，可复用 Base 的成员 */
};

class Component
{
	/* 组件类成员 */
};


class Host
{
	Component comp; // 组合 Component 对象
};

// 以下演示 stack 与 vector 的两种关系（实际标准库中 stack 通常用组合，这里对比说明）
template<class T>
class vector 
{
   
};

// 错误示范：stack 公有继承 vector，强行让 stack "是一个" vector（is-a）
// 但 stack 语义上更适合 "有一个" vector（has-a），此写法会暴露 vector 所有接口，不符合栈的设计
template<class T>
class stack : public vector<T> 
{
  
};

// 正确示范：stack 组合 vector，体现 has-a 关系（stack "有一个" vector 作为底层容器）
template<class T>
class stack 
{
public:
    vector<T> _v;  // 组合 vector 对象，stack 通过 _v 实现底层存储
};

#include <iostream> 
#include <string>    
#include <vector>   
using namespace std; 

/*---------------------定义：“基类：Tire类”---------------------*/
class Tire   //注：后续会被 Car 组合，体现 （has-a 关系）
{
protected:
    string _brand = "Michelin";  // 轮胎品牌，默认米其林
    size_t _size = 17;           // 轮胎尺寸，默认 17 寸
};

/*---------------------定义：“基类：Car类”---------------------*/
class Car   //注：后续被 BMW、Benz 继承，体现（is-a 关系）
{
protected:
    string _colour = "白色";  // 车颜色，默认白色
    string _num = "京00001";  // 车牌号，默认京00001
    Tire _t1;  // 第一个轮胎 ---> 组合轮胎对象，体现 Car "有一个" Tire（has-a 关系）
    Tire _t2;  // 第二个轮胎
    Tire _t3;  // 第三个轮胎
    Tire _t4;  // 第四个轮胎
};

/*---------------------定义：“派生类：BMW类”---------------------*/
class BMW : public Car  //注：公有继承 Car 类，体现 is-a 关系（BMW "是一个" Car）
{
public:
    void Drive() 
    {
        cout << "好开-操控" << endl;  // BMW 车型的驾驶体验描述
    }
};


/*---------------------定义：“派生类：Benz类”---------------------*/
class Benz : public Car  //注：公有继承 Car 类，体现 is-a 关系（Benz "是一个" Car）
{
public:
    void Drive() 
    {
        cout << "好坐-舒适" << endl;  // Benz 车型的驾驶体验描述
    }
};


int main() 
{
    BMW bmwCar;
    bmwCar.Drive();  // 调用 BMW 的 Drive 方法

    return 0;
}