【C++】类和对象三大特性--继承

于 2023-02-16 14:12:21 发布
阅读量2.6k 收藏 19
点赞数 17
分类专栏： 受虐的C++之路 文章标签： c++ 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/dongming8886/article/details/128908206
版权

文章目录

1.继承的概念及定义

1.1继承的概念

继承是面向对象三大特性之一

继承(inheritance)机制是面向对象程序设计使代码可以复用的最重要的手段，它允许程序员在保
持原有类特性的基础上进行扩展，增加功能，这样产生新的类，称派生类。继承呈现了面向对象
程序设计的层次结构，体现了由简单到复杂的认知过程。以前我们接触的复用都是函数复用，继
承是类设计层次的复用

有些类与类之间存在特殊的关系，例如下图中：

image-20230206143107865

我们发现，定义这些类时，下级别的成员除了拥有上一级的共性，还有自己的特性。

这个时候我们就可以考虑利用继承的技术，减少重复代码

1.2 继承定义

1.2.1定义格式

继承的语法：class 子类 : 继承方式 父类

下面我们看到Person是父类，也称作基类。Student是子类，也称作派生类

class Person
{
public:
	void Print()
	{
		cout << "name:" << _name << endl;
		cout << "age:" << _age << endl;
	}
protected:
	string _name = "peter"; // 姓名
	int _age = 18; // 年龄
};
// 继承后父类的Person的成员（成员函数+成员变量）都会变成子类的一部分。这里体现出了
//Student复用了Person的成员。下面我们使用监视窗口查看Student，可
//以看到变量的复用。调用Print可以看到成员函数的复用。
class Student : public Person
{
protected:
	int _stuid; // 学号
};

image-20230206143533135

1.2.2继承关系和访问限定符

继承方式一共有三种：

  • 公共继承
  • 保护继承
  • 私有继承

image-20230206144023718

1.2.3继承基类成员访问方式的变化

类成员/继承方式public继承protected继承private继承
基类的public成员派生类的public成员派生类的protected 成员派生类的private 成员
基类的protected 成员派生类的protected 成员派生类的protected 成员派生类的private 成员
基类的private成 员在派生类中不可见在派生类中不可见在派生类中不可 见

image-20230206143807326

总结：

  1. 基类private成员在派生类中无论以什么方式继承都是不可见的。这里的不可见是指基类的私
    有成员还是被继承到了派生类对象中，但是语法上限制派生类对象不管在类里面还是类外面
    都不能去访问它。

  2. 基类private成员在派生类中是不能被访问，如果基类成员不想在类外直接被访问，但需要在
    派生类中能访问，就定义为protected。可以看出保护成员限定符是因继承才出现的。

  3. 实际上面的表格我们进行一下总结会发现，基类的私有成员在子类都是不可见。基类的其他
    成员在子类的访问方式 == Min(成员在基类的访问限定符，继承方式)，public > protected
    > private。

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

  5. 在实际运用中一般使用都是public继承，几乎很少使用protetced/private继承，也不提倡
    使用protetced/private继承，因为protetced/private继承下来的成员都只能在派生类的类里
    面使用，实际中扩展维护性不强。

//实例演示三种继承关系下基类成员的各类型成员访问关系的变化
class Base1
{
public: 
	int m_A;
protected:
	int m_B;
private:
	int m_C;
};

//公共继承
class Son1 :public Base1
{
public:
	void func()
	{
		m_A; //可访问 public权限
		m_B; //可访问 protected权限
		//m_C; //不可访问
	}
};

void myClass()
{
	Son1 s1;
	s1.m_A; //其他类只能访问到公共权限
}

//保护继承
class Base2
{
public:
	int m_A;
protected:
	int m_B;
private:
	int m_C;
};
class Son2:protected Base2
{
public:
	void func()
	{
		m_A; //可访问 protected权限
		m_B; //可访问 protected权限
		//m_C; //不可访问
	}
};
void myClass2()
{
	Son2 s;
	//s.m_A; //不可访问
}

