c++的继承

最新推荐文章于 2023-03-16 23:45:18 发布
最新推荐文章于 2023-03-16 23:45:18 发布
阅读量146 收藏
点赞数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_40421712/article/details/80190608
版权

继承是面向对象复用的重要手段.通过继承定义一个类,继承是类型之间的关系建模,共享公有的东西,实现各自本质不同的东西.


#include<iostream>
#include<stdlib.h>
#include<string.h>


using namespace std;
class Person
{
private:
	string _name;


public:
	void show()
	{
		cout << "Person" << endl;
	}
};
class Student:public Person
{
public:
	 void display()
	{
		cout << "Student" << endl;
	}
private:
	int _stunum;;
};
int main()
{
	Student s;
	system("pause");
	return 0;

}

继承是一种复用手段,在继承关系里基类的成员类的成员派生类的成员,由此达到复用目的.


总结:

1.基类的私有成员在派生类中是不能被访问的,如果一些基类成员不想被基类对象直接访问,但需要在派生类中能访问,就定义为保护成员,可以看出保护成员限定符是因为继承才出现.

2.punlic继承是一个接口继承,保持is-a(每一个子类都是一个父类)原则,每个父类可用的成员对子类也是可用的,每个子类对象也都是一个父类对象.

3.protected/private继承是一个实现继承,基类的部分成员并未完全称为子类接口的一部分,是has-a(每一个子类中都有一个父类)的关系原则.所以非特殊情况下是不会用这两种继承关系,绝大多是情况下都是使用公有继承.

4.不管哪种继承方式,在派生内部都可以访问基类的公有成员和保护成员,但是基类的私有成员存在但是在子类中不可见(不能访问)

5.使用关键字class时默认的继承方式时private,使用struct时默认的继承方式时public,不过最好显示的写出继承方式.

6.在实际运用中一般都是用public继承,极少场景下才会使用protected/private继承.

继承与转换--赋值兼容规则--public继承

1.punlic继承时子类可以赋值给父类--切片

2.子类对象不能赋值给子类对象

3.父类的指针/引用可以指向子类对象

4.子类的指针/引用不可以指向父类对象(可以通过强制类型转换完成)

(这种情况会出现问题就是越界访问)

例:

#include<iostream>
#include<stdlib.h>
#include<string.h>


using namespace std;
class Person
{
protected:
	string _name;


public:
	void show()
	{
		cout << "Person" << endl;
	}
};
class Student:public Person
{
public:
	 void display()
	{
		cout << "Student" << endl;
	}
private:
	int _num;;
};
int main()
{
	Person p;
	Student s;
	p=s;            //子类对象可以赋值给父类对象（切片/切割）
	//s=p;         // 父类对象不能赋值给子类对象
	//父类的指针/引用可以指向子类对象
	Person *p1 = &s;
	Person &p2 = s;
	//子类的指针/引用不可以指向父类对象(可以通过强制类型转换完成)
	Student* s1 = (Student*)&p;
	Student& s2 = (Student&)p;
	system("pause");
	return 0;

}


继承体系中的作用域:

1.在继承体系中基类和派生类都有独立的作用域

2.子类和父类中有同名成员(同名成员函数和同名成员变量),子类成员将屏蔽父类成员的直接访问(子类成员函数中,可以使用 基类::基类成员 访问)--(隐藏)重定义

3.注:在实际继承体系中最好不要定义同名的成员

例:(同名成员变量)

#include<iostream>
#include<stdlib.h>
#include<string.h>


using namespace std;
class Person
{
public:
	string _name;


public:
	void show()
	{
		cout << "Person" << endl;
	}
};
class Student:public Person
{
public:
	 void display()
	{
		cout << "Student" << endl;
	}
public:
	int _num;;
};
int main()
{
	Person p;
	p._name = 10;
	Student s;
	cout << sizeof(s) << endl;
	s._name = 20;              //访问的是子类的_name(这就是重定义/隐藏)
	s.Person::_name = 200;//指定作用域是可以访问到父类的_name
	system("pause");
	return 0;
}

例：（同名成员函数）

#include<iostream>
#include<stdlib.h>
#include<string.h>


using namespace std;
class Person
{
public:
	
