C++中的继承【父类和子类的赋值转化】【子类的默认成员函数】【菱形继承与菱形虚拟继承（重要）】

最新推荐文章于 2024-11-12 13:55:23 发布
最新推荐文章于 2024-11-12 13:55:23 发布
阅读量1.3k 收藏 33
点赞数 39
分类专栏： c++的学习 文章标签： c++ 开发语言 学习 visual studio
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/aaa114514aaaa/article/details/142059888
版权

目录

C++中的继承

1.继承的概念及定义

1.1继承的概念

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

// 继承
// 学生和教师都有很多作为人的共同点,因此人作为父类
class Person
{
public:
	void print()
	{
		cout << "name:" << _name << endl;
		cout << "age:" << _age << endl;
	}

protected:
	int _age = 18;
	string _name = "Person";

private:
	int birth = 2004;
};

// Student和Teache继承了父类Person之后，父类的所有成员变量和成员函数都会成为子类的一部分
// 这里体现出了Student和Teacher复用了Person的成员
// 调试可以看到子类对父类成员变量的复用
// 调用父类的函数，可以体现子类对父类成员函数的复用
class Student : public Person
{
protected:
	int _id;//学号

};

class Teacher : public Person
{
protected:
	int _jobid; // 工号
};


int main()
{
	Student s;
	Teacher t;

	s.print();
	t.print();
	//name:Person
	//age : 18
	//name : Person
	//age : 18'

	return 0;
}

调试之后我们可以看到s和t都继承了Person的所有成员变量，但是父类的birth是私有的，因此子类在类中无权访问。

image-20240905151621041

1.2继承的定义

1.2.1定义格式

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

国外喜欢管父类叫做基类，子类叫做派生类

image-20240905221543841

1.2.2继承关系和访问限定符

image-20240905223355975

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

下面这个表格不用死记硬背。

image-20240905221512329

总结：

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

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

  3. 实际上面的表格我们进行一下总结会发现，基类的私有成员在子类都是不可见。基类的其他成员是否能够在子类被访问，取决于继承的权限和成员权限之间的关系。取两个权限之间的最小就可以。public > protected > private.

  4. 父类的成员只要不是private权限，子类都能够访问（不管是什么权限的继承）

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

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

// 实例演示三种继承关系下基类成员的各类型成员访问关系的变化  
class Person
{
public:
	void Print()
	{
		cout << _name << endl;
	}

protected:
	string _name; // 姓名

private:
	int _age; // 年龄
};

//class Student : protected Person
//class Student : private Person
class Student : public Person
{
public:
	Student()
	{
		_name = "改动"; // 无论什么权限的继承，protected权限的父类成员变量都能在子类被访问
	}

protected:
	int _stunum; // 学号
};

int main()
{
	Student s;

	//s.Print();
}

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

  • 派生类对象 可以赋值给 基类的对象 / 基类的指针 / 基类的引用。这里有个形象的说法叫切片或者切割。寓意把派生类中父类那部分切来赋值过去。
  • 基类对象不能赋值给派生类对象。
  • 基类的指针或者引用可以通过强制类型转换赋值给派生类的指针或者引用。但是必须是基类的指针是指向派生类对象时才是安全的。这里基类如果是多态类型，可以使用RTTI(RunTime Type Information)的dynamic_cast 来进行识别后进行安全转换。（ps：这个我们后面再讲解，这里先了解一下）

image-20240906154937315

// 父类和子类之间的赋值转化
class Person
{
protected:
	string _name;
	int _age;
	string _sex;
};

class Student : public Person
{
public:
	int _id;
};


int main()
{
	Person p;
	Student s;

	// 子类对象可以赋值给父类对象/指针/引用
	p = s; // 只会s对象中Person类的属性赋值过去，跟切割一样，因此叫切片
	Person* ptr1 = &s;
	Person& rp = s;

	// 父类对象无法赋值给子类对象。
	//s = p; // error  因为子类成员更多，没人赋值给他们。因此不行

	// 父类对象的指针大部分情况也无法赋值给子类对象的指针
	// 但是如果父类的指针指向的是子类对象，那么可以通过强制转化赋值给子类的指针
	Person* ptr2 = &s;
	Student* str = (Student*)ptr2;
	
	//父类指针指向父类对象，进行强转赋值给子类指针，有可能也可以成功。但是会存在越界的问题
	ptr2 = &p;
	str = (Student*)ptr2;

	return 0;
}