//私有继承
class Base3
{
public:
	int m_A;
protected:
	int m_B;
private:
	int m_C;
};
class Son3:private Base3
{
public:
	void func()
	{
		m_A; //可访问 private权限
		m_B; //可访问 private权限
		//m_C; //不可访问
	}
};
class GrandSon3 :public Son3
{
public:
	void func()
	{
		//Son3是私有继承，所以继承Son3的属性在GrandSon3中都无法访问到
		//m_A;
		//m_B;
		//m_C;
	}
};

2.基类和派生类对象赋值转换

  • 派生类对象 可以赋值给 基类的对象 / 基类的指针 / 基类的引用。这里有个形象的说法叫切片
    或者切割。寓意把派生类中父类那部分切来赋值过去。

  • 基类对象不能赋值给派生类对象。

  • 基类的指针或者引用可以通过强制类型转换赋值给派生类的指针或者引用。但是必须是基类
    的指针是指向派生类对象时才是安全的。这里基类如果是多态类型，可以使用RTTI(RunTime Type Information)的dynamic_cast 来进行识别后进行安全转换。（ps：后面多态的内容，这里先了解一下）

image-20230206144938765

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;
}

3.继承中的作用域

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

  2. 子类和父类中有同名成员，子类成员将屏蔽父类对同名成员的直接访问，这种情况叫隐藏，
    也叫重定义。（在子类成员函数中，可以使用 基类::基类成员 显示访问）

  3. 需要注意的是如果是成员函数的隐藏，只需要函数名相同就构成隐藏。

  4. 注意在实际中在继承体系里面最好不要定义同名的成员。

示例1

// Student的_num和Person的_num构成隐藏关系，可以看出这样代码虽然能跑，但是非常容易混淆
class Person
{
protected:
	string _name = "小李子"; // 姓名
	int _num = 111; // 身份证号
};
class Student : public Person
{
public:
	void Print()
	{
		cout << " 姓名:" << _name << endl;
		cout << " 身份证号:" << Person::_num << endl;
		cout << " 学号:" << _num << endl;
	}
protected:
	int _num = 999; // 学号
};
void Test()
{
	Student s1;
	s1.Print();
};

int main()
{
	Test();
	return 0;
}

image-20230206145540709

示例2

// B中的fun和A中的fun不是构成重载，因为不是在同一作用域
// B中的fun和A中的fun构成隐藏，成员函数满足函数名相同就构成隐藏。
class A
{
public:
	void fun()
	{
		cout << "func()" << endl;
	}
};
class B : public A
{
public:
	void fun(int i)
	{
		A::fun();
		cout << "func(int i)->" << i << endl;
	}
};

int main()
{
	B b;
	b.fun(10);
	return 0;
}

image-20230206145841961

总结：

  • 访问子类同名成员 直接访问即可
  • 访问父类同名成员 需要加作用域
  1. 子类对象可以直接访问到子类中同名成员
  2. 子类对象加作用域可以访问到父类同名成员
  3. 当子类与父类拥有同名的成员函数，子类会隐藏父类中同名成员函数，加作用域可以访问到父类中同名函数

4.派生类的默认成员函数

6个默认成员函数，“默认”的意思就是指我们不写，编译器会变我们自动生成一个，那么在派生类
中，这几个成员函数是如何生成的呢？

  1. 派生类的构造函数必须调用基类的构造函数初始化基类的那一部分成员。如果基类没有默认
    的构造函数，则必须在派生类构造函数的初始化列表阶段显示调用。

  2. 派生类的拷贝构造函数必须调用基类的拷贝构造完成基类的拷贝初始化。

  3. 派生类的operator=必须要调用基类的operator=完成基类的复制。

  4. 派生类的析构函数会在被调用完成后自动调用基类的析构函数清理基类成员。因为这样才能
    保证派生类对象先清理派生类成员再清理基类成员的顺序。

  5. 派生类对象初始化先调用基类构造再调派生类构造。

  6. 派生类对象析构清理先调用派生类析构再调基类的析构。

  7. 因为后续一些场景析构函数需要构成重写，重写的条件之一是函数名相同(这个我们后面会讲
    解)。那么编译器会对析构函数名进行特殊处理，处理成destrutor()，所以父类析构函数不加
    virtual的情况下，子类析构函数和父类析构函数构成隐藏关系