	void show()
	{
		cout << "Person show()" << endl;
	}
	void f1(int i)
	{
		cout << "Student shows()" << endl;
	}
	string _name;
};
class Student:public Person
{
public:
	 void show()
	{
		cout << "Student shows()" << endl;
	}
	 void f1()
	 {
		 cout << "Student shows()" << endl;
	 }
	int _num;;
};
int main()
{
	Person p;
	Student s;
	s.show();//两个show构成重定义/隐藏；
	s.f1(); //两个f1构成重定义/隐藏（虽然他们的参数不同但是名字是相同的）
	system("pause");
	return 0;

}


继承关系里面，在派生类中如果没有显示的定义这6个成员函数编译器会默认合成这6个成员函数


#include<iostream>
#include<stdlib.h>
#include<string.h>


using namespace std;
class Person
{
public:
	Person()
		:_name("name")
	{
		cout << "Person" << endl;
	}
	Person(const Person& p)
		:_name(p._name)
	{
		cout << "Person(const Person& p)" << endl;
	}
	Person& operator=(const Person& p)
	{
		cout << "Person& operator=(const Person& p)" << endl;
		if (this != &p)
		{
			_name = p._name;
		}
		return *this;
	}
	~Person()
	{
		cout << "~Person()" << endl;
	}
protected:
	string _name;
};

class Student:public Person
{
public:
	//构造
	Student()
		:Person()//name是父类的成员所以要调用父类的构造函数
		,_num(0)
	{
		cout << "Student()" << endl;
	}
	//拷贝构造
	Student(const Student& s)
		:Person(s)
		,_num(s._num)
	{
		cout << "Student(const Student& s)" << endl;
	}
	Student& operator=(const Student& s)
	{
		cout << "Student& operator=(const Student& s)" << endl;
		if (this != &s)
		{
			Person::operator=(s);
			_num = s._num;
		}
		return *this;
	}
	~Student()
	{
		Person::~Person();
		cout << "~Student()" << endl;
	}
protected:
	int _num;;
};
int main()
{
	Student s1;
	Student s2(s1);
	Student s3;
	s1 = s3;
	Person p;
	s1.~Student(); 
	p.~Person();
	system("pause");
	return 0;

}

析构函数比较特殊，因为子类的析构函数跟父类的析构函数名称不一样，但是构成覆盖，这里编译器做了特殊处理


子类的构造是先构造父类再构造子类

子类的析构实现析构子类再析构父类

实现一个不能被继承的类：

方法一：

#include<iostream>
#include<stdlib.h>
#include<string.h>

using namespace std;
class AA
{
private:
	AA()
	{}
protected:
	int _aa;
};
class BB: public AA
{

protected:
	int _bb;
};

缺点：AA 也不能在类外用因为他们是私有的

方法二：

.h
#include<iostream>
#include<stdlib.h>
#include<string.h>

using namespace std;
class AA
{
private:
	AA()
	{}
public:
	static AA* GetAA()
	{
		return new AA;
	}
	
protected:
	int _aa;
};
class BB: public AA
{

protected:
	int _bb;
};
.cpp
#include"test.h"
int main()
{
	AA* p1 = AA::GetAA();
	system("pause");
	return 0;

}
实现一个只能在栈上生成对象的类：
class BB
{
public:
	static BB GetBB()
	{
		return   BB();
	}
private:
	BB(int b=0)
		:_bb(b)
	{}
	
public:
 int _bb;
};

实现一个只能在堆上生成对象的类：（为防止在堆上生成成员再拷贝构造一个栈上的所以要做到防拷贝）

方法一：

class BB
{
public:
	static BB& GetBB()
	{
		return  *(new BB);
	}
	
private:
	BB(int b=0)
		:_bb(b)
	{}
	
       //类的防拷贝
	//1.之声明不定义
	//2.要声明为私有（防止别人在类外定义）
	BB(const BB& bb);
	BB& operator=(const BB& bb);
public: int _bb;};

方法二：

class BB
{
public:
	static BB* GetBB()
	{
		return  new BB;
	}
	
private:
	BB(int b=0)
		:_bb(b)
	{}
	
        //类的防拷贝
	//1.之声明不定义
	//2.要声明为私有（防止别人在类外定义）
	BB(const BB& bb);
	BB& operator=(const BB& bb);
public:
int _bb;};
实现一个不能在堆上生成对象的类
class BB
{
private:
	//这样防止了在堆上生成对象
	void* operator new(size_t size);
	void  operator delete(void* p);

 int _bb;
};


单继承&多继承



#include<iostream>
#include<stdlib.h>
#include<string.h>

