C++之继承、派生

最新推荐文章于 2024-05-05 15:46:28 发布
最新推荐文章于 2024-05-05 15:46:28 发布
阅读量1k 收藏 7
点赞数 1
分类专栏： C++笔记 代码+运行结果 面向对象 文章标签： 数据结构 c++ 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_59052131/article/details/127928191
版权

目录

1.继承的概念与定义

2.层次概念是计算机的重要概念:

3.私有的能被继承，不能被访问

 4.继承的三步骤

1.继承语法

2.继承例子

5.有继承和组合的构造顺序---内存布局

6.继承之下的赋值运算符重载

1.基础知识

 2.Person、Student例子

7.一个类被多个类继承

1.继承的概念与定义

继承和派生:（继承和派生一体两面）

继承（inheritance）机制：是类型层次结构设计中实现代码的复用重要手段。

class 子类： 继承权限 基类
 {
}；
继承：
* 1.一个类自动拥有了来自另外一个类的属性和方法
* 2.一个类是一个类
* 层次关系-继承、派生

继承：
1、基类的处理构造和析构之外，其他的全盘继承
2、是否能被子类的成员函数访问
3、是否能被外界访问

基类的权限        public           protected         private——继承权限

 public               public            protected         private
 protected         protected      protected          private
 private             不可访问       不可访问          不可访问

派生：保持原有类特性的基础上进行扩展，增加新属性和新方法，从而产生新的类型。

在面向对象程序设计中，继承和派生是构造出新类型的过程。呈现类型设计的层次结构，体现了程 序设计人员对现实世界由简单到复杂的认识过程。

2.层次概念是计算机的重要概念:

C++ 通过类派生（ class derivation）的机制来支持继承。被继承的类称为基类（base class）或超 类（superclass），新产生的类为派生类（derived class）或子类（subclass）。基类和派生类的集合 称作类继承层次结构（hierarchy）。

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

class 派生类名：访问限定符 基类名
{
private:
	成员表1; //派生类增加或替代的私有成员
public:
	成员表2; //派生类增加或替代的公有成员
protected:
	成员表3; //派生类增加或替代的保护成员
};//分号不可少

3.私有的能被继承，不能被访问


class A
{
public:
	int m_i;
	void print()
	{
		cout << "A::print" << endl;
	}
protected:
	int m_j;
private:
	int m_k;
};
class B :public A
{
	void set()
	{
		m_i = 10;
		m_j = 30;
		//m_k = 15;
	}
};
class C :protected A
{
	void set()
	{
		m_i = 10;
		m_j = 30;
		//m_k = 15;
	}
};
class D :private A
{
	void fn()
	{
		m_i = 10;
		m_j = 30;
		//m_k = 15;
	}
};
class CC :protected C
{
public:
	void ff()
	{
		m_i = 12;
		m_j = 23;
		//m_k = 15;
	}
};
class DD :public D
{
public:
	void ff()
	{
		
		//m_i = 12;
		//m_j = 23;
		//m_k = 15;
	}
};

//如果是私有继承，只能继承，不能使用
//继承除了构造和析构全盘接收
void main()
{
	cout << sizeof(B) << endl;
	B b;
	b.print();
	b.m_i = 12;
	//b.m_j = 23;
	//b.m_k = 34;
	C c;
	//c将属性m_i变成protected
	c.m_i = 12;
	c.m_j = 23;
	c.m_k = 34;}

class B :public  A//如果没有说明，默认私有继承
 //m_k = 15;//私有的能被继承，不能被访问
class DD :public D
{
public:
    void ff()
    {
        //在上一次继承被私有化了，不能再继承、访问
        //m_i = 12;
        //m_j = 23;
        //m_k = 15;
    }
};
//b.m_j = 23;//保护的在外界不能使用
C c;
//c将属性m_i变成protected
c.m_k = 34;//将C被保护继承

 4.继承的三步骤

* 1.除了构造和析构全盘接收
* 2.改写
* 3.添加子类特有的

1.继承语法

class 派生类名:［继承方式］ 基类名{ 派生类新增加的成员 };

代码如下：


class A
{
public:
	A()
	{
		cout << "A" << endl;
	}
	void print()
	{
		cout << "A::print" << endl;
	}
	~A()
	{
		cout << "~A" << endl;
	}
private:
	int m_i;

};
class B : public A
{
public:
	B()
	{
		cout << "B" << endl;
	}
	~B()
	{
		cout << "~B" << endl;
	}
private:
	int m_j;
};
void main()
{
	B b;
}

 

 因为子类继承父类的时候，先运行父类构造函数；具体的说就是运行父类时就会先“调用”父类的构造函数，注意“调用”和继承不是一个含义，实质上是“自动运行”。

2.继承例子