3.继承的作用域

  1. 在继承中父类和子类都有各自的作用域
  2. 子类和父类如果有同名的成员变量，子类会屏蔽对父类的成员的访问，这个现象叫隐藏，也可以叫重定义【在子类成员函数中，可以使用 基类::基类成员 显式访问】
  3. 如果是成员函数的隐藏，只需要函数名相同即可构成隐藏/重定义
  4. 实际编写继承的代码时尽量不要定义同名的成员变量。
// 继承中的作用域
// 父类和子类各自拥有自己的作用域
class Person
{

protected:
	string _name = "小李";
	int _num = 1;
};

class Student : public Person
{
public:
	void Print()
	{
		cout << " 姓名:" << _name << endl;
		cout << " 身份证号:" << Person::_num << endl; // 指定Person作用域
		cout << " 学号:" << _num << endl; 
		// 如果不指定是父类的_num，那么优先在自己的作用域找。和变量的寻找规则有点像
	}

protected:
	int _num = 2; // 拥有和父类相同的变量名字，没有问题，两个变量处在各自的作用域
	// 子类和父类拥有相同的变量名，子类的变量会隐藏（重定义）父类的变量【访问优先访问子类变量】

};


int main()
{
	Student().Print();
	//姓名:小李
	//身份证号 : 1
	//学号 : 2
	return 0;
}

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

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

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

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

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

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

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

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

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

image-20240908010520869

// 子类的默认成员函数
class Person
{
public:
	// 如果这里没有缺省值，那么就不是默认构造函数，那么子类无法调用合适的父类的默认构造函数就会报错。
	Person(const string name = "Tom")
	{
 		cout << "Person()" << endl;
		_name = name;
	}

	Person(const Person& p)
	{
		cout << "Person显式拷贝构造" << endl;
		_name = p._name;
	}

	Person& operator=(const Person& p)
	{
		if (this != &p)
		{
			_name = p._name;
		}

		cout << "Person显式赋值运算符重载\n";
		return *this;
	}


	~Person()
	{
		cout << "~Person()" << endl;
	}
protected:
	string _name;
};

class Student : public Person
{
public:
	// 子类会先调用父类的构造函数，去构造自己父类的成员，在调用自己的构造函数
	Student(string name = "Tom", int id = 111)
		:Person(name) // 要想在子类构造函数去构造子类父类成员，必须调用显式调用父类的构造函数。
		,_id(id) 
	{
		cout << "Student()" << endl;
	}

	//子类的拷贝构造也不能直接修改父类成员，只能显式调用父类的拷贝构造
	Student(const Student& s)
		:Person(s) // 父类拷贝构造的形参是父类的对象，但是这里调用子类对象就行。前面说过这个叫切片
		,_id(s._id)
	{
		cout << "Student显式拷贝构造" << endl;
	}

	Student& operator=(const Student& s)
	{
		if (this != &s)
		{
			// 调用父类的=运算符重载。传s是切片。
			Person::operator=(s); // 这里不能是this->operator(s); 
			// 因为与父类的operator=是同名函数，构成隐藏/重定义了。会无线调用自己，无限递归导致栈溢出
			_id = s._id;
		}

		cout << "Student显式赋值运算符重载\n";
		return *this;
	}

	~Student()
	{
		// ~Person和~Student也构成隐藏/重定义。因为编译器会把他们处理成destructor（跟多态有关）
		//Person::~Person(); // 因此这里不能写~Person，构成隐藏。要指定调用的是父类的析构函数
		// 析构函数虽然可以显式调用，但是实际上编译器在调用完子类的析构函数之后会自动的调用父类的析构函数。
		// 因此父类的析构函数不需要我们在子类显式调用
		cout << "~Student()" << endl;
	}

	 
protected:
	int _id;
};

// 设计一个不能被继承的类
class A 
{
private:
	// 构造或者析构私有化
	A() {}
};

class B : public A
{

};
 
