C++继承

最新推荐文章于 2024-07-04 14:48:12 发布
最新推荐文章于 2024-07-04 14:48:12 发布
阅读量165 收藏
点赞数
分类专栏： C++ 文章标签： c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Loo_Loo_Loo_su/article/details/117248180
版权

继承

概念：是类与类之间的一张关系。如果类A继承于类B，则把类B称为基类（父类），类A称为派生类（子类）。继承需要符合is-a的关系，基类更通用更抽象，派生类更特殊更具体。

继承目的

①提高代码的重要性，因为派生类会拥有基类的所有特性，所以当写派生的时候就没有必要把基类相同功能的代码再写一遍。
②提高代码的可拓展性。派生类可以在基类上添加新的代码，而且一个基类可以出现多个派生类。
简单的继承
公有继承的子类声明：
class 派生类名： public 基类名
{
//成员的声明
}；

  1. vi Animal.h
#ifndef _ANIMAL_H
#define  _ANIMAL_H

class Animal
{
public:
	void breath();
	
};
#endif
  1. vi Animal.h
#include"Animal.h"
#include <iostream>
using namespace std;

void Animal::breath()
{
	cout<<"Animal  Breath"<<endl;
}
  1. vi main.h
#include"Animal.h"
#include"Predator.h"

int main(int argc,char **argv)
{
	Predator Predator;
	Predator.breath();//调用基类的函数
	Predator.eatMeat();//调用本身的函数
	return 0;
}
  1. vi Predator.h
#ifndef _PREDATOR_H
#define _PREDATOR_H
#include"Animal.h"

class Predator:public Animal//公有继承的子类声明
{
public:
	void eatMeat();
};

#endif
  1. vi Predator.cpp
#include"Predator.h"
#include <iostream>
using namespace std;

void Predator::eatMeat()
{
	cout<<"Predator eat Meat"<<endl;
}

运行结果
在这里插入图片描述

对象的构造和析构过程

任何对象在创建后都会调用构造函数，在销毁之前都会调用析构函数。
因为派生类对象除了本身成员之外还拥有基类的成员，所以派生类对象在创建时会调用父类的构造函数，销毁时会调用父类的析构函数。

派生类的构造函数

在定义派生类的构造函数是需要知道父类的构造函数，如果不能指定则会调用父类的无参结构函数。
派生类构造函数定义：
派生类名::派生类名（参照列表）
：基类名（基类构造函数参数列表），派生类成员（参数）…
{
}

  1. vi Person.h Person.cpp
#ifndef _PERSON_H
#define _PERSON_H

class Person
{
private:
	int weight
	int hinght
public:
	int getWeight()const;
	int getHeight()const;

	Person();//无参构造函数
	Person(int weight,int height);//有参构造函数
};

#endif

Person.cpp

#include"Person.h"
#include<iostream>
using namespace std;

int Person::getWeight()const
{
	return weight;
}

int  Person::getHeight()const
{
	return height;
}

Person:: Person()
{
	cout<<" Person:: Person();"<<endl;
}

Person:: Person(int weight,int height)
		weight(weight),height(height)
{
	cout<<" Person:: Person(int weight,int height);"<<endl;
}
  1. . vi Student.h Student.cpp
#ifndef _STUDENT_H
#define _STUDENT_H

#include"Person.h"
class Student:public Person//person是父类，student是子类
{
private:
	int id;
public:
	int getId()const;
};
#endif

Student.cpp

#include"Student.h"

int Student::getId()const
{
	return id;
}
  1. vi main.cpp
#include "Student.h"
#include"Person.h"
#include <iostream>
using namespace std;

int main(int arg,char **argv)
{
 	cout<<"Person: "<<sizeof(Person)<<endl;
 	cout<<"Student: "<<sizeof(Student)<<endl;
 	return 0;
}

运行结果
在这里插入图片描述
在main函数中添加Student stu；就会发现他会调用基类的无参结构函数
main.cpp