image-20230206150130899

image-20230206151035324

示例

class Person
{
public:
	Person(const char* name = "peter")
		: _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(const char* name, int num)
		: Person(name)//派生类要显示调用基类构造函数
		, _num(num)
	{
		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()
	{
		cout << "~Student()" << endl;
	}
protected:
	int _num; //学号
};
int main()
{
	Student s1("jack", 18);
	Student s2(s1);
	Student s3("rose", 17);
	s1 = s3;
	return 0;
}

image-20230206151542675

5.继承与友元

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

示例

class Student;
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);
}

报错信息：

image-20230206152009755

6. 继承与静态成员

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

问题：继承中同名的静态成员在子类对象上如何进行访问？

静态成员和非静态成员出现同名，处理方式一致

  • 访问子类同名成员 直接访问即可
  • 访问父类同名成员 需要加作用域

示例：

class Base {
public:
	static void func()
	{
		cout << "Base - static void func()" << endl;
	}
	static void func(int a)
	{
		cout << "Base - static void func(int a)" << endl;
	}

	static int m_A;
};

int Base::m_A = 100;

class Son : public Base {
public:
	static void func()
	{
		cout << "Son - static void func()" << endl;
	}
	static int m_A;
};

int Son::m_A = 200;

//同名成员属性
void test01()
{
	//通过对象访问
	cout << "通过对象访问： " << endl;
	Son s;
	cout << "Son  下 m_A = " << s.m_A << endl;
	cout << "Base 下 m_A = " << s.Base::m_A << endl;

	//通过类名访问
	cout << "通过类名访问： " << endl;
	cout << "Son  下 m_A = " << Son::m_A << endl;
	cout << "Base 下 m_A = " << Son::Base::m_A << endl;
}

//同名成员函数
void test02()
{
	//通过对象访问
	cout << "通过对象访问： " << endl;
	Son s;
	s.func();
	s.Base::func();

	cout << "通过类名访问： " << endl;
	Son::func();
	Son::Base::func();
	//出现同名，子类会隐藏掉父类中所有同名成员函数，需要加作作用域访问
	Son::Base::func(100);
}
int main() {

	test01();
	test02();
	return 0;
}
image-20230206152432121

总结：同名静态成员处理方式和非静态处理方式一样，只不过有两种访问的方式（通过对象 和 通过类名）

7.复杂的菱形继承及菱形虚拟继承

C++允许一个类继承多个类

语法： class 子类 ：继承方式 父类1 ， 继承方式 父类2...

多继承可能会引发父类中有同名成员出现，需要加作用域区分

C++实际开发中不建议用多继承

单继承：一个子类只有一个直接父类时称这个继承关系为单继承

image-20230206153043566

多继承：一个子类有两个或以上直接父类时称这个继承关系为多继承

image-20230206152732421

菱形继承概念：

菱形继承：菱形继承是多继承的一种特殊情况。

​ 两个派生类继承同一个基类

​ 又有某个类同时继承者两个派生类

​ 这种继承被称为菱形继承，或者钻石继承

image-20230206153101752

菱形继承的问题：从下面的对象成员模型构造，可以看出菱形继承有数据冗余和二义性的问题。
在Assistant的对象中Person成员会有两份。

image-20230206153909780

示例1

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; // 主修课程
};
void Test()
{
	// 这样会有二义性无法明确知道访问的是哪一个
	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; // 主修课程
};
void Test()
{
	Assistant a;
	a._name = "peter";
}

虚拟继承解决数据冗余和二义性的原理

为了研究虚拟继承原理，我们给出了一个简化的菱形继承继承体系，再借助内存窗口观察对象成
员的模型。

示例1-没有加virtual关键字