int main()
{
	Student s1("jack", 222); // 先调用父类的构造函数，再调用自己的
	Student s2(s1); // 先调用父类的拷贝构造，再调用自己的

	Student s3;
	s1 = s3; 
	// 如果子类没有赋值运算符重载，那么会调用父类的赋值运算符重载，再调用系统生成的默认的子类的赋值运算符重载，是浅拷贝
	// 但是如果子类实现了，并且子类的赋值运算符重载中，没有调用父类的，就不会调用父类的。
	// 就不会赋值到s3的父类的成员，只赋值s3的子类成员

	// 析构函数是先调用子类的析构函数（跟栈有关系），再自动调用父类的析构函数。
	// 因为这样才能保证先析构子类，再析构父类的顺序

	//B b; // 无法调用父类的默认构造函数，直接报错

	return 0;
}

5.继承与友元

友元无法被继承。

来看代码：

//继承与友元
class Person
{
	friend void display(const Person& p); // 这样没有问题
	//friend void display(const Person& p, const Student& s); //这样就不行，因为友元无法继承，这里带了子类

public:

private:
	string _name = "小赖";
};

class Student 
{
protected:
	int _id;
};

//void display(const Person& p, const Student& s); // 友元无法继承，不能带上子类
void display(const Person& p) // 友元函数
{
	cout << p._name << endl;
	//cout << s._id << endl; 
}

int main()
{
	Person p;
	Student s;
	display(p); // 小赖


	return 0;
}

6.继承与静态成员

// 继承与静态变量
class A
{
public:

	int _a = 1;
	static int count; // 静态成员无论被继承了多少次，这个继承体系都只有这一个静态成员
};

int A::count = 0; // 静态成员变量初始化

class B : public A
{
public:
	int _a = 2;
};

int main()
{
	A a;
	B b;

	a._a = 1; // A类和B类对象 a和b都各自拥有一个变量_a,他们存在于各自的作用域，地址不相同。
	b._a = 1;

	a.count = 1;
	b.count = 2; // a和b所拥有的count对象,指向的都是同一个静态对象，地址是一样的

	A::count++;
	cout << A::count << endl; // 3
	cout << B::count << endl; // 3 

	return 0;
}

调试可以查看成员变量的地址

image-20240908010201859

7.菱形继承与菱形虚拟继承

7.1菱形继承

前面所讲的继承都是单继承：一个子类只有一个直接父类

cpp中还有一种继承叫做多继承：一个子类可以拥有多个直接父类

但是多继承就会导致一种特殊情况就是菱形继承

image-20240908125716712

菱形继承会导致一个问题：数据冗余和二义性

下面就是一个菱形继承的代码：

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类的对象会继承了两个Person类的_name成员
	Assistant ass;
	//ass._name = "assisant"; // 这样就会报错，因为编译器不知道你指的是Student类的_name，还是Teacher类的_name
	//这就是菱形继承带来的问题：数据冗余和二义性

	// 如果要想访问_name,要指定是那个父类的_name
	ass.Student::_name = "Student._name";
	ass.Teacher::_name = "Teacher._name"; // 这一句和下一句是等效的
	ass.Teacher::Person::_name = "Person._name"; 

	return 0;
}

根据调试可以看到Assistant类的对象会拥有两个Person的成员_name

image-20240908125908130

并且这两个_name是独立的，各自在各自的作用域，这样就意味着这个ass对象有两个名字。这就是数据冗余和二义性。

我们对两个_name进行访问，可以看到他们不是同一个_name

image-20240908125040775

7.2菱形虚拟继承

那这个菱形继承导致的问题要怎么解决呢？cpp给出的方案是菱形虚拟继承

在学习菱形虚拟继承之前，我们先来学习内存对象模型：也就是对象在内存中是如何存储的

代码如下：下面是一个简易的菱形继承

//在将虚拟继承之前，要先学习内存对象模型（对象在内存中是怎么存储的）
class A
{
public:
	int _a;
};

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

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

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

int main()
{
	D d;
	cout << sizeof(d) << endl; // 虚拟继承之前，就是20个字节
	// 虚拟继承之后，就是48个字节

	d.B::_a = 1;
	d.C::_a = 2;
	d._b = 3;
	d._c = 4;
	d._d = 5;

	return 0;
}

如果不虚拟继承，d的大小是20个字节，并且变量内各个成员在内存的分布如下图：

image-20240908141418910

但是如果我们让B和C以虚拟继承的方式去继承A类，那么有什么不同呢？