class Person
{
public:
	Person(int num,const char*name,char sex) :m_num(num), m_sex(sex)
	{
		m_name = new char[strlen(name) + 1];
		strcpy_s(m_name, strlen(name) + 1, name);
	}
	~Person()
	{
		if (m_name != NULL)
		{
			delete[]m_name;
			m_name = NULL;
		}
	}
	Person(const Person& p) :m_num(p.m_num), m_sex(p.m_sex)
	{
		m_name = new char[strlen(p.m_name) + 1];
		strcpy_s(m_name, strlen(p.m_name) + 1, p.m_name);
	}
	void Show()
	{
		cout << m_num << " " << m_name << " " << m_sex << endl;
	}
private:
	int m_num;
	char* m_name;
	char m_sex;
};

class Student :public Person
{
public:
	Student(int num, const char* name, char sex, float score)
		:Person(num,name,sex),m_score(score)
	{

	}
	Student(Student& s) :Person(s)
	{
		m_score = s.m_score;
	}
	void Print()
	{
		Show();
		cout << m_score << endl;
	}
private:
	float m_score;
};
void main()
{
	Student s1(1001, "zhaowawa", 'f', 15);
	s1.Print();
	Student s2(s1);
	s2.Print();
}

 

 Student类公有继承了Person类中的num、name、sex，并且扩展了score。

5.有继承和组合的构造顺序---内存布局

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

class CPU
{
public:
	CPU() { cout << "CPU" << endl; }
};
class KB
{
public:
	KB() { cout << "KB" << endl; }
};
class Mouse
{
public:
	Mouse() { cout << "Mouse" << endl; }
};
class Computer
{
public:
	Computer() { cout << "Computer" << endl; }
private:
	CPU cpu;
	KB kb;
	Mouse ms;
}; 
class Touch
{
public:
	Touch() { cout << "Touch" << endl; }
};
class Laptop :public Computer
{
public:
	Laptop() { cout << "Laptop" << endl; }
private:
	Touch tc;
};
void main()
{
	Laptop lp;
}

1.调用基类，2.按照组合顺序得到：

CPU
KB
Mouse
Computer

3.调用自己的构造

Touch
Laptop

6.继承之下的赋值运算符重载

1.基础知识


class A
{
public:
	void Print()
	{
		cout << "A::Print" << endl;
	}
protected:
	int m_i;
};
/*
*隐藏：
*/
class B :public A
{
public:
	//B::Print将A::Print隐藏了
	void Print()
	{
		cout << "B::Print" << endl;
		cout << m_i << " " << A::m_i << endl;
	}
	void set()
	{
		m_i = 10;
		A::m_i = 20;
	}
protected:
	int m_i;
};

void main()
{
	A a;
	B b;
	a.Print();
	b.set();
	b.A::Print();
	b.Print();
	cout << sizeof(A) << endl;//4
	cout << sizeof(B) << endl;//8
}

//B::Print将A::Print隐藏了

A::Print      a.Print();
A::Print      b.A::Print();//B调用A::Print
B::Print      b.Print();
10 20         b.set();、b.Print();
4                int m_i;的大小
8                既继承了A中的m_i,B自己构造了成员

 2.Person、Student例子


class Person
{
public:
	
	Person() :m_sex('f'), m_age(20)
	{
		m_name = new char[1];
		*m_name = '\0';
		cout << "Person()" << endl;
	}
	Person(const char* name,char sex,int age):m_sex(sex), m_age(age)
	{
		m_name = new char[strlen(name) + 1];
		strcpy_s(m_name, strlen(name) + 1, name);
	}
	Person(Person& p) :m_sex(p.m_sex), m_age(p.m_age)
	{
		m_name = new char[strlen(p.m_name) + 1];
		strcpy_s(m_name, strlen(p.m_name) + 1, p.m_name);
	}
	Person& operator=(Person& p)
	{
		if (this == &p)
			return *this;
		delete[]m_name;
		m_name = new char[strlen(p.m_name) + 1];
		strcpy_s(m_name, strlen(p.m_name) + 1, p.m_name);
		m_sex = p.m_sex;
		m_age = p.m_age;
		return *this;
	}
	void Print()
	{
		cout << m_name << " " << m_sex << " " << m_age << endl;
	}
	~Person()
	{
		if (m_name != NULL)
		{
			delete[]m_name;
			m_name = NULL;
		}
	}
private:
	char* m_name;
	char m_sex;
	int m_age;
};
class Student :public Person
{
public:
	Student() :m_num(0), m_score(0)
	{
		cout << "Student()" << endl;
	}
	Student(int num,const char*name,char sex,int age,int score):m_num(num),Person(name,sex,age),m_score(score)
	{

	}
	void Print()
	{
		cout << m_num << " ";
		Person::Print();
		cout << m_score << endl;
	}
	Student(Student& s) :Person(s), m_num(s.m_num), m_score(s.m_score)
	{

	}
	Student& operator=(Student& s)
	{
		if (this == &s)
			return *this;
		Person::operator=(s);
		m_num = s.m_num;
		m_score = s.m_score;
		return *this;
	}
private:
	int m_num;
	int m_score;
};
void main()
{
	Student s;
	Student s1(1001, "zhangsan", 'f', 20, 78);
	s.Print();
	s1.Print();
	Student s2(s1);
	s2.Print();
	s = s1;
	s.Print();
}