#include "Student.h"
#include"Person.h"
#include <iostream>
using namespace std;

int main(int arg,char **argv)
{
 	//cout<<"Person: "<<sizeof(Person)<<endl;
 	//cout<<"Student: "<<sizeof(Student)<<endl;
 	Student stu;
 	return 0;
}

运行结果
在这里插入图片描述
如果要指定调用构造函数，就需要在自己手动写出有参构造函数，如在Student.h公有成员中加入有参构造函数Student（int id，int weight ，int height）
Student.h

#ifndef _STUDENT_H
#define _STUDENT_H

#include"Person.h"
class Student:public Person//person是父类，student是子类
{
private:
	int id;
public:
	Student(int id , int weighet, int height);//有参构造函数
	int getId()const;
};
#endif

Student.cpp

#include"Student.h"

int Student::getId()const
{
	return id;
}

Student::Student(int id,int weight,int height)//有参构造函数
	:Person(weight,height),id(id)//声明
{
	cout<<"Student::Student(int,int,int)"<<endl;
}

main.cpp

#include "Student.h"
#include"Person.h"
#include <iostream>
using namespace std;

int main(int arg,char **argv)
{
 	//cout<<"Person: "<<sizeof(Person)<<endl;
 	//cout<<"Student: "<<sizeof(Student)<<endl;
 	//Student stu();
 	Student stu(1,70,170);//（）里面就要写入参数了
 	return 0;
}

运行结果：这样就调用了父类的构造函数和子类的构造函数
在这里插入图片描述

访问控制符

private：只有能在当前类成员函数中能够访问。
protected：只有在当前类成员函数和子类成员函数中能够访问。
public：既能在当前类成员函数，子类成员函数中访问，也能通过当前类对象，子类对象访问。

  1. vi Object.h Object.cpp
#ifndef _OBJECT_H
#define _OBJECT_H

class Base
{
private:
	int i;
protected:
	int j;
public:
	int k;

	Base(int i,int j, int k);//基类对象
	void testBase();//基类函数
};

class Child:public Base
{
public:
	Child(int i,int j,int k);//子类对象
	void testChid();子类函数
};

#endif

Object.cpp

#include"Object.h"

Base::Base(int i,int j,int k)
	:i(i),j(j),k(k)
{

}

Child::Child(int i,int j,int k)
	:Base(i,j,k)
{

}

void Child::testChild()//子类可以访问保护和公有成员
{
	//i++;私有成员不能访问
	j++;
	k++;
}

void Base::testBase()//基类都能访问
{
	i++;
	j++;
	k++;
}
  1. vi main.cpp
#include"Object.h"

int main(int argc,char **argv)
{
	Base base(1,2,3);//基类对象，对象只能访问公开成员
	//base.i++;私有成员不能访问
	//base.j++;保护成员不能访问
	base.k++;
	Child child(1,2,3);//派生类对象
	//child.i++;
	//child.j++;
	child.k++;
	
	return 0;
}

受保护继承和私有继承

在C++中最常见的是公有继承，除了公有继承外，还有受保护继承和私有继承。
在受保护继承中，派生类从基类继承下来的私有成员会隐藏，所有非私有成员都会变成受保护成员。
在私有继承中，派生类从基类继承下来的私有成员会隐藏，所有非私有成员都会变成私有成员。
受保护继承的派生类声明和公有继承类似：
class 派生类名：protected 基类名
{
//成员
}；

受保护继承的派生类声明和公有继承类似：**
class 派生类名：private 基类名
{
//成员
}；
① 受保护的：vi Object.h Object.cpp main.cpp

#ifndef _OBJECT_H
#define _OBJECT_H

class Base
{
private:
	int i;
protected:
	int j;
public:
	int k;

	Base(int i,int j, int k);//基类对象
	void testBase();//基类函数
};

class Child:protected Base//受保护的基类
{
public:
	Child(int i,int j,int k);//子类对象
	void testChid();子类函数
};

