【C++】继承

最新推荐文章于 2024-05-31 14:42:05 发布
最新推荐文章于 2024-05-31 14:42:05 发布
阅读量31 收藏
点赞数
分类专栏： 及格家の C++养成录 文章标签： c++ python 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/waluolandao/article/details/133146428
版权

        继承是面向对象的程序使代码可以复用的重要手段，它允许程序员在保持原有类特性的基础上进行扩展、增加功能。被继承的原有类称为基类（或父类），继承基类而产生的新的类，称为派生类（或子类）。类似于函数的复用，继承是类的复用。

class Person
{
public:
	void Print()
	{
		cout << "name:" << _name << endl;
		cout << "age:" << _age << endl;
	}
	//protected:
private:
	string _name = "peter"; // 姓名
	int _age = 18;          // 年龄
};

// 继承后，父类的Person的成员都会变成子类的一部分。
//这里Student和Teacher复用了Person的成员
class Student : public Person
{
public:
	void func()
	{
		// 父类私有成员，子类用不了(无论什么方式继承)
		//cout << "name:" << _name << endl;
		//cout << "age:" << _age << endl;
	}
protected:
	int _stuid; // 学号
};

class Teacher : public Person
{
protected:
	int _jobid; // 工号
};
int main()
{
	Student s;
	Teacher t;
	s.Print();
	t.Print();

	return 0;
}

        本篇博客总结了继承的相关用法，旨在解读继承的常见问题和背后的思想。

目录

一、继承的定义

二、基类和派生类对象的赋值转换

三、继承中的作用域

四、派生类的默认成员函数

五、其他细节

（一） 继承与友元

（二） 继承与静态成员

（三）菱形继承和菱形虚拟继承 *

（四） 继承与组合 *

补、相关面试题

一、继承的定义

        继承定义的语法格式为：

派生类 + 指定的继承方式 + 基类

 

        其中，继承方式与访问限定符有关。

【Tips】

  1. 基类private成员在派生类中无论以什么方式继承都是不可见的。这里的不可见是指基类的私有成员虽然是被继承到了派生类对象中，但语法上限制了派生类对象不管在类里面还是类外面都不能去访问它；
  2. 基类private成员在派生类中是不能被访问，如果基类成员不想在类外直接被访问，但需要在派生类中能访问，就定义为protected（其实保护成员限定符是因继承而出现的）；
  3. 基类除私有成员的其他成员在子类的访问方式：public > protected > private；
  4. 使用关键字class时默认的继承方式是private，使用struct时默认的继承方式是public，不过，最好显示的写出继承方式；
  5. 在实际运用中一般使用都是public继承，几乎很少使用protetced/private继承，也不提倡 使用protetced/private继承，因为protetced/private继承下来的成员都只能在派生类的类里面使用，实际中扩展维护性不强。

 

二、基类和派生类对象的赋值转换

【Tips】

  1. 派生类对象可以赋值给基类的对象 / 基类的指针 / 基类的引用（这里有个形象的说法叫切片或者切割，寓意把派生类中父类那部分切来赋值过去）；
  2. 基类的对象不能赋值给派生类对象（这是因为父未必有子的全部成员）；
  3. 但基类的指针或者引用可以通过强制类型转换赋值给派生类的指针或者引用（注意，必基类的指针必须是指向派生类对象，否则有安全隐患。基类如果是多态类型，可以使用RTTI(RunTime Type Information)的dynamic_cast来进行识别后进行安全转换）。
class Person
{
protected :
    string _name; // 姓名
    string _sex;  // 性别
    int _age;     // 年龄
};

class Student : public Person
{
public :
     int _No ; // 学号
};

void Test ()
{
     Student sobj ;

     // 1.派生类对象可以赋值给基类对象/指针/引用
     Person pobj = sobj ;
     Person* pp = &sobj;
     Person& rp = sobj;
    
     //2.基类对象不能赋值给派生类对象
    //sobj = pobj;
    
    // 3.基类的指针可以通过强制类型转换赋值给派生类的指针
    pp = &sobj
    Student* ps1 = (Student*)pp; // 这种情况转换是可以的
    ps1->_No = 10;
    
    pp = &pobj;
    Student* ps2 = (Student*)pp; // 这种情况转换时虽然可以，但是会存在越界访问的问题
    ps2->_No = 10;
}
class Person
{
protected :
    string _name; // 姓名
    string _sex;  // 性别
    int _age;     // 年龄
};

class Student : public Person
{
public :
     int _No ; // 学号
};