class A
{
public:
	int _a;
};
class B : public A
{
public:
	int _b;
};
class C : 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;
	return 0;
}

下图是菱形继承的内存对象成员模型：这里可以看到数据冗余

image-20230206202955591

示例2-加virtual关键字的虚拟继承

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 = 6;
	return 0;
}

下图是菱形虚拟继承的内存对象成员模型：这里可以分析出D对象中将A放到的了对象组成的最下
面，这个A同时属于B和C，那么B和C如何去找到公共的A呢？

这里是通过了B和C的两个指针，指向的一张表。这两个指针叫虚基表指针，这两个表叫虚基表。

虚基表中存的偏移量。通过偏移量可以找到下面的A。

image-20230206204005867

我们可能会有疑问为什么D中B和C部分要去找属于自己的A？那么大家看看当下面的赋值发生时，d是
不是要去找出B/C成员中的A才能赋值过去？

D d;
B b = d;
C c = d;

下面是上面的Person关系菱形虚拟继承的原理解释

image-20230206204732195

8.继承的总结和反思

  1. 很多人说C++语法复杂，其实多继承就是一个体现。有了多继承，就存在菱形继承，有了菱
    形继承就有菱形虚拟继承，底层实现就很复杂。所以一般不建议设计出多继承，一定不要设
    计出菱形继承。否则在复杂度及性能上都有问题。

  2. 多继承可以认为是C++的缺陷之一，很多后来的语言都没有多继承，如Java。

  3. 继承和组合

    • public继承是一种is-a的关系(如学生是人)。也就是说每个派生类对象都是一个基类对象。
      组合是一种has-a的关系（如眼睛和头的关系）。假设B组合了A，每个B对象中都有一个A对象。

    • 优先使用对象组合，而不是类继承 。

    • 继承允许你根据基类的实现来定义派生类的实现。这种通过生成派生类的复用通常被称
      为白箱复用(white-box reuse)。术语“白箱”是相对可视性而言：在继承方式中，基类的
      内部细节对子类可见 。继承一定程度破坏了基类的封装，基类的改变，对派生类有很
      大的影响。派生类和基类间的依赖关系很强，耦合度高。

    • 对象组合是类继承之外的另一种复用选择。新的更复杂的功能可以通过组装或组合对象
      来获得。对象组合要求被组合的对象具有良好定义的接口。这种复用风格被称为黑箱复
      用(black-box reuse)，因为对象的内部细节是不可见的。对象只以“黑箱”的形式出现。
      组合类之间没有很强的依赖关系，耦合度低。优先使用对象组合有助于你保持每个类被
      封装。

    • 实际尽量多去用组合。组合的耦合度低，代码维护性好。不过继承也有用武之地的，有
      些关系就适合继承那就用继承，另外要实现多态，也必须要继承。类之间的关系可以用
      继承，可以用组合，就用组合。