首先就是d的大小在x64的环境下会变成48个字节，在x86的环境下是24个字节。

为了方便观察成员在内存中的存储，这里用x86的环境去看地址。

image-20240908144201686

在d变量中，B类和C类的部分原来继承的A类成员_a,变成了一个指针，这个指针存储着一个数字，代表着这个指针当前位置距离真正存储_a这个成员地址的偏移量

也就是说当我们要通过B或者C类对象去访问这个_a的时候，是通过其内的指针的地址 + 上内部存储的偏移量，去找到真正存储着_a的地址。

上述的代码中通过B类和C类去给_a赋值会用到这个偏移量：

	d.B::_a = 1; // 通过偏移量才能找到_a的地址
	d.C::_a = 2;

还有一个场景会用到这个偏移量：

那就是子类赋值给父类

B b;
D d;
b = d; // 子类拥有的父类成员，会被切片赋值过去，因为是虚继承，父类和子类的公共成员，又是同一个成员，因此就需要调用偏移量去找真正存储_a成员的地址

其实这个指针所指向的地方是一个顺序表一样的东西，叫做虚基表——虚基表存储的就是偏移量。

因为它是虚继承，并且要通过这个表去找基类，A类一般被叫做虚基类，找虚基类的表就叫做虚基表

B类和C类部分内的这两个指针也可以叫做虚基表指针

学习了虚拟继承到底做了什么事情，是怎么解决菱形继承带来的问题之后。

我们再回头看前面使用菱形虚拟继承的代码，就不会觉得奇怪了。

我们只需要在Student和Teacher类在继承Person类的时候，以**虚拟继承（virtual）**的方式去继承就可以解决问题。

// 菱形虚拟继承 解决 菱形继承的问题:数据冗余和二义性

class Person
{
public:
	string _name; // 姓名
};
class Student : virtual public Person // 虚拟继承Person,原本存储_name的地址，会变成存储虚基表指针
{
protected:
	int _num; //学号
};
class Teacher : virtual public Person // 虚拟继承Person
{
protected:
	int _id; // 职工编号
};

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

int main()
{
	// 菱形继承导致Assistant类的对象会继承了两个Person类的_name成员
	Assistant ass;
	// 采用菱形虚拟继承解决
	ass._name = "assisant";  // 此时ass中的所有_name成员指的都是同一个_name
	// Teacher 和 Student内的成员_name其实都是一个虚基表指针
	// 虚基表指针——指向虚基表——存着当前虚基表指针的地址距离真正存储_name成员的地址的偏移量
	// 用当前地址+偏移量就是真正存储_name成员的地址，这个地址不在父类模块里，而是单独开辟一个新的地址，在所有成员的最后面

	// 这里访问的三个_name实际上访问的都是一个_name
	ass.Student::_name = "Student._name"; // 先访问Student内的虚基表指针
	ass.Teacher::_name = "Teacher._name";  // 这句等效下面那句,都是访问Teacher内的虚基表指针
	ass.Teacher::Person::_name = "Person._name"; 

	// 上面四个所访问的_name都是同一个_name

	return 0;
}

菱形虚拟继承的关系图如下：

image-20240908162731687

8.继承的总结

  1. cpp的语法较复杂，多继承就是一个体现。多继承其实算是一个语法缺陷，有了多继承就会出现菱形继承，有了菱形继承就需要菱形虚拟继承来解决问题，有了菱形虚拟继承，那么其底层就很复杂。因此一般不建议设计出多继承或者是菱形继承。也正是因为这个原因，很多后来的语言都不存在多继承——比如java
  2. 继承和组合
  • 继承是is-a的关系。父类是子类的一部分

继承是一种白箱复用，父类的情况子类基本上是全部知晓。也基本都能访问，除了私有成员，但是子类也能知道父类有什么私有成员。因此继承对父类的封装性是有一定的破坏性的

  • 组合是has-a的关系。一个类是另一个类的一个成员

组合是你是我的成员，但是我并不知道你是什么情况，你只是我的一个成员而已
组合是一种黑箱复用，C类对于D类来说除了公共成员，都是不可知的。
因此组合对C类的封装性不会造成破坏。

  • 面试题：使用继承还是组合？

