• C++有关继承

    目录

    1、继承的概念与定义

    2、继承方式和继承访问权限

    总结

    有关protected继承和private继承的区别:

     3、编写派生类的注意事项

    3、1有关继承关系中数据成员的内存分布，可见性，调用顺序

    有关调用顺序:

     4、讨论赋值兼容规则

    5、继承与静态成员

    6、1隐藏和重载

    6、继承与友元

    7、菱形继承

    1、继承的概念与定义

    C++通过类派生的机制来支持继承。被继承的类称为基类或超类，新产生的类称为派生类或者子类。基类和派生类的集合被称作类继承层次结构。

    由基类派生出，派生类的设计形式为：

    1. class 派生类名: 访问限定符 基类名
    2. {
    3.     private:
    4.             成员表1;//派生类增加或替代的私有成员
    5.     public:
    6.             成员表2;//派生类增加或替代的公有成员
    7.     protected:
    8.             成员表3;//派生类增加或替代的保护成员
    9.  
    10. };

    注意:派生反映了事物之间的联系，事物的共性与个性之间的关系。派生与独立设计若干相关的类，前者工作量少，重复的部分可从基类继承，不需要单独编程。继承是类型设计层面的复用。

    2、继承方式和继承访问权限

    有三种类型的访问限定符：

    • public：任意位置
    • protected：本类和子类
    • private：本类

    私有（private）成员：私有成员变量或者函数在类的外部是不可访问的，只有本类中或者友元函数可以访问。定义一个类时，如果不显示地给成员加访问修饰符，类的所有成员都是私有的。

    保护（protected）成员：保护成员变量或者函数和私有成员十分相似，不同的是保护成员在其派生类（子类）中是可以访问的。

    也就是说私有private比protected的保护性更强。

    类中成员变量可以使用这三种访问限定符修饰，继承方式也有这三种方式，我们逐一来讨论：基类中不同的访问限定符的成员以不同的继承方式继承后在派生类中的访问限定为：

    示例:

    1. #include
    2.  
    3. using namespace std;
    4.  
    5. class A {
    6. public:
    7. 	int m_i;
    8. protected:
    9. 	int m_j;
    10. private:
    11. 	int m_k;
    12. 	static int m_m;
    13. };
    14. //public继承在本类的成员函数中，可以访问基类的公有和保护
    15. //外部方法可以访问本类公有，不能访问保护和私有
    16. class B :public A
    17. {
    18. public:
    19. 	void fun()
    20. 	{
    21. 		m_i = 10;
    22. 		m_j = 20;
    23. 		//m_k = 30;//error 能继承，不能访问
    24. 	}
    25. };
    26. //protected继承
    27. class C :protected A
    28. {
    29. public:
    30. 	void test()
    31. 	{
    32. 		m_i = 10;
    33. 		m_j = 20;
    34. 		//m_k = 30;//error 能继承，不能访问
    35. 	}
    36. };
    37. class D :private A
    38. {
    39. public:
    40. 	void test1()
    41. 	{
    42. 		m_i = 10;
    43. 		m_j = 20;
    44. 		//m_k = 30;//error 能继承，不能访问
    45. 	}
    46. };
    47. int main()
    48. {
    49. 	B b;
    50. 	b.fun();
    51. 	b.m_i = 10;
    52. //	b.m_j = 20; 外部不能访问类中保护成员
    53. 	//b.m_k = 30;不能私有成员访问
    54.  
    55. 	C c;
    56. 	c.test();
    57. 	//都不能在外部访问，保护继承
    58. 	// 就把A公有的继承为了保护，保护的继承为了保护，私有还是私有
    59. 	//c.m_i = 10;
    60. 	//c.m_j = 20;
    61. 	//c.m_k = 30;
    62.  
    63. 	D d;
    64. 	//都不能在外部访问，私有继承
    65. 	// 把A里面成员变量函数都变成私有的
    66. 	//D.test1();
    67. 	//d.m_i = 10;
    68. 	//d.m_j = 20;
    69. 	//d.m_k = 30;
    70. }

    【1. 以public方式继承】

    • 类成员m_i以public修饰：m_i可以在任意位置被访问，对于派生类是public。
    • 类成员m_j以protected修饰：m_j可以在其子类中访问，对于派生类是protected
    • 类成员m_k以private修饰：m_k只能在本类中访问即A中，不能在派生类访问，所以是不可访问的。

    【2. 以protected方式继承】

    • 类成员m_i以public修饰：m_i不能在类外访问，但可以在派生的子类访问，对于派生类是protected
    • 类成员m_j以protected修饰：m_j可以其子类中访问，对于派生类是protected。
    • 私有成员ma以private修饰：m_k只能在本类中访问即A中 ，不能在派生类访问，所以是不可访问的。

    【3. 以private方式继承】

    • 类成员m_i以public修饰：可以在派生类中访问，所以对于派生类是私有的private。
    • 类成员m_j以protected修饰：private私有的.
    • 类成员m_k以private修饰：m_k只能在本类中访问即A中，不能在派生类访问，所以是不可访问的。

    • 总结

      对于这三种方式继承的 派生类 来说: 都能访问基类的public, protected 成员;

      public 的方式继承到派生类，这些成员的权限和在基类里的权限保持一致;

      protected方式继承到派生类，成员的权限都变为protected;

      private 方式继承到派生类，成员的权限都变为private;

    继承方式\基类成员访问呢权限publicprotectedprivate
    publicpublicprotected不可访问
    protectedprotectedprotected不可访问
    privateprivateprivate不可访问

    有关protected继承和private继承的区别:

     区别在于多继承之后的访问权限

    给上述代码例子多继承一次就会发现:

     3、编写派生类的注意事项

     

     注意:

            构造函数和析构函数不能被继承。基类的构造和析构满足的工作要求不可能完全适应派生类，因此需要重写构造，析构。

            其他函数都可以通过类对象来调用，创建对象时由系统调用该对象所属类的构造函数，该对象生存期也只调用这一次。由继承而来的派生类对象，是能够调用父类函数，但不能调用构造函数以及析构函数。

    3、1有关继承关系中数据成员的内存分布，可见性，调用顺序

    在派生类中，基类的内存布局优先于派生类。

    1. class Object
    2. {
    3. private: int oa;
    4. protected: int ob;
    5. public:  int oc;
    6.  
    7. };
    8. class Base:public Object
    9. {
    10. private: int bx;
    11. protected: int by;
    12. public:  int bz;
    13. };
    14. int main()
    15. {
    16. 	Object obj;
    17. 	Base base;
    18. 	return 0;
    19. }

    •  不论采取何种继承方式，基类中所有数据成员都会继承到派生类
    • 在类型的继承层次结构中，保护属性当做公有属性来使用
    • 继承性具有传递性
    • 不论采取何种继承方式，派生类对象的成员方法都可以去访问基类对成员对象中的保护和公有属性

    有关调用顺序:

    1. class A
    2. {
    3. public:A(int i = 0) { cout << "A" << i << endl; }
    4. };
    5. class B
    6. {
    7. public:B(int i = 0) { cout << "B" << i << endl; }
    8. };
    9. class C
    10. {
    11. public:C(int i = 0) { cout << "C" << i << endl; }
    12. };
    13. class D :public B, public A
    14. {
    15. public:
    16. 	D(int i = 0, int j = 0, int k = 0) :A(i), B(j), c(k), m_m(10)
    17. 	{
    18. 		cout << "D" << m_m << endl;
    19. 	}
    20. private:
    21. 	C c;
    22. 	int m_m;
    23. };
    24. void main()
    25. {
    26. 	D d(1, 2, 3);
    27. }

    调用顺序:

            1.按照继承顺序调用构造 
            2.按照组合顺序调用构造
            3.调用本类自己的构造

     

     4、讨论赋值兼容规则

    1. 派生类的对象可以赋值给基类对象，这时是把派生类对象中从对应基类中继承来的隐藏对象赋值给基类对象。反过来不行，因为派生类的新成员没有值可以赋。
    2. 可以将一个派生类的对象的地址赋给其基类指针变量，但是只能通过这个指针访问派生类中由基类继承来的隐藏对象，不能访问派生类中的新成员。同样反过来也不行。
    3. 派生类对象可以初始化基类引用。引用是别名，但这个别名只能包含派生类对象中的由基类继承来的隐藏对象。
    1. class Object
    2. {
    3. private: 
    4. 	int value;
    5. public: 
    6. 	Object(int x = 0):value(x){}
    7. 	~Object(){}
    8. 	void Print(int x)
    9. 	{
    10. 		value = x;
    11. 		cout << value << endl;
    12. 	}
    13.  
    14. };
    15. class Base :public Object
    16. {
    17. private:
    18. 	int num;
    19.  
    20. public:  
    21. 	Base(int x=0):Object(x),num(x+10){}
    22. };
    23. int main()
    24. {
    25. 	Object obja(0);
    26. 	Base base(10);
    27. 	Object* op = &base;
    28. 	Object& ob = base;
    29. 	obja = base;
    30.    // base = obja;//error 父类对象不能给子对象赋值
    31. 	return 0;
    32. }

     几个例题:

    1. //不能被继承的类
    2. //final 表示当前类终止了
    3. class A final
    4. {
    5. private:
    6. 	A() {}
    7. };
    8. class B :public A
    9. {
    10.  
    11. };
    12. int main()
    13. {
    14. 	//B b;
    15. }
    16.  
    17.  
    18. //能被继承，不能在外界定义对象的类
    19. class A
    20. {
    21. protected:
    22. 	A() { cout << "A" << endl; }
    23. };
    24. class B :public A
    25. {
    26. public:
    27. 	B() { cout << "B" << endl; }
    28. };
    29. void main()
    30. {
    31. 	//A a;  //外部不能定义a类对象
    32. 	B b;
    33. }
    34.  
    35.  
    36. //设计一个类，只能生成一个实例
    37. class A
    38. {
    39. private:
    40. 	A() { cout << "A" << endl; }
    41. public:
    42. 	A(const A& a) = delete;
    43. 	A& operator=(const A& a) = delete;
    44. 	static A&& GetA()
    45. 	{
    46. 		cout << "Get(a)" << endl;
    47. 		return A();
    48. 	}
    49. 	void Print() { cout << "Print" << endl; }
    50. };
    51. void main()
    52. {
    53. 	//A a, b, c, d;
    54. 	A::GetA().Print();
    55. 	//A a = A::GetA();
    56. }

    实现子类的拷贝，析构，赋值，编写继承关系

    1. //如果有指针了作为数据成员 析构，深拷贝，深赋值必须要写
    2. class Person {
    3. public:
    4. 	Person(){}
    5. 	Person(const char* name, char sex, int age) :m_sex(sex), m_age(age)
    6. 	{
    7. 		cout << "Person name sex age" << endl;
    8. 		m_name = new char[strlen(name) + 1];
    9. 		strcpy(m_name, name);
    10.  
    11. 	}
    12. 	Person(const Person& p)
    13. 	{
    14. 		m_name = new char[strlen(p.m_name) + 1];
    15. 		strcpy(m_name, p.m_name);
    16. 		m_age = p.m_age;
    17. 		m_sex = p.m_sex;
    18. 	}
    19. 	~Person()
    20. 	{
    21. 		cout << "Person析构" << endl;
    22. 		if (m_name == nullptr)
    23. 		{
    24. 			delete[]m_name;
    25. 			m_name = nullptr;
    26. 		}
    27. 	}
    28. 	Person& operator = (const Person& p)
    29. 	{
    30. 		if (this != &p)
    31. 		{
    32. 			delete[] m_name;
    33. 			m_name = new char[strlen(p.m_name) + 1];
    34. 			strcpy(m_name, p.m_name);
    35. 			m_sex = p.m_sex;
    36. 			m_age = p.m_age;
    37. 		}
    38. 		return *this;
    39. 	}
    40. 	void Show()
    41. 	{
    42. 		cout << "name : " << m_name << endl;
    43. 		cout << "sex : " << m_sex << endl;
    44. 		cout << "age : " << m_age << endl;
    45. 	}
    46. private:
    47.     char* m_name;
    48. 	char m_sex;
    49. 	int m_age;
    50. };
    51. class Student : public Person
    52. {
    53. public:
    54. 	Student(){}
    55. 	Student( const char*name, const char sex, int age, const char* num, float sorce): Person(name, sex, age)
    56. 	{
    57. 		m_num = new char[strlen(num)+1];
    58. 		strcpy_s(m_num,strlen(num)+1, num);
    59. 		m_sorce = sorce;
    60. 		cout << "Student" << endl;
    61. 	}
    62. 	Student(const Student& s) :Person(s)
    63. 	{
    64. 		m_num = new char[strlen(s.m_num) + 1];
    65. 		strcpy(m_num, s.m_num);
    66. 		m_sorce = s.m_sorce;
    67. 	}
    68. 	~Student()
    69. 	{
    70. 		cout << "Student析构" << endl;
    71. 		if (m_num == nullptr)
    72. 		{
    73. 			delete[]m_num;
    74. 			m_num = nullptr;
    75. 		}
    76. 	}
    77. 	Student& operator=(const Student& s)
    78. 	{
    79. 		if (this != &s)
    80. 		{
    81. 			Person::operator = (s);//指定作用域调用父类的赋值运算符重载
    82. 			delete[] m_num;
    83. 			m_num = new char[strlen(s.m_num) + 1];
    84. 			strcpy(m_num, s.m_num);
    85. 			m_sorce = s.m_sorce;
    86. 		}
    87. 		return *this;
    88. 	}
    89. 	void Print()
    90. 	{
    91. 		Show();
    92. 		cout << "num : " << m_num << endl;
    93. 		cout << "score :" << m_sorce << endl;
    94. 	}
    95. private:
    96. 	char* m_num;
    97. 	float m_sorce;
    98. };
    99. int main()
    100. {
    101. 	//Person p;
    102. 	Student s("张三", 'm', 20, "1001", 80);
    103. 	s.Print();
    104. 	cout << "SS info :" << endl;
    105. 	Student ss = s;  //用s对象去构造ss对象，调用拷贝构造
    106. 	ss.Print();
    107.  
    108. 	cout << "dd info : " << endl;
    109. 	Student dd;
    110. 	dd = s; //用s去给dd赋值，需要调用赋值运算符重载
    111. 	dd.Print();
    112. 	cout << "main end " << endl;
    113. 	return 0;
    114. }

    5、继承与静态成员

    继承与静态成员，静态成员只有一个，所有对象共享（包括基类对象和派生类对象）

    1. class Shape
    2. {
    3. public:
    4. 	Shape() {}
    5. 	void Print() { cout << "num = " << m_num << endl; }
    6. 	//private:
    7. 	static int m_num;
    8. };
    9. int Shape::m_num = 0;
    10. class Circle :public Shape
    11. {
    12. public:
    13. 	Circle() { cout << "C num = " << ++m_num << endl; }
    14. };
    15. class Rectangle : public Shape
    16. {
    17. public:
    18. 	Rectangle() { cout << "R num = " << ++m_num << endl; }
    19. };
    20. class Triangle : public Shape
    21. {
    22. public:
    23. 	Triangle() { cout << "T num = " << ++m_num << endl; }
    24. };
    25. void main()
    26. {
    27. 	Shape s;
    28. 	Circle c1, c2;
    29. 	s.Print();
    30. 	Rectangle r1, r2;
    31. 	s.Print();
    32. 	Triangle t1, t2;
    33.  
    34. 	s.Print();
    35. }

    6、1隐藏和重载

    示例一：

    子类中定义了和基类同名的static属性
    如果子类中定义了和基类同名的static属性，则有两份静态区域，各自维护，基类的被隐藏
     如果在子类中想访问基类的，则需要显示访问

    1. class A
    2. {
    3. public:
    4. 	A() { cout << "A:" << ++m_i << endl; }
    5. 	void Print() { cout << "A : m_i:" << m_i << endl; }
    6. protected:
    7. 	static int m_i;
    8. };
    9. int A::m_i = 10;
    10. class B :public A
    11. {
    12. public:
    13. 	B()
    14. 	{
    15. 		A::m_i++;
    16. 		cout << "B : " << ++m_i << endl;
    17. 	}
    18. 	void Show() { cout << "B : m_i:" << m_i << endl; }
    19. private:
    20. 	static int m_i;
    21. };
    22. int B::m_i = 20;
    23. void main()
    24. {
    25. 	A a;
    26. 	a.Print();  //11
    27. 	B b;
    28. 	a.Print(); //13
    29. 	b.Show();  //21
    30. }

    示例二：

    1. class A
    2. {
    3. public:
    4. 	A(int i = 0) :m_i(i) {}
    5. 	virtual void fn() { cout << "A : fn" << endl; }
    6. private:
    7. 	int m_i;
    8. };
    9. class B :public A
    10. {
    11. public:
    12. 	B(int i = 0, int j = 0) :m_j(j), A(i) {}
    13. 	//定义了一个和基类同名的函数，则将基类的fn函数隐藏
    14. 	//1隐藏，如果是非virtual，则同名同参或者不同参
    15. 	void fn()
    16. 	{
    17. 		A::fn();
    18. 		cout << "B:fn" << endl;
    19. 	}
    20. 	//virtual void fn();
    21. 	//隐藏2 如果是virtual，则一定不能同参
    22. 	/*void fn(int n)
    23. 	{
    24. 		A::fn();
    25. 		cout << "B : fn(int)" << endl;
    26. 	}*/
    27. private:
    28. 	int m_j;
    29. };
    30. void main()
    31. {
    32. 	//	cout << sizeof(B) << endl;
    33. 	B b;
    34. 	//b.fn(10);
    35. 	b.fn(); //从A继承过来的fn函数被隐藏了
    36. }

     示例三：

    1. class A
    2. {
    3. public:
    4. 	A(int i = 0) :m_i(i) {}
    5. 	virtual void fn() { cout << "A : fn" << endl; }
    6. private:
    7. 	int m_i;
    8. };
    9. class B :public A
    10. {
    11. public:
    12. 	B(int i = 0, int j = 0) :m_j(j), A(i) {}
    13. 	//定义了一个和基类同名的函数，则将基类的fn函数隐藏
    14. 	//1隐藏，如果是非virtual，则同名同参或者不同参
    15. 	/*void fn()
    16. 	{
    17. 		A::fn();
    18. 		cout << "B:fn" << endl;
    19. 	}*/
    20. 	//virtual void fn();
    21. 	//隐藏2 如果是virtual，则一定不能同参
    22. 	void fn(int n)
    23. 	{
    24. 		A::fn();
    25. 		cout << "B : fn(int)" << endl;
    26. 	}
    27. private:
    28. 	int m_j;
    29. };
    30. void main()
    31. {
    32. 	//	cout << sizeof(B) << endl;
    33. 	B b;
    34. 	b.fn(10);
    35. 	//b.fn(); //从A继承过来的fn函数被隐藏了
    36. }

    总结:

            重载:

    • 1.同一个类
    • 2.同名函数
    • 3.参数列表不同
    • 4.和返回值无关，但是和const有关
    • void fn(){}
    • void fn()const{}

            隐藏：

    • 1.父子关系两个类
    • 2.如果是非virtual，则同名同参或者不同参都可以
    • 3.如果是virtual，则一定不能同参,否则会被隐藏

    6、继承与友元

    友元不具有继承性

    7、菱形继承

    菱形问题:

            一个派生类有两个或以上的基类，这些基类中存在相同的基类即(B继承A ;C继承A ;D继承B和C) 当派生类想要直接调用A类中的方法时，产生二义性，出错。    

          这里的二义性是由于他们间接都有相同的基类导致的，除了带来二义性外，还会浪费空间(每个派生类中都会带有一份基类的内存)

    而为了解决菱形继承问题：让A变为一份，B，C，D可以共享，那么可以将其放在D作用域的md的下面

    • B,C类中使用指针指向对应A内存块即可，给这个指针起个名字叫vbptr，虚基类指针。
    • 内存布局在编译阶段确定，那么可以利用偏移量让vbptr指向A内存块，即vbptr指向的内存块中存放A内存的相对偏移（相对自己位置的偏移）。

     这就是虚继承，可以用来解决菱形继承出现重复间接基类的问题

    虚继承的实现: 

    class 派生类名：virtual 访问限定符 基类类名{...}

    class 派生类名：访问限定符 virtual 基类类名{...}

    virtual 关键字只对紧随其后的基类名起作用

    1. class B :virtual public A //A称为虚基类
    2.  
    3. class C :public virtual A //A称为虚基类

    虚继承添加位置：

    可能出现数据重复的直接继承关系，如A重复出现，那么B，C虚继承A。

    虚继承的内存布局

    • 将虚基类放在当前作用域最下面。如菱形继承，第二个虚基类A可以直接不要，那么此时A属于D了，需要在D中对其进行构造。
    • 出现虚基类的位置放一个虚基类指针vfptr，它指向虚基类表vftable：包含（1）虚基类指针相对于当前作用域的偏移（2）虚基类指针相对于虚基类数据的偏移

    示例:从下面沙发类和床品类中抽象出共性，写出一个新类，家具类

    1. class Furniture//家具
    2. {
    3. public:
    4. 	Furniture() { cout << "1" << endl; }
    5. 	void Sit() { cout << "sit" << endl; }
    6. private:
    7. 	int m_size;
    8. };
    9. // vptr(虚指针，占内存，同指针),m_size ---->8
    10. class Sofa : virtual public Furniture
    11. {
    12. public:
    13. 	Sofa() { cout << "2" << endl; }
    14. };
    15. //vptr，m_size ---->8
    16. class Bed : virtual public Furniture
    17. {
    18. public:
    19. 	Bed() { cout << "3" << endl; }
    20. };
    21. //vptr（Sofa）,vptr(Bed),m_size ---->12
    22. class SofaBed :public Sofa, public Bed
    23. {
    24. public:
    25. 	SofaBed() { cout << "4" << endl; }
    26. };
    27. int main()
    28. {
    29.  
    30. 	SofaBed sb;
    31. 	sb.Sit();
    32.     return 0;
    33. 	//	cout << sizeof(sb) << endl;
    34. 	//	cout << sizeof(Sofa) << endl;
    35. 	//	cout << sizeof(Bed) << endl;
    36. 	//	sb.Sofa::Sit();
    37. 	//	sb.Bed::Sit();
    38. }

    • 在没有加virtual之前，重复构造家具 ，结果为 sofa(1 2) -> bed( 1 3)  ->4 
    • 结果1  2  1  3  4 
    • 加了virtual后 构造家具(属性构造了一份)，构造沙发，构造床的时候发现床也是从家具继承过来
    • 此时就不再构造家具，接着构造床，最后构造沙发床，保证了家具的属性只有一份拷贝
    • 结果 1 2 3 4

    日常打卡巩固，知识分享

  • 相关阅读:
    一篇文章学会调优 ClickHouse
    edge浏览器被恶意插件劫持，不能删除由组织安装的扩展，提示您的浏览器由您的组织管理
    数字化医院信息云平台源代码 HIS系统全套成品源代码
    【Proteus仿真】【STM32单片机】水箱液位监控系统
    PyQt5 基本教程大全
    综述、浏览器外观（Actions、右键菜单、桌面通知）
    [Java]Java SPI机制
    机器视觉中的工业光源选择技巧
    mysql分组concat() concat_ws() group_concat()
    安卓的ATV系统
  • 原文地址：https://blog.csdn.net/weixin_51609435/article/details/126021827