#endif

Object.cpp

#include"Object.h"

Base::Base(int i,int j,int k)
	:i(i),j(j),k(k)
{

}

Child::Child(int i,int j,int k)
	:Base(i,j,k)
{

}

void Child::testChild()//子类可以访问保护和公有成员
{
	//i++;子类私有成员不能访问
	j++;//变成受保护
	k++;//变成受保护的
}

void Base::testBase()//基类都能访问
{
	i++;
	j++;
	k++;
}

main.cpp

#include"Object.h"

int main(int argc,char **argv)
{
	Base base(1,2,3);//基类对象，对象只能访问公开成员
	//base.i++;私有成员不能访问
	//base.j++;保护成员不能访问
	base.k++;
	Child child(1,2,3);//派生类对象
	//child.i++;
	//child.j++;
	child.k++;
	
	return 0;
}

②私有的vi Object.h Object.cpp main.cpp

#ifndef _OBJECT_H
#define _OBJECT_H

class Base
{
private:
	int i;
protected:
	int j;
public:
	int k;

	Base(int i,int j, int k);//基类对象
	void testBase();//基类函数
};

class Child:private Base//私有的基类
{
public:
	Child(int i,int j,int k);//子类对象
	void testChid();子类函数
};

#endif

Object.cpp

#include"Object.h"

Base::Base(int i,int j,int k)
	:i(i),j(j),k(k)
{

}

Child::Child(int i,int j,int k)
	:Base(i,j,k)
{

}

void Child::testChild()//子类可以访问保护和公有成员
{
	//i++;子类私有成员不能访问
	j++;//变成受保护
	k++;//变成受保护的
}

void Base::testBase()//基类都能访问
{
	i++;
	j++;
	k++;
}

main.cpp

#include"Object.h"

int main(int argc,char **argv)
{
	Base base(1,2,3);//基类对象，对象只能访问公开成员
	//base.i++;私有成员不能访问
	//base.j++;保护成员不能访问
	base.k++;
	Child child(1,2,3);//派生类对象
	//child.i++;
	//child.j++;
	child.k++;
	
	return 0;
}

注意：虽然私有和受保护用法一样，但是还是有区别的。当为私有时，child里面的j、k是变成私有的；当为受保护时，child里面的j、k是变成受保护的。

多重继承

在C++中，一个派生类可以继承自多个基类。
如下：
class 派生类：public基类A，public基类B,…
{
//成员
}

  1. vi Animal.h Animal.cpp main.cpp
#ifndef _ANIMAL_H
#define _ANIMAL_H

class Bear
{
public:
	void bearIntroduce();
};

class Raccon
{
public:
	void racconIntroduce();
};

class Panda:public Bear,public  Recccon//熊猫有熊和浣熊的特性
{}
public:
	void pandaIntroduce();
};

Animal.cpp

#include" Animal.h"
#include <iostream>
using namespace std;

void Bear::bearIntroduce()
{
	cout<<"I'm bear"<<endl;
}

void Raccoon::raccoonIntroduce()
{
	cout<<"I'm  raccoon"<<endl;
}

void Panda::pandaIntroduce()
{
	cout<<"I'm  panda"<<endl;
	Bear::bearIntroduce();//调用基类Bear成员
	Raccoon::raccoonIntroduce();
}

main.cpp

#include" Animal.h"

int main(int argc,char **argv)
{
	Panda panda;
	Panda.PandaIntroduce();//I'm  panda   I'm bear    I'm  raccoon

	Panda.bearIntroduce();//I'm bear 
	Panda.raccoonIntroduce();//I'm  raccoon
	return 0;
}

运行结果
在这里插入图片描述

虚拟继承