int main()
{
	int i = 0;
	double d = i;//强制类型转换

	Person p;
	Student s;
	p = s;//也存在类似强转的赋值兼容转换（切割、切片），不会产生临时变量
	//一个子类对象相当于一个特殊的父类对象
	//将子类的全部变量切割后，部分赋给父类
	//s=p;//但父不能赋给子，这是因为父未必有子的全部成员

}
class Person
{
protected :
    string _name; // 姓名
    string _sex;  // 性别
    int _age;     // 年龄
};

class Student : public Person
{
public :
     int _No ; // 学号
};

//证明切片存在：
int main()
{
	int i = 0;
	//double& d = i;     //不可用，存在具有常性的临时变量，涉及权限放大
	const double& d = i; //可用，权限平移

	Student s;
	Person p = s;   //无须添加const
	Person& rp = s; //无须添加const

	//故没有临时变量产生，非强制类型转换
	
}
//向上转换（子赋给父）是可用的
//子类对象可转换为父类的对象、引用、指针

三、继承中的作用域

【Tips】

  1. 在一个继承体系中，基类和派生类都有独立的作用域；
  2. 子类和父类中有同名成员，子类成员将屏蔽父类对同名成员的直接访问，这种情况叫隐藏或重定义（在子类成员函数中，可以使用 基类::基类成员 显示访问）；
  3. 对于构成成员函数的隐藏，只需要函数名相同就构成隐藏；
  4. 在实际中在继承体系里面最好不要定义同名的成员。
class Person
{
public:
	void fun()
	{
		cout << "Person::func()" << endl;
	}

protected:
	string _name = "小林";   // 姓名
	int _num = 111; 	    // 身份证号
};

// 隐藏/重定义：子类和父类有同名成员，子类的成员隐藏了父类的成员
class Student : public Person
{
public:
	void fun()
	{
		cout << "Student::func()" << endl;
	}

	void Print()
	{
		cout << " 姓名:" << _name << endl;
		cout << _num << endl;
		cout << Person::_num << endl;
	}
protected:
	int _num = 999; // 学号。与父类的身份证号重名了
};

int main()
{
	Student s;
	s.Print();//999，
    //就近原则：局部域 > 成员 > 继承的父类 > 全局域，
    //编译器只要在一个地方找到了目标就不会再前往下个地方
	
    s.fun();
	s.Person::fun();
     //Q：两个fun构成什么关系？
     //    a、隐藏/重定义   b、重载   c、重写/覆盖  d、编译报错
     //A：a  (父子类域中，成员函数名相同就构成隐藏)

	return 0;
}

四、派生类的默认成员函数

【Tips】

  1. 派生类的构造函数必须调用基类的构造函数初始化派生类中基类的那一部分成员。如果基类没有默认的构造函数，就必须在派生类的构造函数的初始化列表阶段显示调用。
  2. 派生类的拷贝构造函数必须调用基类的拷贝构造完成基类成员的拷贝初始化；
  3. 派生类的operator=必须要调用基类的operator=完成基类的复制；
  4. 派生类的析构函数会在被调用完成后，自动调用基类的析构函数清理其中的基类成员（这样才能保证派生类对象先清理派生类成员再清理基类成员的顺序）；
  5. 派生类对象初始化先调用基类构造再调派生类构造；
  6. 派生类对象析构清理先调用派生类析构再调基类的析构。
  7. 因为在一些场景下，析构函数需要构成重写（重写的条件之一是函数名相同），编译器会对析构函数名进行特殊处理，处理成destrutor()，所以父类析构函数不加virtual的情况下（多态），子类析构函数会和父类析构函数构成隐藏关系。 
class Person
{
public:
	Person(const char* name)
		:_name(name)
	{
		cout << "Person()" << endl;
	}
	Person(const Person& p)
		:_name(p._name)
	{
		cout << "Person(const Person& p" << endl;
	}
	~Person()
	{
		cout << "~Person()" << endl;
		delete _pstr;
	}

	Person& operator=(const Person& p)
	{
		cout << "Person& operator=(const Person& p)" << endl;
		if (this != &p)
		{
			_name = p._name;
		}
		return *this;
	}
protected:
	string _name;
	string* _pstr = new string("111111");
};


class Student : public Person
{
public:
	//调用构造的顺序：先父后子
	Student(const char* name="zhangsan",int id=0)
		:Person(name)
		,_id(0)
	{}
	Student(const Student& s)
		:Person(s)//显示地调用拷贝构造
		,_id(s._id)
	{}
	~Student()
	{
		//Person::~Person();//显示调用无法保证先子后父
		// 由于后面多态的原因，析构函数的函数名被
		// 特殊处理了，统一处理成destructor
		// 显示调用父类析构，无法保证先子后父
		// 所以子类析构函数完成就自动调用父类析构，这样就保证了先子后父的析构顺序
		
		cout << *_pstr << endl;
		delete _pstr;
	}