using namespace std;
class A
{
public:
	int _name;
};
class B :public A
{
public:
	int _num;
};
class C :public A
{

public:
	int _id;
};
class D :public B, public C
{
public:
	int _course;
};
int main()
{
	D d;
	d ._name=1;
	d ._num= 2;
	d._id = 3;
	d._course = 4;
	system("pause");
	return 0;
}


C中有两份A成员所以菱形继承存在二义性和数据冗余；

菱形虚继承


#include<iostream>
#include<stdlib.h>
#include<string.h>

using namespace std;
class A
{
public:
	int  _name;
};
class B :virtual public A
{
public:
	int _num;
};
class C :virtual public A
{
public:
	int _id;
};
class D :public B, public C
{
public:
	int _course;
};
int main()
{
	D d;
	d._name = 1;
	d._num = 2;
	d._id = 3;
	d._course = 4;
	system("pause");
	return 0;
}

虚函数&多态

虚函数——类的成员函数前面加关键字virtual，则这个成员函数就是虚函数。

虚函数重写——当在子类的定义了一个与父类完全相同的虚函数时，则称子类的这个函数重写了（也称覆盖）了父类的这个虚函数。

#include<iostream>
#include<stdlib.h>
#include<string.h>

using namespace std;
class A
{
public:
	virtual void f1()
	{
		cout << "A" << endl;
	}
	int  _name;
};
class B : public A
{
public:
	virtual void f1()
	{
		cout << "B" << endl;
	}
	int _num;
};
void fun(A& m)
{
	m.f1();
}
void fun1(A* m)
{
	m->f1();
}
int main()
{
	
	//构成多态的条件--跟对象有关
	//1.函数(fun/fun1)的参数必须是父类的指针/引用
	//2.函数(fun/fun1)里调用的函数(f1)必须是虚函数的重写
	A a;
	B b;
	fun(a);
	fun(b);
	A c;
	B d;
	fun1(&c);
	fun1(&d);
	system("pause");
	return 0;
}
#include<iostream>
#include<stdlib.h>
#include<string.h>

using namespace std;
class A
{
public:
	 void f1()
	{
		cout << "A" << endl;
	}
	int  _name;
};
class B : public A
{
public:
	 void f1()
	{
		cout << "B" << endl;
	}
	int _num;
};
void fun(A& m)
{
	m.f1();
}


int main()
{
	//不构成多态的函数--跟类型有关
	
	A a;
	B b;
	fun(a);
	fun(b);
	
	system("pause");
	return 0;
}


总结：

1.子类重写父类的虚函数实现多态，要求函数名，参数列表，返回值完全相同。

2.父类定义了虚函数，在子类中该函数始终保持虚函数特性。

3.只有类的成员函数才能定义为虚函数。

4.静态成员函数不能定义为虚函数。

5.如果在类外面定义了虚函数，只能是声明时加virtual，类外定义虚函数时不能加virtual。

6.构造函数不能是虚函数，虽然可以将operator=定义为虚函数，但是最好不要把operator=定义为虚函数，因为使用时容易引起混淆。

7.不要在构造函数和析构函数中调用虚函数，在构造和析构函数中对象是不完整的容易引发未定义行为。

8.最好把父类的析构函数声明为虚函数（原因：析构函数比较特殊，因为子类的析构函数跟父类的析构函数名称不一样，但是构成覆盖，这里编译器做了特殊处理(参考上面合成默认函数)）


纯虚函数

在成员函数的形参后面写上=0，则成员函数为纯虚函数。包含纯虚函数的类叫做抽象类（也叫接口类），抽象类不能实例化出对象。纯虚函数在派生类中重新定义以后，派生类才能实例化处对象。

class A
{
	virtual void show() = 0;//纯虚函数
protected:
	string _name;//名字
};
class B :public A
{};
友元与继承

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

友元与静态成员

基类定义了static成员，则整个继承体系里面只有一个这样的成员。无论父类中出多少个类，都只有一个static成员

.h
#include<iostream>
#include<stdlib.h>
#include<string.h>

using namespace std;
class AA
{
public:
	AA()
	{
		++_count;
	}
protected:
	string _name;
public:
	static int _count;
};
int AA::_count = 0;
class BB : public AA
{
protected:
	int _stunum;
};
class CC:public BB
{
protected:
	string _course;
};
.cpp
#include"test.h"
int main()
{
	AA a1;
	AA a2;
	AA a3;
	CC c;
	cout << "人数" << AA::_count << endl;
	AA::_count = 0;
	cout << "人数" << AA::_count << endl;
	system("pause");
	return 0;

}