概念：是多重继承中特有的概念，是为了解决多重继承出现的菱形继承。
比如：熊猫继承类熊、浣熊，而熊和浣熊都继承动物为，那么熊猫就会两次出现在动物中成员。为了节省内存，可以将熊、浣熊对动物的继承定义为虚拟继承，这样在熊和浣熊出现的继承体系中只会出现一份动物实例。
虚拟继承的语法：
class 派生类：virtual public基类
{
//成员
}；
注意：public和virtual的位置可以互换。

  1. vi vi Animal.h Animal.cpp main.cpp
    Animal.h
#ifndef _ANIMAL_H
#define _ANIMAL_H

class Animal
{
private:
	int weight;
	int age;
public:
	Animal(int weight,int age);
};

class Bear:public Animal
{
public:
	void bearIntroduce();
	Bear(int weight,int age);
};

class Raccoon:public Animal
{
public:
	void raccoonIntroduce();
	Raccoon(int weight,int age);
};

class Panda:public Animal
{
public:
	void PandaIntroduce();
	Panda(int weight,int age);
};
#endif
  1. Animal.cpp
#include" Animal.h"
#include <iostream>
using namespace std;

void Bear::bearIntroduce()
{
	cout<<"I'm bear"<<endl;
}

void Raccoon::raccoonIntroduce()
{
	cout<<"I'm  raccoon"<<endl;
}

void Panda::pandaIntroduce()
{
	cout<<"I'm  panda"<<endl;
	Bear::bearIntroduce();//调用基类Bear成员
	Raccoon::raccoonIntroduce();
}

//构造函数
Animal::Animal(int weight,int age)
	:weight(weight),age(age)
{
	
}

Bear::Bear(int weight,int age)
	:Animal(weight,age)
{

}

Raccoon::Raccoon(int weight,int age)
	:Animal(weight,age)
{

}

Panda::Panda(int weight,int age)
	：Bear(weight,age),Raccoon(weight,age)
{

}
  1. main.cpp
#include"Animal.h"
#include <iostream>
using namespace std;

int main(int arg,char **argv)
{
 	cout<<"Animal: "<<sizeof(Animal)<<endl;
 	cout<<"Bear: "<<sizeof(Bear)<<endl;
 	cout<<"Raccoon: "<<sizeof(Raccoon)<<endl;
 	cout<<"Panda: "<<sizeof(Panda)<<endl;
 	Panda panda(50,5);
 	panda pandaIntroduce();
 	
	return 0;
}

运行结果
在这里插入图片描述
从结果中我们可以看出Bear和Raccoon 继承了Animal的字节大小；Panda是继承了Bear和Raccoon它们两个字节的大小。这样就会造成资源浪费，所以我们要在Bear和Raccoon 的函数中加个virtual，并且Panda中之前调用Bear和Raccoon 后面补充Animal调用。

Animal.h

#ifndef _ANIMAL_H
#define _ANIMAL_H

class Animal
{
private:
	int weight;
	int age;
public:
	Animal(int weight,int age);
};

class Bear:virtual public Animal//虚拟继承
{
public:
	void bearIntroduce();
	Bear(int weight,int age);
};

class Raccoon:virtual public Animal
{
public:
	void raccoonIntroduce();
	Raccoon(int weight,int age);
};

class Panda:public Animal
{
public:
	void PandaIntroduce();
	Panda(int weight,int age);
};
#endif

Animal.cpp

#include" Animal.h"
#include <iostream>
using namespace std;

void Bear::bearIntroduce()
{
	cout<<"I'm bear"<<endl;
}

void Raccoon::raccoonIntroduce()
{
	cout<<"I'm  raccoon"<<endl;
}

void Panda::pandaIntroduce()
{
	cout<<"I'm  panda"<<endl;
	Bear::bearIntroduce();//调用基类Bear成员
	Raccoon::raccoonIntroduce();
}

//构造函数
Animal::Animal(int weight,int age)
	:weight(weight),age(age)
{
	
}

Bear::Bear(int weight,int age)
	:Animal(weight,age)
{

}