	Student& operator=(const const Student& s)
	{
		if (this != &s)
		{
			Person::operator=(s);
			_id = s._id;
		}
		return *this;
	}
protected:
	int _id;
};

int main()
{
	Student s1;
	Student s2(s1);

	Student s3("lisi", 1);
	s1 = s3;
}

 

五、其他细节

（一） 继承与友元

        友元关系不能继承，也就是说，基类友元不能访问子类私有和保护成员


class Person
{
public:
     friend void Display(const Person& p, const Student& s);
protected:
     string _name; // 姓名
};
class Student : public Person
{
    protected:
    int _stuNum; // 学号
};

void Display(const Person& p, const Student& s)
{
     cout << p._name << endl;
     cout << s._stuNum << endl;
}

void main()
{
     Person p;
     Student s;
     //Display(p, s); //基类友元不能访问子类私有和保护成员
}

 

（二） 继承与静态成员

        如果基类中定义了一个static静态成员，那么整个继承体系里面只有一个这样的成员，无论派生出多少个子类，都只有一个static成员实例。

class Person
{
public :
     Person () {++ _count ;} //每调用构造一次， _count自增1
protected :
     string _name ; // 姓名
public :
     static int _count; // 统计人的个数。
};

int Person :: _count = 0;

class Student : public Person
{
protected :
     int _stuNum ; // 学号
};

class Graduate : public Student
{
protected :
     string _seminarCourse ; // 研究科目
};

int main()
{
	Person p;
	Student s;
	Graduate g;

	cout << Person::_count << endl; //3

	cout << &p._name << endl; //000000D06E16F4D8
	cout << &s._name << endl; //000000D06E16F518

	cout << &p._count<< endl;  //00007FF708CA2440
	cout << &s._count << endl; //00007FF708CA2440

	cout << &Person::_count << endl;  //00007FF708CA2440
	cout << &Student::_count << endl; //00007FF708CA2440

	return 0;
}

 

（三）菱形继承和菱形虚拟继承 *

        菱形继承是多继承的一种特殊情况。菱形继承有数据冗余和二义性的问题。如下图中，在Assistant的对象中Person成员会有两份。

class Person
{
public :
     string _name ; // 姓名
};

class Student : public Person
{
protected :
     int _num ; //学号
};

class Teacher : public Person
{
protected :
     int _id ; // 职工编号
};

class Assistant : public Student, public Teacher
{
protected :
     string _majorCourse ; // 主修课程
};

int main()
{
     // 这样会有二义性无法明确知道访问的是哪一个    
     Assistant a ;
     a._name = "peter"; 

     // 需要显示指定访问哪个父类的成员可以解决二义性问题，但是数据冗余问题无法解决
     a.Student::_name = "xxx";
     a.Teacher::_name = "yyy";
}

        实践当中可以用多继承，但务必不用菱形继承。数据冗余和二义性可以通过虚继承来解决，如上面的继承关系，在Student和Teacher的继承Person时使用虚拟继承，即可解决问题。但需要注意的是，虚拟继承不要在其他地方去使用。

class Person
{
public :
     string _name ; // 姓名
};

class Student : virtual public Person
{
protected :
     int _num ; //学号
};

class Teacher : virtual public Person
{
protected :
     int _id ; // 职工编号
};

class Assistant : public Student, public Teacher
{
protected :
     string _majorCourse ; // 主修课程
};

int main()
{
     Assistant a ;
     a._name = "peter";
}

 

        虚继承相比普通继承，解决了数据冗余（虽然并不意味着空间一定被节省了）。拿菱形继承来说，普通继承在每次继承后都会将父类拷贝一份跟子类存在一起，而虚继承将多个继承的子类和一个父类存在同一个空间中，通过偏移量（存在虚基表中）来定位相应的数据。

class A
{
public:
	int _a;
};

class B : virtual public A
{
public:
	int _b;
};

class C : virtual public A
{
public:
	int _c;
};

class D : public B, public C
{
public:
	int _d;
};

int main()
{
	D d;
	d.B::_a = 1;
	d.C::_a = 2;
	d._b = 3;
	d._c = 4;
	d._d = 5;
	d._a = 0;

	D d1;

	return 0;
}

 

class A
{
public:
	int _a;
};

class B : virtual public A
{
public:
	int _b;
};

class C : virtual public A
{
public:
	int _c;
};

class D : public B, public C
{
public:
	int _d;
};