Person()                     先调用基类
Student()                    构造s对象
0  f 20                         没有给s对象赋值，为构造函数的默认值
0
1001 zhangsan f 20   打印s1对象
78
1001 zhangsan f 20   用s1对象拷贝构造s2对象，并将s2对象打印
78
1001 zhangsan f 20   将s1对象的值赋给s对象，并将s对象打印
78

为什么要给默认值？

Person() :m_sex('f'), m_age(20)
    {
        m_name = new char[1];
        *m_name = '\0';
        cout << "Person()" << endl;
    }

因为不写默认值没有指向合法的内存空间

void main()
{
    int* p;
    cout << p << endl;//error
}

7.一个类被多个类继承


class Person
{
public:
	Person(int num = 1000):m_num(num)
	{

	}
	void print()
	{
		cout << "count = " << m_count << endl;
	}
protected:
	int m_num;
	static int m_count;
};
int Person::m_count;
class Student:public Person
{
public:
	Student(int num, const char*job) :Person(num)
	{
		m_job = new char[strlen(job) + 1];
		strcpy_s(m_job, strlen(job) + 1, job);
		m_count++;
	}
private:
	char* m_job;
};
class Teacher :public Person
{
public:
	Teacher(int num, const char* job) :Person(num)
	{
		m_job = new char[strlen(job) + 1];
		strcpy_s(m_job, strlen(job) + 1, job);
		m_count++;
	}
private:
	char* m_job;
};
class Worker :public Person
{
public:
	Worker(int num, const char* job) :Person(num)
	{
		m_job = new char[strlen(job) + 1];
		strcpy_s(m_job, strlen(job) + 1, job);
		m_count++;
	}
private:
	char* m_job;
};
void main()
{
	Student s(1001, "student");
	Teacher t(1002, "teacher");
	Worker w(1003, "worker");
	w.print();
	s.print();
	Worker w1(1006, "worker");
	s.print();
	cout << sizeof(Worker) << endl;//8
}

count = 3      static成员只构造一次
count = 3      每构造一个继承了Person的对象，count++
count = 4      增加了一名Worker
8                   Person 的num+Worker的job