Raccoon::Raccoon(int weight,int age)
	:Animal(weight,age)
{

}

Panda::Panda(int weight,int age)
	：Animal(weight,age)//还要调用Animal构造函数（虚拟继承时）
	：Bear(weight,age),Raccoon(weight,age)	
{

}

运行结果
在这里插入图片描述
因为加了virtual所以占了4字节，所以Bear和Raccoon才有8变成了12，Panda的字节因为有了virtual才没有把Bear和Raccoon两个字节相加，而是在12字节上加了4字节，并不是之前的8+8形成的

LU_LU_ZHU
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
C/C++ 避免重复定义
weixin_43869778的博客
07-12 1430
加入宏定义: 第一种： #ifndef _STUDENT_H #define _STUDENT_H // student.h 中的内容置于此 struct ListNode{ int val; ListNode* next; ListNode(int x) ： val(x), next(NULL) {} }; #endif 第二种， 在起始行加入： #pragma once 这种方法可移植性较差（编译器可能不支持），并且也不够灵活，因为其只能作用于整个.h文件夹。 ...
c++ 自定数据类型
BLOG OF PETERMAOSX.
08-07 116
先写一个头文件 这里是使用了结构体来构建一个Student类型 // // Student.h // algorithm // // Created by Mao on 2019/8/7. // Copyright © 2019 Mao. All rights reserved. // #ifndef Student_h #define Student_h #endif /* Stud...
C++——继承（超详细）
最新发布
sqm_C的博客
07-04 1376
看了上面的案例，我们大概知道了继承的概念，那么我们接下来就来看看继承的定义：下面我们看到Person是父类，也称作基类。Student是子类，也称作派生类。由上图，我们发现继承方式好像跟访问限定符一样也是三种，那是不是就有九种情况呢？那我们如何分辨呢?总结：1. 基类private成员在派生类中无论以什么方式继承都是不可见的。这里的不可见是指基类的私有成员还是被继承到了派生类对象中，但是语法上限制派生类对象不管在类里面还是类外面都不能去访问它。
一个使用C++编写的简单示例，实现对学生成绩的管理
m0_74288622的博客
05-02 332
在Student类的构造函数中，我们可以选择使用默认姓名为空，分数为0，也可以使用传入的参数进行初始化。在getName()函数中，我们直接返回m_name的值。在getScore()函数中，我们直接返回m_score的值。在Student类中，我们声明了构造函数、获取姓名、设置姓名、获取分数和设置分数的成员函数，其中m_name和m_score是私有成员变量，用于存储学生的姓名和分数。在main()函数中，我们创建一个vector容器用于存储所有学生的信息。
C语言实现学生管理系统 增删改查
从hello到kernel
06-27 3622
学生管理系统主要用于学校学生信息管理，总体任务是实现学生信息关系的系统化、科学化、规范化和智能化，其主要功能是利用计算机对学生的各种信息，如：姓名、学号、成绩等，进行日常管理，如查询、修改、增加、删除等。
@图灵不吃苹果 #C++ 学生类设计
我怎么这么菜啊7
09-20 571
@图灵不吃苹果 C++学生类的设计（带注释） 实验要求 设计一个图形基类：Shape，在此基础上派生Rectangle、Circle、Triangle 类。 设计一个 Studnet(学生)类 1、基本信息：学号、姓名、性别、出生日期、年级、班级、院系、专业；其中：基本信息为 private 属性，成员函数为public 属性； 2、Student 类有多个构造函数：缺省构造函数、带参数的构造函数、带默认参数的构造函数 3、基本功能： 1）使用对象数组保存学生对象； 2）可以从键盘输入学生的基本信息； 3）
C++继承介绍
09-05
总结来说，C++继承是实现代码复用和创建类层次结构的重要手段。通过选择适当的继承类型、访问修饰符和虚函数，开发者可以构建灵活且强大的类体系，同时确保类型安全和多态性。理解和熟练运用这些概念对于编写高效、...
c++继承分类
04-28
C++继承是面向对象编程（OOP）中的一个核心概念，它允许我们创建新的类，这些新类可以扩展已存在的类的功能。在这个“c++继承分类”主题中，我们将深入探讨C++中的继承机制，以及如何在Qt环境中利用这一特性进行开发...
C++ 继承详解及实例代码
12-31
C++继承可以是单一继承或多重继承，每一个继承连接可以是public,protected,private也可以是virtual或non-virtual。然后是各个成员函数选项可以是virtual或non-virtual或pure virtual。本文仅仅作出一些关键点的验证...
c++继承的视频
04-28
C++继承是面向对象编程（OOP）中的一个核心概念，它允许一个类（子类或派生类）从另一个类（基类或父类）继承特性，从而实现代码的重用和扩展。在Qt框架中，C++的继承机制同样被广泛应用，以构建丰富的用户界面和...
c++继承描述
01-05
c++继承描述
实例代码讲解c++ 继承特性
12-17
以下是对C++继承特性的详细解释： 1. **派生类构造函数**：派生类需要定义自己的构造函数来初始化新增加的数据成员。在派生类构造函数中，通常需要调用基类的构造函数来初始化继承过来的成员。这可以通过成员初始化...
C++继承与多态性实验报告
03-01
### C++继承与多态性实验报告知识点解析 #### 实验背景及目的 本实验旨在通过实际操作加深学生对C++面向对象编程的理解，特别是针对继承与多态性的概念进行深入学习。实验要求学生能够利用C++语言特性，设计并实现...
C++ 继承机制易犯的错误
01-21
继承作为面向对象的基本特征之一，其使用率极高。不管是为了实现软件的基本功能，还是再程序的重构的过程中，我们总是会用到继承机制。正是因为其用途极为广泛，而且使用简单，大众程序员对其真正的内部实现机制的...
c++：继承（超详解）
热门推荐
qq_62718027的博客
07-22 7万+
目录一：什么是继承二：继承的格式继承的总结：二：子类和父类（基类和派生类）1.子类和父类的相互赋值：2.同名的成员变量3.同名成员函数三：子类中默认的成员函数1.构造函数2.析构函数3.拷贝构造4.赋值运算符重载 四：单继承和多继承单继承： 多继承：菱形继承解决方法一：解决方法二：单继承和多继承的总结：定义：继承(inheritance)机制是面向对象程序设计中使代码可以复用的最重要的手段，它允许程序员在保持原有类特性的基础上进行扩展，增加功能。这样产生的新类，称派生类（或子类），被继承的类称基类（或父类）
【C++继承中的相关内容】
weixin_43730061的博客
06-05 492
主要内容： 1.继承的概念及定义 2.基类和派生类对象赋值转换 3.继承中的作用域 4.派生类的默认成员函数 5.继承与友元 6.继承与静态成员 7.复杂的菱形继承及菱形虚拟继承 8.继承的总计和反思 9.继承中常见的面试题 1.继承的概念及定义 1.1 继承的概念 继承机制是面向对象程序设计使代码可以复用的重要的手段，它允许程序员在保持原有类特性的基础上进行扩展，增加功能，这样产生新的类，称派生...
C++继承[万字详解]
weixin_47257473的博客
03-16 3774
本文非常详细介绍了C++中的继承，包括继承的定义，介绍，方式。以及继承后派生类构造函数和析构函数的调用顺序，继承中的切片等问题，继承后静态成员，友元关系的变化，以及多继承中的菱形继承和菱形虚拟继承，对继承的一些总结。继承和组合的介绍以及关系.
C++继承与派生详解
"继承与派生是C++中面向对象编程的重要概念，它允许我们创建新的类（派生类）基于已存在的类（基类），以实现代码的重用和扩展。继承使得派生类能够继承基类的属性和方法，同时可以添加新的特性或者覆盖原有的行为。...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值