int main()
{
	D d;
	d._a = 1;

	B b;
	b._a = 2;
	b._b = 3;

	B* ptr = &b;
	ptr->_a++;

	ptr = &d;
	ptr->_a++;

	return 0;
}

 

        多继承可以算是C++语法复杂的一个体现。有了多继承，就存在菱形继承，有了菱形继承就有菱形虚拟继承，相关的底层实现相当复杂。所以，一般不建议使用多继承，且一定不要使用菱形继承，否则在复杂度及性能上都有问题。 多继承也可以认为是C++的缺陷之一，很多后来的OO（如Java语言）都没有多继承。

（四） 继承与组合 *

class C
{
	//....
};

// 继承
class D : public C
{};

// 组合
class E
{
private:
	C _cc;
};

        继承是白箱（内部细节可见）复用，组合是黑箱（内部细节不可见）复用，继承与父类的耦合度相比组合来说更高，父类的内部变化可能直接影响继承子类，但这对组合的影响很小。组合类之间没有很强的依赖关系，耦合度低。有助于保持每个类被封装，代码维护性更好。

        public继承是is-a的关系（例如，植物-花 人-学生...），组合是has-a的关系（例如，车-轮胎...）。它们没有优劣之分，各自有各自适配的情景。

   // Car和BMW Car和Benz构成is-a的关系

   class Car{
   protected:
       string _colour = "白色";   // 颜色
       string _num = "陕ABIT00";  // 车牌号
   };
   
   class BMW : public Car{
   public:
       void Drive() {cout << "好开-操控" << endl;}
   };
   
   class Benz : public Car{
   public:
       void Drive() {cout << "好坐-舒适" << endl;}
   };
   

   // Tire和Car构成has-a的关系
   
   class Tire{
   protected:
       string _brand = "Michelin";  // 品牌
       size_t _size = 17;           // 尺寸  
   };
   
   class Car{
   protected:
       string _colour = "白色";     // 颜色
       string _num = "陕ABIT00";    // 车牌号
       Tire _t;                     // 轮胎
   };

补、相关面试题

1、

2、什么是菱形继承？菱形继承的问题是什么？

3、什么是菱形虚拟继承？它是如何解决数据冗余和二义性的？

4、继承和组合的区别？什么时候用继承？什么时候用组合？