答：优先使用组合，而不是继承，如果场景需求是继承那就继承，比如车和车的品牌，不能说比亚迪有一个成员是车，而是比亚迪就是车。 轮子和车就用组合。如果都能用。那就是优先组合。

标准答案：

  1. 继承允许你根据基类的实现来定义派生类的实现。这种通过生成派生类的复用通常被称为白箱复用(white-box reuse)。术语“白箱”是相对可视性而言：在继承方式中，基类的内部细节对子类可见 。继承一定程度破坏了基类的封装，基类的改变，对派生类有很大的影响。派生类和基类间的依赖关系很强，耦合度高
  2. 对象组合是类继承之外的另一种复用选择。新的更复杂的功能可以通过组装或组合对象来获得。对象组合要求被组合的对象具有良好定义的接口。这种复用风格被称为黑箱复用(black-box reuse)，因为对象的内部细节是不可见的。对象只以“黑箱”的形式出现。组合类之间没有很强的依赖关系，耦合度低。优先使用对象组合有助于你保持每个类被封装。
  3. 实际尽量多去用组合。组合的耦合度低，代码维护性好。不过继承也有用武之地的，有些关系就适合继承那就用继承，另外要实现多态，也必须要继承。类之间的关系可以用继承，可以用组合，就用组合

9.学完继承要能知道

  1. 什么是菱形继承？菱形继承的问题是什么？

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

  3. 继承和组合的区别？什么时候用继承？什么时候用组合？

上面三个问题，面试出现概率较大

  1. 对隐藏/重定义要清晰。

  2. 子类的默认成员函数——各种调用的优先顺序