qq_40421712
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
c++继承构造函数
digitalkee的博客
12-18 1万+
【1】为什么需要继承构造函数？ 首先，看看如下代码片段： 1 struct A 2 { 3 A(int i) 4 {} 5 }; 6 7 struct B : A 8 { 9 B(int i) : A(i) 10 {} 11 }; 在C++中非常常见：B派生于A，B在构造函数中调用A的构造函数，从而完成构造函数的“传递”。 有时候，基类可能拥有数量众多的不同版本的构造函数（这样的情况并不少见）。 那么，倘若基类中有大量的构造函数
C++ 继承详解及实例代码
09-01
C++继承是面向对象编程中的一个核心概念，它允许创建一个新的类（子类或派生类）基于已存在的类（基类或父类）。通过继承，子类不仅可以获得基类的所有成员（包括数据成员和成员函数），还可以添加新的功能或者重写...
c++实验三：继承与派生
cy846586184的博客
05-31 6448
一、实验目的 1、 掌握类继承与派生关系以及实现方法，理解类的层次结构； 2、 掌握派生类构造函数初始化基类成员和对象成员的方法； 3、 掌握类型兼容规则，掌握派生类的复制构造函数的定义。 4、 掌握多重继承和虚基类。 二.一个用于人事管理的类族。 ⑴设计一个用于人事管理的“People（人员类）”基类。考虑到通用性，仅抽象出各类人员都具有的属性：编号、姓名·、性别、出生日期、身份证号等； ⑵从People（人员类）派生出Student（学生类），并添加属性：班号classNO； ⑶从People类派生出T
【C++】—— C++中的继承（下）
chenxiyuehh的博客
03-23 152
上篇博客C++中的继承(上)我们讲到了继承关系函数重载与函数重定义等概念，接下来我们继续介绍继承与派生： 继承与派生 派生类中的默认成员函数 派生类的构造函数必须调基类的构造函数初始化基类那一部分的成员。若基类没有默认的构造函数，则必须在派生类构造函数的初始化列表阶段显示调用。 派生类的拷贝构造函数必须调基类的拷贝构造函数完成基类部分成员的拷贝构造。 派生类的operat...
C++ 继承详解
热门推荐
TABE_的博客
02-21 1万+
C++ 继承继承语法继承方式改变访问权限名字遮蔽继承时的对象模型无变量遮蔽有变量遮蔽 继承语法 继承的一般语法为： class 派生类名:［继承方式］ 基类名{ 派生类新增加的成员 }; 继承方式 继承方式包括 public（公有的）、private（私有的）和 protected（受保护的），此项是可选的，如果不写，那么默认为 private。不同的继承方式会影响基类成员在派生类中的访问权限。 （1）public继承方式 基类中所有 public 成员在派生类中为 public 属性； 基类中
C++ 继承
qq_58724706的博客
05-04 3440
都说C++难学，其中继承这一块的语法就是其中一个体现，像别的语言java就简化了继承这一块的语法(删去了多继承这个语法,就不存在菱形继承的问题)，C++中尤其菱形继承(由多继承衍生出来的菱形继承场景)和虚函数、多态结合才是能让人从入门到放弃~ 不过这有什么可怕的？只要我们迎难而上，只有难学的知识我们把它搞懂了，才能体现我们和其他人的差距。今天博主来给大家详细剖析C++继承这个语法~ 目录 继承的概念 继承的定义 定义格式 继承关系和访问限定...
C++继承详解
DR5200的博客
10-14 2660
文章目录一.继承的概念和定义二.基类和派生类对象赋值转换三.继承中的作用域四.派生类的默认成员函数五.继承和友元六.继承与静态成员七.菱形继承及菱形虚拟继承八.C++编译器如何通过虚继承解决数据冗余和二义性 一.继承的概念和定义 继承(inheritance)机制是面向对象程序设计使代码可以复用的最重要的手段，它允许程序员在保持原有类特性的基础上进行扩展，增加功能，这样产生新的类，称派生类。继承呈现了面向对象程序设计的层次结构，体现了由简单到复杂的认知过程。以前我们接触的复用都是函数复用，继承是类设计层次的
C++继承
彧玊的博客
12-20 1865
C++继承相关的基础知识
C++继承的使用
JayceSun的博客
04-17 1878
定义 继承(inheritance)机制是面向对象程序设计使代码可以复用的最重要的手段，它允许程序员在保持原有类特 性的基础上进行扩展，增加功能，这样产生新的类，称派生类。继承呈现了面向对象程序设计的层次结构， 体现了由简单到复杂的认知过程。以前我们接触的复用都是函数复用，继承是类设计层次的复用。 ...
C++继承[万字详解]
weixin_47257473的博客
03-16 4069
本文非常详细介绍了C++中的继承，包括继承的定义，介绍，方式。以及继承后派生类构造函数和析构函数的调用顺序，继承中的切片等问题，继承后静态成员，友元关系的变化，以及多继承中的菱形继承和菱形虚拟继承，对继承的一些总结。继承和组合的介绍以及关系.
C++继承方式
m0_50313114的博客
05-20 940
C++继承分为，公有(public)、保护(protected),私有(private)三种继承方式， 公有继承：基类共有成员（函数、属性）、保护成员在派生类中依旧为共有成员、保护成员；基类私有成员物理上在派生类中继承了，不过不能通过派生类对象（指针、引用）访问，只能通过基类中公有函数来间接访问基类私有成员。 保护继承：基类共有成员（函数、属性）、保护成员在派生类中均为在派生类中“”保护成员，私有成员在“派生类中不可见”，可通过基类共有函数间接访问。 私有继承：基类公有、保护、私有在派生类中均“不可见
实例代码讲解c++ 继承特性
12-17
以下是对C++继承特性的详细解释： 1. **派生类构造函数**：派生类需要定义自己的构造函数来初始化新增加的数据成员。在派生类构造函数中，通常需要调用基类的构造函数来初始化继承过来的成员。这可以通过成员初始化...
c++继承分类
04-28
C++继承是面向对象编程（OOP）中的一个核心概念，它允许我们创建新的类，这些新类可以扩展已存在的类的功能。在这个“c++继承分类”主题中，我们将深入探讨C++中的继承机制，以及如何在Qt环境中利用这一特性进行开发...
C++ 继承机制易犯的错误
01-21
继承作为面向对象的基本特征之一，其使用率极高。不管是为了实现软件的基本功能，还是再程序的重构的过程中，我们总是会用到继承机制。正是因为其用途极为广泛，而且使用简单，大众程序员对其真正的内部实现机制的...
利用SIMULINK建立的四转子动力学模型.rar
最新发布
09-10
1.版本：matlab2014/2019a/2024a 2.附赠案例数据可直接运行matlab程序。 3.代码特点：参数化编程、参数可方便更改、代码编程思路清晰、注释明细。 4.适用对象：计算机，电子信息工程、数学等专业的大学生课程设计、期末大作业和毕业设计。
WPF的MVVM框架，数据绑定和命令的学习文档
09-10
MVVM是WPF的一种软件架构模式，它将应用程序分为三个层次 model（数据模型），view（视图），viewmodel（视图模型） 在MVVM中数据绑定、命令一直是难点，该文档讲解的比较清楚明了 数据绑定 1、Binding数据源 ◆绑定对象是DataContext，DataContent数据是默认的数据源属性，通过在Xaml中初始化Datacontent绑定 ◆绑定对象是Source属性时，通过资源Resouce的key名字来绑定Source ◆绑定对象是RelativeSource属性，数据源是控件树中相对于当前控件的上层控件时 ◆绑定对象是ElementName属性，数据源是其他控件 2、Binding模式（数据流方向），由Model属性指定，有5个模式 3、转换器 4、绑定的其它属性 5、INotifyPropertyChanged接口和wpf提供的实现了这个接口的类ObservableObject、BindableBase，可以直接继承这些类，使代码更简洁 6、实现INotifyColletionChanged接口，用于集合
天鹰优化算法AO-TCN-LSTM-Multihead-Attention多变量时间序列预测Matlab实现.rar
09-10
1.版本：matlab2014/2019a/2024a 2.附赠案例数据可直接运行matlab程序。 3.代码特点：参数化编程、参数可方便更改、代码编程思路清晰、注释明细。 4.适用对象：计算机，电子信息工程、数学等专业的大学生课程设计、期末大作业和毕业设计。
基于ssm的协同过滤算法的电影推荐系统设计与实现.docx
09-10
基于ssm的协同过滤算法的电影推荐系统设计与实现.docx
带有永磁体的直流发动机simulink.rar
09-10
带有永磁体的直流发动机simulink.rar
C++继承详解与示例
"C++继承介绍，讲解了C++中的继承概念，包括public继承以及virtual、non-virtual和pure virtual成员函数的区别。通过示例代码展示了如何使用继承，并且验证了基类指针可以调用派生类对象的方法，但反之不行。" 在...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值