小明的c++笔记本
关注
专栏目录
【java】面向对象的三大特性之一----继承
qq_43669007的博客
10-11 542
1.继承是面向对象的三大特性之一 1.1 继承的概念 类的继承就是指在一个现有类的基础上去构建一个新的类，构建出来的新类被称作子类，现有类被称作父类，子类会自动拥有父类所有可继承的属性和方法。j如果想要声明一个类继承另外一个类，要用extends关键字。 1.2 继承的语法 class ParentClass{ //属性//方法//构造方法 } class chil...
C++ 类和继承
Choly_chen的博客
04-09 572
C++三大特性：继承、封装和多态。今天想先把继承的一些基本概念搞清楚~以后会慢慢慢慢慢慢慢扩展的！ 参考网上的一些资料，做了一些整理如下：一、定义：    继承性是面向对象程序设计的一个重要特性。它允许在既有类的基础上创建新的类，新类可以从一个（单继承）或者是多个（多继承）既有类中继承函数和数据，还可以重新定义或加入新的数据和函数。继承的重要优势之一，就是实现了代码复用。    我们一般把原始类称...
c++类和继承
Gnglas的博客
02-21 224
c++ 面向对象 运算符重载 成员函数运算符重载 全局函数运算符重载 运算副重载函数发生重载 拷贝构造 友元 继承 继承方式 继承复用 继承的构建顺序 继承基类调用 c++ 面向对象 运算符重载 operator 创建一个重载运算符 成员函数运算符重载 // 现在我们创建一个对象 class Perjet { public: // 定义两个int 类型变量 int ba; int bb; // 设置变量的值 Perjet() {} Perjet(int..
C++类和继承
chuck001002004的博客
10-31 1404
C++与C语言类似，运算效率高，与java也有相似之处 一：基础 1.输入：C语言中使用scanf来输入，需要声明变量的类型，头文件include。                C++中只需要“cin>>变量”即可实现，头文件include。 2.输出：C语言输出用printf执行，也需要声明变量的类型。                C++用“cout 二：类与继承 类在
C++类与继承
csdnyhz的博客
09-09 157
类与继承： class cBase//基类 { private: int m_iPrivateBaseData;//私有成员只能由类自身成员访问，子类不能访问 public: cBase(int arg) : m_iPrivateBaseData(arg){};//基类构造函数 virtual void VirtualBaseFunc(){return m_iProtectedBaseData;};//基类虚函数 int baseFuncConst() const {return m_iPrivateBas
C++类的特性-职工管理系统.zip
最新发布
10-29
利用C++类的特性：封装、继承和多态 利用C++操作符的重载
C++面向对象程序设计课程大作业-通讯录管理系统
05-21
C++是支持OOP的重要编程语言，提供了类（Class）、对象（Object）、继承（Inheritance）、多态（Polymorphism）等特性。 1. **类与对象**：在C++中，类定义了一种数据结构，它是对象的蓝图。对象是类的实例，包含了...
c++语言程序设计课件_C语言教程_C++程序设计--类与对象_
09-30
C++的面向对象特性还包括封装、继承和多态。封装是将数据和操作数据的方法捆绑在一起，形成一个独立的实体，这样可以隐藏内部实现细节，只对外提供接口。继承允许一个类（子类）继承另一个类（父类）的属性和方法，...
C++三大特性----“继承”
chenkaixin_1024的博客
03-02 1749
C++作为一门面向对象的语言，其核心便是它的三大特性：封装，继承和多态。     而其中，继承这一特性的存在最主要的目的是为了实现代码的复用，即当你在构建多个类的时候，你发现它们之间有相当一部分的功能和属性是相同，这时你就可以通过继承这一特性来进行代码的复用，将重复的部分作为公共部分来使用，从而不必在构建每一个类的时候都将相同的部分在写一遍。
13-C++课件-面向对象高级编程-p110
06-04
在C++中，面向对象编程（OOP）包括类（class）、对象（object）、封装、继承、多态等核心概念。 首先，基础是关键。在学习面向对象编程之前，你应该对C语言或其他过程化语言有基本的了解，熟悉变量、类型、作用域、...
C++类的继承关系
m0_58495729的博客
10-23 1157
C++学习路径之类的继承
C++类的继承
小怪物爱吹牛的博客
11-23 5416
C/C++文件读写引言新的改变功能快捷键合理的创建标题，有助于目录的生成如何改变文本的样式插入链接与图片如何插入一段漂亮的代码片生成一个适合你的列表创建一个表格设定内容居中、居左、居右SmartyPants创建一个自定义列表如何创建一个注脚注释也是必不可少的KaTeX数学公式新的甘特图功能，丰富你的文章UML 图表FLowchart流程图导出与导入导出导入 引言 你好！ 这是你第一次使用 Mark...
c++派生类与继承
热门推荐
ayangya的博客
12-23 1万+
派生类的构造函数和析构函数 基类的构造函数和析构函数不能被继承，在派生类中，如果对派生类新增的成员进行初始化，需要加入派生类的构造函数 当派生类创建对象时，首先执行基类的构造函数，随后执行派生类的构造函数；当撤销派生类对象时，先执行派生类的析构函数，在执行基类的析构函数。 当基类的构造函数没有参数或没有显式定义构造函数时，派生类可以不向基类传递参数，甚至可以不定义构造函数。#include<i
C++面向对象的三大特性
m0_64837135的博客
03-14 2666
面向对象：先抽象问题整体，在具体逻辑细节。 面向过程：先具体逻辑细节，再抽象问题整体。 面向对象的三大特性：封装、继承、多态 类的封装 --> 一个类如何描述？ 类的继承 --> 多个类型之间存在继承关系,如何继承？ 类的多态 --> 类的对象有多种形态？ C++认为万事万物皆为对象，对象上有其属性与行为。 例如： 人可以作为对象，属性有姓名、年龄、身高、体重... 行为有走、跑、跳、唱歌、跳舞.. 车可以作为对象，属性有轮胎，方向盘，车灯... 行为载人、播音乐、放...
C++面向对象编程三大特征都有什么？每种特征的主要作用是什么？
weixin_61725973的博客
12-14 693
多态是指在一般类中定义的属性或行为，被特殊类继承之后，可以具有不同的数据类型或表现出不同的行为。封装在现实中的例子：人们使用各种电子设备，人们知道按下每个按键的功能（音量，关机）是什么，不需要知道各个功能是怎样实现的，也不需要知道其内部电路或构造。把对象的属性和功能结合成一个独立的系统单位。重载包括函数重载和运算符重载 ，函数重载：使用同一个名字的多个函数定义。C++中，编译时多态是通过重载实现的，而运行时多态是通过虚函数实现的。定义：如果类的对象A拥另一个类B的全部属性与服务，称作类A对类B的继承。
【C+】深入浅出面向对象三大特性之多态
码农印象
04-05 490
前言什么是多态？对象的类型静态多态动态多态动态绑定的先决条件虚函数定义的重要说明重定义(隐藏规则)纯虚函数虚表剖析 作为面向对象三大特性之一的多态无疑是最复杂的一个特性。 封装可以使代码模块，继承可以在原有的基础上进行改进,增加新功能，前两者的引入都是为了提高·代码的复用性。那么多态呢？它的目的是为了·接口重用，即当传递不同类的多个对象时，函数都可以通过同一个接口调用不同对象的实现方法。 什么是多...
C++ 面向对象三大特征（封装、继承、多态）
编程菜鸟
01-27 653
C++面向对象的三大特征：封装、继承、多态 C++认为万事万物结为对象，对象上有其属性和行为 一、封装 意义：①将属性和行为作为一个整体，表现生活中的事物 ②将属性和行为加以权限控制 语法：class 类名 { 访问权限： 属性 / 行为 } 权限：公共权限 public 类内可以访问，类外可以访问 保护权限protected 类内可以访问，类外不可以访问（子可...
王老师 C++ 类的继承
行风
07-15 6616
1.类的继承语法: class 导出类名 : 继承方式 基类名1, ..., 继承方式 基类名n 类体 继承方式有public, protected, private三种.导出类对象构成:(1)基类的对象; (2)导出类部分.导出类中成员的访问权限,如下表所示. 继承方式 基类private
继承是面向对象三大特性之一
码云仓库地址：https://gitee.com/lance-gyq
01-31 147
继承是面向对象三大特性之一 有些类与类之间存在特殊的关系，例如下图中： 我们发现，定义这些类时，下级别的成员除了拥有上一级的共性，还有自己的特性。 这时我们就可以考虑利用继承的技术，减少重复代码。 代码示例： #include <iostream> using namespace std; //继承实现页面 //公共页面类 class BasePage { public: void header() {
C++类与对象详解：封装、继承和多态
"C++类和对象的总结，包括对象的概念、类的引入、类的定义以及封装、继承和多态的简述。" 在面向对象编程中，C++提供了对类和对象的强大支持。对象是类的具体实例，代表了现实世界中的实体，具有属性（数据成员）和...
评论 16
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

小明的c++笔记本

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值