WZF-Sang
关注
专栏目录
C++进阶：继承
yourfriendyo的博客
04-14 4132
继承 面向对象的三大特性：封装、继承、多态。继承在实际中用的也不是太多，但必须能熟练使用。 1. 继承的概念 继承机制是面向对象思想中复用代码的一种手段，它能够在原有类的特性的基础上进行扩展。由此产生新的类，称为派生类，原有类称作基类。继承体现了面向对象设计的层次结构，体现了由简单到复杂的认知过程，不同于面向过程只有函数复用，继承是类的设计层面上的复用。 1.1 继承的定义 对于具有一定联系的一类群体，将其抽象成一类对象后，这些对象必然会具有重复的属性。 比如学校中有学生老师两种群体，他们都是属于人这个
【C++】从零开始认识继承
叫我龙翔的博客
04-27 2335
本文从零开始讲解了c++的继承特性
C++ 继承 2--继承的赋值
Paulliam的博客
04-12 738
#include &lt;iostream&gt;using namespace std;/*---------------------------------       公有派生的赋值问题---------------------------------*/class father{public: int x;};class son:public father{public: int y;};...
【C++】继承 —— 切片 | 隐藏 | 子类的默认成员函数 | 菱形继承
浮光掠影
04-21 2815
继承
C++继承详解——基类派生类对象赋值转换、菱形虚拟继承
bang___bang_的博客
05-15 2096
详细讲解C++特性——继承，派生类的默认构造函数（及派生类和基类的函数顺序），基类和派生类的赋值转换，继承的3个模型——单继承、多继承、菱形继承。并且讲解菱形继承的菱形虚拟继承（原理：虚基表存偏移量），最后对继承总结，并提出组合。
C++ 继承，子类与父类的一些特性
weixin_44601183的博客
07-11 1484
子类重定义父类的成员函数和重载父类的成员函数在函数名称、参数列表以及返回类型等方面存在区别。函数名称重载：在同一个类中，函数名相同。重定义：在子类中，与父类中函数名相同。参数列表重载：参数列表不同，即参数的个数或类型有所改变。重定义：参数列表可以不同，但如果完全相同且父类函数未声明为virtual，则基类的函数被隐藏。返回类型重载：返回类型可以相同也可以不同，但重载不依据返回类型来判断。重定义：若与父类原型完全一致（包括返回类型），则为重写；否则，只是简单地隐藏了父类方法。
C++基础：继承，子类继承父类有规范和要求
凯凯在此
06-25 2978
文章目录继承1. 语法2. 成员的访问权限3. 继承关系的构造顺序 继承 1. 语法 父类/子类 基类/派生类 class 派生类:public 基类 { 成员 } 三角形和等腰三角形 #include <iostream> #include <cmath> using namespace std; class Triangle{ int a,b,c; public: Triangle(int a,int b,int c):a(a)
C++＞继承，继承方式及其比较，子类和父类对象指针，派生类的默认成员函数，虚继承，继承与友元，继承与静态成员
qq_42069216的博客
07-24 1315
C++>继承，继承方式及其比较，子类和父类对象指针，派生类的默认成员函数，虚继承，继承与友元，继承与静态成员,赋值兼容
C++ 继承：父子类赋值转换、菱形继承、虚继承、继承与组合
林慢慢的博客
06-02 1502
C++ 继承：父子类赋值转换、菱形继承、虚继承、继承与组合
C++的继承与虚继承以及如何调用父类同名函数或成员变量
L_smartworld的博客
08-29 2636
基础知识： 理论看多了，发现不大会写代码，今天来做个总结，并把代码好好梳理一下。 1.类继承及调用父类同名函数或成员变量 所谓类继承就是子类继承了父类的方法和属性（当然有三种继承权限） #include <iostream> #include <string> #include <vector> #include <algorithm> using namespace std; class A{ public: voi...
cpp代码-C++：类02__多继承（子类对象可以转换成父类对象）
07-14
总的来说，C++中的多继承和子类到父类的转换是实现面向对象设计的重要工具。它们允许程序员创建复杂而灵活的类层次结构，以适应各种需求。然而，多继承也可能引入歧义和复杂性，如菱形问题（diamond problem），在...
C++（第十一篇）：继承（基类与派生类、菱形继承和菱形虚拟继承问题）
杨同学的博客
12-11 1144
面向对象程序设计中最重要的一个概念是继承。继承允许我们依据另一个类来定义一个类，这使得创建和维护一个应用程序变得更容易。这样做，也达到了重用代码功能和提高执行效率的效果。当创建一个类时，不需要重新编写新的数据成员和成员函数，只需指定新建的类去继承一个已有的类即可。这个已有的类称为基类（父类），新建的类称为派生类（子类）。很多人说 C++ 语法复杂，其实多继承就是一个体现。有了多继承，就存在菱形继承，有了菱形继承就有菱形虚拟继承，底层实现就很复杂。所以一般不建议设计出菱形继承。否则在复杂度及性能上都有问题。
【c++】继承的基础知识的详细讲解（作用域、默认函数、单继承、多继承...
小刘好好学习的博客
12-08 1139
c++继承的基础概念
STL set
hls0611的博客
11-09 285
练习题：P1059 [NOIP2006 普及组] 明明的随机数。
C++_用 using 语句继承基类的构造函数
学海无涯
11-09 290
**默认情况下**，派生类会继承基类的所有成员，包括数据成员和函数成员，但不会继承基类的**构造函数和析构函数**，因为构造函数和析构函数的作用是创建和销毁对象，派生类通常需要有自己的构造和析构的逻辑。C++11 引入了using语句，使得派生类可以通过 using 关键字使用基类的构造函数，更方便地复用基类的构造逻辑。
C++——智能指针
最新发布
Wangx_wang的博客
11-12 972
介绍了几种智能指针的不同和实现思路以及循环引用的问题
C++builder中的人工智能（15）：C++高斯误差线性单元（GELU）
caridle的专栏
11-08 739
激活函数（phi()），也称为转移函数或阈值函数，它根据净输入函数的给定值（sum）确定激活值（a = phi(sum)）。在这里，sum是它们权重中的信号之和，激活函数是这个和的新值，具有给定的函数或条件。换句话说，激活函数是将所有加权信号的和转换为该信号的新激活值的方法。有不同类型的激活函数，通常使用的是线性（恒等）、双极性和逻辑（sigmoid）函数。在C++（以及大多数编程语言）中，你可以创建自己的激活函数。注意，sum是净输入函数的结果，它计算所有加权信号的和。我们将使用这些作为输入函数的结果。
C++ 内存分布及 new , delete 分配问题( ~~~ 面试重要 ~~~)
GAOSHOUCYUYAN的博客
11-10 849
本篇文章笔者将会对 C++ 中的内存问题简单的讲解 , 同时对 new , delete 的面试题进行重点讲解.以上就是本篇的内容 , 希望读者认真领会.
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值