A steria.
关注
  • 1
    点赞
  • 踩
  • 7
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
c++继承和派生.doc
01-13
C++中的继承和派生是面向对象编程的重要概念，它们允许创建新的类（派生类）基于现有的类（基类），从而实现代码的重用和类的层次结构。以下是关于继承和派生的详细说明： 12.1 继承的基本概念 继承是一种“is-a”...
C++继承和派生
小程的博客
07-20 3365
C++通过类派生（classderivation）的机制来支持继承。被继承的类称为基类或超类（superclass），新产生的类为派生类（derivedclass）或子类（subclass）。基类和派生类的集合称作类继承层次结构（hierarchy）。class派生类名访问限定符基类名{private成员表1;//派生类增加或替代的私有成员public成员表2;//派生类增加或替代的公有成员protected成员表3;private。...
C++核心知识（五）—— 继承和派生
此心光明事上练的博客
03-08 3342
当使用虚继承时，虚基类是被共享的，也就是在继承体系中无论被继承多少次，对象内存模型中均只会出现一个虚基类的子对象（这和多继承是完全不同的）。即使共享虚基类，但是必须要有一个类来完成基类的初始化（因为所有的对象都必须被初始化，哪怕是默认的），同时还不能够重复进行初始化，那到底谁应该负责完成初始化呢？C++标准中选择在每一次继承子类中都必须书写初始化语句（因为每一次继承子类可能都会用来定义对象），但是虚基类的初始化是由最后的子类完成，其他的初始化语句都不会调用。
C++面向对象——继承、派生与多态
最新发布
爱思考的小伙
05-05 1011
两个类之间语义级别的一种强依赖关系，比如我和我的朋友，这种关系比依赖更强、不存在依赖关系的偶然性、关系也不是临时性的，一般是长期性的，而且双方的关系一般是平等的。C++提供虚基类(virtual base class )的方法，使得在间接继承共同基类时只保留一份成员（在内存中只有基类成员的一份拷贝），通过把基类继承声明为虚拟的，就只能继承基类的一份拷贝，从而消除歧义。当一个基类被继承为不同的派生类时，各派生类可以使用与基类成员相同的成员名，如果运行时使用同一成员名调用对象的成员，会调用哪个对象的成员？
【C++】继承和派生
weixin_45220863的博客
07-18 1678
继承、派生、多态
C++继承与派生
weixin_51884452的博客
03-08 630
浅析c++继承与派生！！！
C++：继承与派生
qq_53826699的博客
06-07 4845
继承与派生的概念 基类与派生类 访问权限控制 派生类的构造函数、析构函数 构造函数与析构函数 duo'ji'c
代码讲解C++继承和派生
12-31
1、单继承：class 派生类名：访问方式 基类名{ 派生类成员} 说明： 1.派生类名由用户自己命名 2.访问方式：公有、私有、保护 3.基类名必须是程序一个已有的类 4.冒号：告诉系统，派生类从那个基类派生 5.派生类...
C++ 类的继承与派生实例详解
01-01
继承性是面向对象程序设计最重要的特性之一，使软件有了可重用性，C++提供的类的继承机制。 继承与派生的概念 一个新类从已有的类那里获得已有的特性，这种现象称为类的继承。同样也可以说成已有的类派生出来了新的...
C++程序设计——继承与派生
Mr_Fmnwon的博客
12-26 1380
界 - 门 - 纲 - 目 - 科 - 属 - 种 ~有一个笑话：医生让病人多吃水果，看着家人送来的梨、苹果和橘子，他不解的问，医生说的是“水果”啊，怎么是“梨”“苹果”“橘子”呢？这就是哲学上的共性与个性，矛盾的普遍性与特殊性原理——当然，此篇博客并不是哲学的复习提纲，而本篇博客的内容，继承与派生，确乎与之密不可分。class 派生类名: 继承方式 基类名1, …{成员定义;};基类与派生类的关系是相对的多继承：一个派生类有多个直接基类单继承：一个派生类只有一个直接基类。
C++的继承与派生
Tian Meng的博客
07-11 347
这是因为，如果我们用一个基类指针指向一个派生类的对象，然后删除这个指针，那么如果基类的析构函数不是虚函数，就只会调用基类的析构函数，而不会调用派生类的析构函数。所以，我们一般会将基类的析构函数声明为虚函数，这样，在删除基类指针时，就会首先调用派生类的析构函数，然后才调用基类的析构函数。如果派生类中有与基类相同的成员，那么在通过派生类对象或者派生类的成员函数树进行访问该成员时，会访问到派生类新增的成员，而不是基类的。表示具体的图形对象。基类的指针可以指向派生类的对象，基类的引用可以引用派生类的对象。
C++ 继承和派生
Mi-ronin的博客
10-14 1475
继承与派生 一.继承和派生机制 二.层次概念 三.继承语法 3.1 继承格式 3.2 编制派生类时可分四步 为什么构造函数与析构函数不可以被继承？ 3.3 继承关系的访问限定符 3.4 继承基类成员访问方式的变化 3.5 继承中的作用域 同名隐藏与函数重载，函数重写的区别 3.8 派生类的默认成员函数 3.7 继承与静态成员 3.8 继承与友元 3.9 菱形继承与虚拟继承 四.公有继承/私有继承/保护继承的区别 五.公有继承与私有继承和组合怎样选择
C++之继承与派生
有梦想的小新人的博客
12-11 614
文章目录1.类的继承与派生1.1 类的继承1.2 类的派生2.访问控制2.1公有继承2.22.3 1.类的继承与派生 1.1 类的继承 多继承和单继承：一个派生类可以同时有多个基类称为多继承： class Derived:public Base1,private Base2{}；一个派生类只有一个直接基类称为单继承： class Derived:public Base1{} 直接基类和间接基类：直接参与派生出某类的基类称为直接基类，基类的基类甚至更高的基类称为间接基类 在类的定义中，除了要指定基类外，还
浅析C++继承与派生
热门推荐
Fireplusplus的博客
06-11 1万+
测试环境： Target: x86_64-linux-gnu gcc version 5.3.1 20160413 (Ubuntu 5.3.1-14ubuntu2.1) 定义 要分析继承，首先当然要知道什么是继承：继承是面向对象程旭设计中使代码可以复用的最重要的手段，它允许程序员在原有类特性的基础上进行扩展，增加功能。这样产生的新类，就叫做派生类（子类）。继承呈现了面向对象程
c++ 继承与派生
m0_61650789的博客
05-12 1057
c++ 继承与派生
28.【C++ 继承与派生 （详解）】
qq_69683957的博客
08-18 714
C++继承与派生 详解
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值