CV工程师小林
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C++继承介绍
09-05
C++继承可以是单一继承或多重继承，每一个继承连接可以是public,protected,private也可以是virtual或non-virtual
详解c++ 继承
08-18
主要介绍了c++ 继承的相关资料，文中讲解非常细致，代码帮助大家更好的理解和学习，感兴趣的朋友可以了解下
C++ 继承详解
热门推荐
TABE_的博客
02-21 1万+
C++ 继承继承语法继承方式改变访问权限名字遮蔽继承时的对象模型无变量遮蔽有变量遮蔽 继承语法 继承的一般语法为： class 派生类名:［继承方式］ 基类名{ 派生类新增加的成员 }; 继承方式 继承方式包括 public（公有的）、private（私有的）和 protected（受保护的），此项是可选的，如果不写，那么默认为 private。不同的继承方式会影响基类成员在派生类中的访问权限。 （1）public继承方式 基类中所有 public 成员在派生类中为 public 属性； 基类中
C++继承详解
DR5200的博客
10-14 2488
文章目录一.继承的概念和定义二.基类和派生类对象赋值转换三.继承中的作用域四.派生类的默认成员函数五.继承和友元六.继承与静态成员七.菱形继承及菱形虚拟继承八.C++编译器如何通过虚继承解决数据冗余和二义性 一.继承的概念和定义 继承(inheritance)机制是面向对象程序设计使代码可以复用的最重要的手段，它允许程序员在保持原有类特性的基础上进行扩展，增加功能，这样产生新的类，称派生类。继承呈现了面向对象程序设计的层次结构，体现了由简单到复杂的认知过程。以前我们接触的复用都是函数复用，继承是类设计层次的
C++继承
彧玊的博客
12-20 1769
C++继承相关的基础知识
C++ 继承
weixin_44212838的博客
07-23 1467
inheritance)机制是面向对象程序设计的最重要的手段，它允许程序员在保持原有类特性的基础上进行扩展，增加功能，这样产生新的类，称派生类。继承，体现了由简单到复杂的认知过程。以前我们接触的复用都是函数复用。.........
C++继承的使用
JayceSun的博客
04-17 1771
定义 继承(inheritance)机制是面向对象程序设计使代码可以复用的最重要的手段，它允许程序员在保持原有类特 性的基础上进行扩展，增加功能，这样产生新的类，称派生类。继承呈现了面向对象程序设计的层次结构， 体现了由简单到复杂的认知过程。以前我们接触的复用都是函数复用，继承是类设计层次的复用。 ...
C++继承[万字详解]
weixin_47257473的博客
03-16 3422
本文非常详细介绍了C++中的继承，包括继承的定义，介绍，方式。以及继承后派生类构造函数和析构函数的调用顺序，继承中的切片等问题，继承后静态成员，友元关系的变化，以及多继承中的菱形继承和菱形虚拟继承，对继承的一些总结。继承和组合的介绍以及关系.
C++继承方式
m0_50313114的博客
05-20 831
C++继承分为，公有(public)、保护(protected),私有(private)三种继承方式， 公有继承：基类共有成员（函数、属性）、保护成员在派生类中依旧为共有成员、保护成员；基类私有成员物理上在派生类中继承了，不过不能通过派生类对象（指针、引用）访问，只能通过基类中公有函数来间接访问基类私有成员。 保护继承：基类共有成员（函数、属性）、保护成员在派生类中均为在派生类中“”保护成员，私有成员在“派生类中不可见”，可通过基类共有函数间接访问。 私有继承：基类公有、保护、私有在派生类中均“不可见
c++ 继承构造函数
SWX230162的博客
10-11 4905
c++ 继承构造函数 class TestA { public: TestA(string i): a(i) {} ~TestA() {} string geta() { return a; } virtual string getb() = 0; private: string a; }; class TestB: public TestA{ public: TestB(string i):TestA(i),b(i) {}
c++继承
小陈的博客
04-19 4361
目录继承继承方式父类和子类对象赋值转换 继承 继承机制是面向对象程序设计使代码可以复用的最重要的手段，它允许程序员在保持原有类特性的基础上进行扩展，增加功能，这样产生新的类，称派生类。 继承不仅继承父类的成员变量，还继承父类的成员函数 继承是类设计层次的复用 简单来说，继承就是让子类使用父类的成员 class Person//父类 { public: void print() { cout << "name:" << _name << endl; cout
C++ 继承方式
gxt_kt的博客
01-19 1187
C++ 继承方式 文章目录C++ 继承方式一、了解继承方式首先需要了解类的权限：二、继承时权限的变化1.公共继承2.保护继承3.私有继承三、代码理解四、深入研究，加深理解五、全部代码（由于故意写出错误帮助理解，编译通不过） 继承方式： 1.公共继承。2.保护继承。3.私有继承 用法： class 子类 : 继承方式 父类{ 内容 } 一、了解继承方式首先需要了解类的权限： public:类内类外都能访问 protected/private:类内能访问，类外不能访问 二、继承时权限的变化 1.公共继承 p
C++ 继承详解及实例代码
12-31
C++继承可以是单一继承或多重继承，每一个继承连接可以是public,protected,private也可以是virtual或non-virtual。然后是各个成员函数选项可以是virtual或non-virtual或pure virtual。本文仅仅作出一些关键点的验证...
c++继承分类
04-28
在Qt中编写的c++继承分类的视频
C++中的智能指针类别
最新发布
GOLOJO的博客
05-31 894
C++中的智能指针是用来管理动态内存的对象，避免我们手动管理内存时可能会带来的复杂性和错误。C++标准库提供了几种不同类型的智能指针，包括``、``和`- 优先使用``和``来创建智能指针，避免手动使用`new`，可以提高代码的安全性和性能。- 在使用``时要特别小心循环引用的问题。可以使用``来打破循环引用。- 确保智能指针的生命周期管理正确，避免悬空指针和内存泄漏。- 虽然智能指针极大地简化了内存管理，但也带来了额外的开销，如引用计数的维护。因此，在性能敏感的代码中，应慎重使用`
C++：round函数用法
Solititude的博客
05-28 395
C++：round函数用法
精通C++ STL（二）：string类的模拟实现
Russ_Leo的博客
05-27 847
string类各函数接口。
C语言 指针——指针变量的定义、初始化及解引用
hangweijie的博客
05-29 1224
目录指针内存如何编址？如何对变量进行寻址？用什么类型的变量来存放变量的地址?如何显示变量的地址?​编辑使用未初始化的指针会怎样？NULL是什么？如何访问指针变量指向的存储单元中的数据？指针变量的定义和初始化
c++ 继承java类
01-12
C++可以继承Java类，但是需要注意一些细节和差异。在C++中，可以使用关键字`class`来定义一个类，并使用关键字`public`来指定继承关系。下面是一个示例： ```cpp class JavaClass { public: void javaMethod() { ...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值