C++——继承

已于 2024-04-25 17:26:43 修改
阅读量804 收藏 9
点赞数 11
文章标签： c++ 开发语言 数据结构 c语言
于 2024-04-08 12:21:10 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_74795859/article/details/137432816
版权

继承的概念和定义

继承的概念 

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

简单地举个例子，比如图书馆或者大学刷脸进出校园，人固有的相同属性:名字 年龄 电话号码 住址等。

如果要分别定义不同类去存储共有特征，是不是太浪费空间了，在大学教师和学生区别 顶多是学号和教职工号的区别。

最快成为富二代的办法是什么？是继承他爸爸的财产，是最轻松、最容易的，因此这种方法叫继承

在国外父类也叫基类 子类叫做派生类。

class Person
{
public:
	void print()
	{
		cout << _name << _age<< endl;
	}


protected:
	string _name="张麻子";姓名
	int _age = 30;年龄
};


class Student :public Person
{

protected:
	int _stuNum;学号
};


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

int main()
{
	Student s;
	s.print();

	Teacher t;
	t.print();

	return 0;
}

Student实际有三个成员变量 一个是自己独有的学号和从父类继承来的名字和年龄，而且也有成员函数(从父类继承来的)，同理Teacher这个类也是一样的。

通过调试方式和运行结果，更能直观感到继承的魅力。

 继承的定义

定义格式

 继承关系和访问限定符

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

类成员/继承方式public继承protected继承private继承
基类的public成员

派生类的public成员

派生类的protected成员

派生类private成员

基类的protected成员派生类的public成员派生类的protected成员派生类private成员
基类的private成员在派生类中不可见在派生类中不可见在派生类中不可见

 总结 ：

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

什么意思呢？看代码说话

class Person
{
public:
	void print()
	{
		cout << _name << _age<< endl;
	}


//protected:
private:
	string _name="张麻子";//姓名
	int _age = 30;//年龄
};


class Student :public Person
{
public:
	void f()
	{
		cout << _name << _age << endl;
	}
protected:
	int _stuNum;//学号
};
int main()
{
	Student s;
	s.print();

	

	return 0;
}

会报错，因为父类的成员变量变成了私有，子类在自己类中访问不了。

相当于你要买房子，首付要50w，你爸爸立马给了40w，剩下的10w，让你自己去想办法。

但子类可以间接去访问父类的私有成员变量

这又是为什么呢？因为你发现爸爸除了正常工资还有一部分隐藏花销，供着两大爱好:抽烟和钓鱼，是什么支撑这两大情怀呢？当然money的魔力了，你发现爸爸还有私房钱，但他只会供自己的爱好去消费，但突然有一天，你说你也想去钓鱼，那么他会帮你准备好鱼竿、鱼饵，还有上好的烟。

class Person
{
public:
	void print()
	{
		cout << _name << _age<< endl;
	}


//protected:
private:
	string _name="张麻子";//姓名
	int _age = 30;//年龄
};


class Student :public Person
{
public:
	/*void f()
	{
		cout << _name << _age << endl;
	}*/
protected:
	int _stuNum;//学号
};
int main()
{
	Student s;
	s.print();

	

	return 0;
}

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

如果想在子类可以访问和使用就用protected或者public即可

class Person
{
public:
	void print()
	{
		cout << _name << _age<< endl;
	}


protected:
//private:
	string _name="张麻子";//姓名
	int _age = 30;//年龄
};


class Student :public Person
{
public:
	void f()
	{
		cout << _name <<" "<< _age << endl;
	}
protected:
	int _stuNum;//学号
};
int main()
{
	Student s;
	s.print();
	s.f();
	

	return 0;
}

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

class Person
{
public:
	void print()
	{
		cout << _name << _age<< endl;
	}


protected:
//private:
	string _name="张麻子";//姓名
	int _age = 30;//年龄
};


class Student :protected Person
{
public:
	void f()
	{
		cout << _name <<" "<< _age << endl;
	}
protected:
	int _stuNum;//学号
};

int main()
{
	Student s;
	s.print();
	
	

	return 0;
}

因为父类的成员是protected Student类的继承方式是protected  两个protected相遇是protected

父类的公有部分遇子类的继承是protected  public>protected 变protected 所以在类外访问不了。

为什么teacher可以在类外访问呢？

protected遇见public 变protected   public遇public还是public 所以Teacher可以在类外访问。

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

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

 一般都是父类成员 公有/保护  子类继承 用公有继承

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

这样为什么会报错呢？因为在int到double的隐式类型转换中，会产生一个临时变量，临时变量具有常属性，而直接引用相当于权限的放大，为了编译时候语法不报错，要在double前面加上const，形成权限的平移。

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

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

class Person
{
public:
	void print()
	{
		cout << _name << endl;
	}

protected:
	string _name;
private:
	int _age;
};
class Student :public Person
{

protected:
	int _stuNum;
};
int main()
{
	Student s;
	Person p = s;
    是子类继承父类 切割父类那一部分的引用
	Person& pp = s;
    指针指向的是子类继承父类的那一部分
	Person* ptr = &s;

    s = p;//error
	return 0;
}

但要注意的是，在派生类把父类切割的那部分赋值过去时，无论是赋值还是引用、指针都不会产生临时变量，是直接赋值过去，中间没有其他特殊情况。

切割或切片 子类->父类  

赋值兼容转换 相当于语法特殊处理 中间转换没有产生临时变量。

继承中的作用域

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

你觉得打印函数会打印出输的_id?是父类还是子类？

class Person
{
public:
	void print()
	{
		cout <<_name << endl;
	}


protected:
	string _name;
	int _id = 24;
};

class Student :public Person
{
public:
	void print()
	{
		cout << _id << endl;
	}

protected:
	int _stuNum;
	int _id = 12;
};
int main()
{
	Student s;
	s.print();
	
	return 0;
}

优先打印子类_id 就近原则 

打印的是子类的_id，这表明了父类和子类各种有独立的作用域。

那怎么打印父类的_id呢？前面加个父类名+域作用限定符就可以了。 

class Person
{
public:
	void print()
	{
		cout <<_name << endl;
	}


protected:
	string _name;
	int _id = 24;
};

class Student :public Person
{
public:
	void print()
	{
		cout << _id << endl;
		cout << Person::_id << endl;
	}

protected:
	int _stuNum;
	int _id = 12;
};
int main()
{
	Student s;
	s.print();
	
	return 0;
}

隐藏关系

class A
{
public:
	void fun()
	{
		cout << "func()" << endl;
	}
};
class B : public A
{
public:
	void fun(int i)
	{
		
		cout << "func(int i)->" << i << endl;
	}
};
int main()
{
	B b;
	b.fun();
	
	return 0;
}

这里为什么会报错呢？因为子类和父类如果存在同名成员函数，那么父类的同名函数就会被隐藏，编译器只能看到子类的同名成员函数，所以只能传参使用。

注意只要是成员函数名相同即可，返回值和参数可以不相同。 

class A
{
public:
	void fun()
	{
		cout << "func()" << endl;
	}
};
class B : public A
{
public:
	void fun(int i)
	{
		
		cout << "func(int i)->" << i << endl;
	}
};
int main()
{
	B b;
	//b.fun();//被隐藏
	b.fun(5);
	b.A::fun();

	return 0;
}

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

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

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

派生类的默认成员函数

其实跟之前学过的类和对象类似，也有构造 析构 拷贝...那么这些函数在基类与派生类之间的关系又是怎么样的呢？让我用代码来解释下。

class Person
{
public:
	Person(const char*name="张麻子")
		:_name(name)
	{
		cout << " Person(const char*name)" << endl;
	}
	Person(const Person& p)
		:_name(p._name)
	{
		cout << "Person(const char& p) " << endl;
	}
	Person& operator=(const Person& pp)
	{
		if (this != &pp)
		{
			_name = pp._name;
		}
		cout << " Person& operator=(const Person& pp)" << endl;

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


class Student :public Person
{
protected:
	int _stuNum;
};

int main()
{
	Student s;
	Student s1(s);
	
	s1 = s;
	return 0;
}

当派生类没有自己写的构造 拷贝等等函数时，它会自动去调用默认生成的函数(基类的函数)，很合理吧，因为他是他儿子，使用爸爸的钱很合情合理。

那么为什么拷贝构造和赋值重载的参数是const Person&p 和&pp呢，前面讲过了，赋值还是引用、指针，都是派生类继承父类那一部分的切割 因此作为函数参数很合理。

那么如果子类想自己写这些默认成员函数该怎么写呢？

子类构造函数

class Student :public Person
{
public:
	Student(const char*name,int num)
		:_name(name)
		,_stuNum(num)
	{}
protected:
	int _stuNum;
};

int main()
{
	Student s;
	
	return 0;
}

但是报错了，这是为什么呢?因为父类的构造函数被隐藏了，那怎么解决呢？你们可能会说前面不是说加上域作用限定符就行了吗？但这里不只是那么简单，加上父类+域作用限定符不能解决这个问题，甚至我们去掉这个_name构造都能编译通过。

为什么Student实例化时_name给的是张三，但在调试时为什么_name是张麻子呢？因为我们在父类构造函数时，_name给的参数是缺省参数，如果去掉父类的缺省参数就会报错。

class Person
{
public:
	//Person(const char*name="张麻子")
	Person(const char* name)
		:_name(name)
	{
		cout << " Person(const char*name)" << endl;
	}
	Person(const Person& p)
		:_name(p._name)
	{
		cout << "Person(const char& p) " << endl;
	}
	Person& operator=(const Person& pp)
	{
		if (this != &pp)
		{
			_name = pp._name;
		}
		cout << " Person& operator=(const Person& pp)" << endl;

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


class Student :public Person
{
public:
	Student(const char*name,int num)
		//:_name(name)
		:_stuNum(num)
	{}
protected:
	int _stuNum;
};

int main()
{
	Student s("张三",20);
	
	return 0;
}

那么怎么解决这个问题呢？最好的方法就是显示调用父类。

class Person
{
public:
	//Person(const char*name="张麻子")
	Person(const char* name)
		:_name(name)
	{
		cout << " Person(const char*name)" << endl;
	}
	Person(const Person& p)
		:_name(p._name)
	{
		cout << "Person(const char& p) " << endl;
	}
	Person& operator=(const Person& pp)
	{
		if (this != &pp)
		{
			_name = pp._name;
		}
		cout << " Person& operator=(const Person& pp)" << endl;

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


class Student :public Person
{
public:
	Student(const char*name,int num)
		//:_name(name)
		:_stuNum(num)
		//显示调用父类
		,Person(name)
	{}
protected:
	int _stuNum;
};

int main()
{
	Student s("张三",20);
	
	return 0;
}

 但在调试时发现，无论初始化顺序怎么写，都是先初始化父类，再初始化子类

初始化父类->子类 

相当于先声明先初始化，因为Student继承是Person 相当于声明 就先初始化父类咯。

一般情况下使用父类的拷贝构造就可以，如果Student想自己深拷贝该怎么写呢？

这里有个问题就是怎么把person里面student继承的那部分调出来呢？

前面讲过&s就是student继承person切割出来的那部分 所以&s就是person里面的_name

子类深拷贝构造

class Person
{
public:
	//Person(const char*name="张麻子")
	Person(const char* name)
		:_name(name)
	{
		cout << " Person(const char*name)" << endl;
	}
	Person(const Person& p)
		:_name(p._name)
	{
		cout << "Person(const char& p) " << endl;
	}
	Person& operator=(const Person& pp)
	{
		if (this != &pp)
		{
			_name = pp._name;
		}
		cout << " Person& operator=(const Person& pp)" << endl;

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


class Student :public Person
{
public:
	Student(const char*name,int num)
		//:_name(name)
		:_stuNum(num)
		//显示调用父类
		,Person(name)
	{
		cout << " Student(const char*name,int num)" << endl;
	}
	//深拷贝构造
	Student(const Student& s)
		:Person(s)
		,_stuNum(s._stuNum)
	{
		cout << " Student(const Student& s)" << endl;
	}
protected:
	int _stuNum;
};

int main()
{
	Student s("张三",20);
	
	Student s1(s);

	return 0;
}

子类的赋值运算符重载

运行时可以运行，但程序结束时返回的代码为负数，就说明有问题，那么到底出了什么问题？

 因为派生类和基类的函数名相同，构成了基类函数隐藏，调用不到基类的赋值。所以赋值函数一直在派生类调用自己的赋值，为了解决这个问题，要声明基类的类名+域作用限定符即可。

子类的析构函数

为什么报错了呢？因为又再次的构成了隐藏，子类和父类的析构构成了隐藏。

由于后面多态的原因，析构函数被特殊处理，后面函数名都会被处理成destruction()。

为什么父类析构了两次？

而屏蔽掉之后就刚刚好？

因为为了先析构子类再析构父类，一般都是先析构子类，编译器再自动去调用父类的析构，与构造相反。

为什么要先析构子类再析构父类呢？

因为如果先析构父类再去析构子类，会存在安全隐患。

例如 父类是指针 先析构了父 释放了那段空间 指针变成了野指针，后面子类需要去访问父类数据时 去访问的空间就变成了野指针，可能父类资源已经释放处理了 ，子类析构函数去访问 存在野指针等安全风险。

在类和对象中 默认生成构造函数中 对内置类型不处理 自定义类型去调用它的默认构造

在派生类中也适用: 派生类去调用基类的构造函数。

总结：派生类默认成员函数规则，其实跟之前类似，唯一不同的是，不管是构造初始化/拷贝/析构，多了父类那一部分，原则：父类那部分调用父类的对应函数完成。

继承和友元

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

相当于你爸爸的朋友并不是你的朋友。

class Student;
class Person
{
public:

	friend void reveal(const Person& p, const Student& s);
protected:
	string _name;
};

class Student :public Person
{
protected:
	int _age;
};

void reveal(const Person& p, const Student& s)
{
	cout <<	p._name << endl;
	cout << s._age << endl;
}
int main()
{
	Person p;
	
	Student s;
	
	return 0;
}

友元函数相当于爸爸的朋友，如果你想认识爸爸的朋友，就得爸爸的引荐。

class Student;
class Person
{
public:

	friend void reveal(const Person& p, const Student& s);
protected:
	string _name;
};

class Student :public Person
{
public:
	friend void reveal(const Person& p, const Student& s);
protected:
	int _age;
};

void reveal(const Person& p, const Student& s)
{
	cout <<	p._name << endl;
	cout << s._age << endl;
}
int main()
{
	Person p;
	
	Student s;
	
	return 0;
}

继承和静态成员

基类定义了static静态成员，则整个继承体系里面只有一个这样的成员。无论派生出多少个子类，都只有一个static成员实例。 因为static静态变量在静态区(全局变量，程序结束才销毁)。

class Person
{
public:
	Person()
	{
		++_count;
	}

protected:
	string _name;
public:
	static int _count;
};
int Person::_count = 0;

class Student :public Person
{
protected:
	int _stuNum;
};
int main()
{
	Person p;
	Student s;
	cout << p.Person::_count << endl;
	cout << s.Person::_count << endl;
	return 0;
}

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

单继承

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

多继承

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

菱形继承

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

class Person
{
public:
	string _name;
};

class Student :public Person
{


protected:
	int _stuNum;
};

class Teacher :public Person
{

protected:
	int _jobid;
};

class Assistant :public Student, public Teacher
{

protected:
	int _majorCourse;
};
int main()
{
	Assistant as;
	as._name="张麻子";
	return 0;
}

报错了，为什么呢？因为存在二义性。

菱形继承会有数据冗余和二义性，因为里面有两份Person_name)(浪费空间)，当指定_name时就会存在二义性，不知道应该指向student还是teacher(访问不明确)。 

解决办法：就是类名+域作用限定符

这样写确实解决了二义性问题，但数据冗余还没有得到解决，属于是捡了芝麻丢了西瓜。

最好的办法就是在继承方式面前加virtual，变成虚继承。

class Person
{


public:
	string _name;
};

class Student :virtual public Person
{


protected:
	int _stuNum;
};

class Teacher :virtual public Person
{

protected:
	int _jobid;
};

class Assistant :public Student, public Teacher
{

protected:
	int _majorCourse;
};
int main()
{
	Assistant as;
	//as._name="张麻子";
	as.Student::_name = "张麻子";
	as.Teacher::_name = "鹅城";
	return 0;
}

不是所有继承类加上virtual，是直接继承父类的子类 子类的继承方式前面才加virtual。 

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

 

虚拟继承原理

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

先来看正常的菱形继承(无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 dd;
	dd.B::_a = 1;
	dd.C::_a = 2;
	dd._b = 3;
	dd._c = 4;
	dd._d = 5;

	return 0;

}

加上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 dd;
	dd.B::_a = 1;
	dd.C::_a = 2;
	dd._b = 3;
	dd._c = 4;
	dd._d = 5;

	return 0;

}

 

虚继承的内存窗口，大家有没有发现什么猫腻？

首先因为虚继承的缘故，不会出现数据冗余，因此1和2是在同一个内存地址存储的，第二个就是B和C有一段内存非常相似，因为VS2019的内存存储是小端存储，因此B的内存地址应该0x007f7bdc

C的内存地址是0x007f7be4

这个A同时属于B和C，那么B和C如何去找到公共的A呢？这里是通过了B和C的两个指针，指 向的一张表。这两个指针0x007f7bdc 0x007f7be4 叫虚基表指针，这两个表叫虚基表。虚基表中存的偏移量。通过偏移量 可以找到下面的A。

内存存储是16进制,C——14    D——12

0x003DF73C + 14 =0x003DF750 刚好是A的位置 B->A

0X003DF744 + 12 = 0x003DF750 又刚好是A的位置  C->A 

里面存的是偏移量，B到A的偏移量，C到A的偏移量 

什么时候会用到这个偏移量呢？

在切割对象时就可以通过偏移量去找到A，因为虚继承的缘故，B对象或者C对象并没有直接存A

而是把A放到一个公共区域，pb对象可能会指向B对象或者D对象的切割。

运行时，通过偏移量区找A的数据，pb->c pb->d 都可以找到A。

再比如结构体访问数据时，对象中多个成员的存储顺序是按照声明顺序确定。

比如结构体中有3个不同类型数据，p->a,p->b,p->c，通过对象顺序和内存对齐规则，在编译时计算好内存位置，进行访问。

大多数代码是编译时就计算好了内存的位置的偏移量。只有虚继承才在运行时去偏移量区找数据。

因此我们不要去写菱形虚拟继承，我们把握不住！要进过不断地看书学习，才能有能力把握菱形虚拟继承。

我们经常使用的i/o(输入和输出)流也是菱形虚拟继承。

Recipe.
关注
C++.继承——虚继承
xiaoyu1381的博客
10-18 2130
C++.继承——虚继承
C++——继承（超详细）
sqm_C的博客
07-04 1927
看了上面的案例，我们大概知道了继承的概念，那么我们接下来就来看看继承的定义：下面我们看到Person是父类，也称作基类。Student是子类，也称作派生类。由上图，我们发现继承方式好像跟访问限定符一样也是三种，那是不是就有九种情况呢？那我们如何分辨呢?总结：1. 基类private成员在派生类中无论以什么方式继承都是不可见的。这里的不可见是指基类的私有成员还是被继承到了派生类对象中，但是语法上限制派生类对象不管在类里面还是类外面都不能去访问它。
C++——继承和多态
weixin_57133901的博客
03-07 2434
多态： 多态按字面的意思就是多种形态。当类之间存在层次结构，并且类之间是通过继承关联时，就会用到多态。 C++ 多态意味着调用成员函数时，会根据调用函数的对象的类型来执行不同的函数。 多态性是面向对象程序设计的关键技术之一。若程序设计语言不支持多态性，不能称为面向对象的语言。利用多态性技术，可以调用同一个函数名的函数，实现完全不同的功能。 1.1两种多态： 1.1.1编译时多态（早绑定）： 编译时的多态通过函数的重载和运算符的重载来实现的。 就像是未出生的男女孩定下的娃娃亲。 1.1.2运行时多态（晚绑定）
用人话讲C++——继承（5）
yjnlovepy的博客
06-17 624
用人话讲C++——继承（5）
c++——私有继承
afootball的博客
11-05 4284
私有继承：使用私有继承，基类的公有成员和保护成员都将成为派生类的私有成员，只可以在派生类的成员函数中使用 一、私有继承示例 class Student : private std::string,private std::valarray<double> { public: ... } //student以私有继承的方式继承了string类和valarray类 //stduent是多重继承（使用多个基类的继承被称为多重继承） 示例student类 class Student { privat
C++编程——继承
professor_tao的博客
04-25 4294
文章目录1. 继承的基本语法2. 继承方式 继承的知识点结构： 继承是面向对象三大特性之一，例如动物类下可以有猫类、狗类。显然猫类、狗类都具有动物类的属性，于此同时，也就有自己独特的属性。这个时候，猫类、狗类就是继承于动物类，采用继承的技术，可以减少重复的代码。 1. 继承的基本语法 语法：class 子类：继承方式 基类 继承示例： 一般网页都有很多部分相似的，我们可以将这些相似的部分抽象出来，作为一个基类。然后子类只需要继承基类，在基类的基础上添加自身其他的属性或者方法就可以实现基本的功能，同时减少
C++——三种继承方式
JAN6055的博客
01-25 1911
三种继承方法
C++核心——继承
wtzhu_13的博客
03-28 1518
C++核心——继承 继承其实最简单的理解就是一种代码复用，之前语句复用的时候，我们利用函数实现代码复用，继承就是在类的基础上实现代码的复用，就是把几个类共有的部分提取出来，实现复用，简化代码结构。当然这是对继承最简单的一种理解，继承还有很多其他的用途。 继承的基本语法 首先在没用继承的时候我们定义两个类，汽车和飞机，有共同的属性名称，共同的行为就是运输，但是飞机可以飞，汽车可以倒车（当然现在有的飞...
C++语法——详解虚继承
热门推荐
weixin_61857742的博客
10-23 2万+
一.什么是虚继承所谓虚继承（virtual）就是子类中只有一份间接父类的数据。该技术用于解决多继承中的父类为非虚基类时出现的数据冗余问题，即菱形继承问题。，那么，当我们用D实例化对象调用a时，编译会报错，因为发生了混淆。除非指定类域B或C。当然指定A也可以，因为默认会从第一个父类中找。此时，D的实例化对象内部结构如下：而当我们使用虚继承时，结构是下图这样，D中只有一份父类A，当我们调用A中数据时，并不会发生冗余。
详解C++基础——类继承
12-31
好吧，本系列博客已经变成了《C++ Primer Plus》的读书笔记，尴尬。在使用C语言时，多通过添加库函数的方式实现代码重用，但有一个弊端就是原来写好的代码并不完全适用于现在的情况。OOP设计思想中类的继承相比来说...
详解C++基础——类继承中方法重载
08-26
C++ 基础知识点 —— 类继承中方法重载 在 C++ 编程语言中，类继承是指在已有的类基础上创建新的类，新类继承了原来类的成员变量和成员函数。然而，在继承的过程中，我们需要注意到方法重载的概念。方法重载...
c++——继承类中的子对象和基类对象的初始化
snail
09-16 4256
为什么研究临时对象？ 主要是为了提高程序的性能以及效率，因为临时对象的构造与析构对系统开销也是不小的，所以我们应该去了解它们，知道它们如何造成，从而尽可能去避免它们。临时对象是可以被编译器感知的。 下面的例子，可能有人认为"int temp"是"临时对象"，但是其实不然，"int temp"仅仅是swap函数的局部变量。 #include void swap( int &a,
C++——封装、继承、多态
。
02-10 4153
封装、继承、多态
C++ 模板专题 - 静态分支(if)
GPU全栈博主-程序哥
10-31 255
模板元编程（Template Metaprogramming，简称 TMP）是一种在 C++ 中使用模板进行编程的技术，它允许在编译时执行计算、生成代码，提供类似脚本语言的功能。TMP 常用于生成高效的代码，避免运行时的计算开销。在高性能编程、类型处理、泛型编程等领域，模板元编程非常有用。模板元编程的一个使用场景就是进行编译器条件分支判断，称为“静态 if”。它允许我们在模板中根据条件编译选择不同的代码分支，而不需要实例化不符合条件的代码，这不仅可以提升编译性能，也可以简化模板代码逻辑。
【C语言】预处理(预编译)详解(下)（C语言最终篇）
hdxbufcbjuhg的博客
10-29 2379
在编译⼀个程序的时候我们如果要将⼀条语句（⼀组语句）编译或者放弃编译，就可以使用条件编译，比如调试性的代码删掉很浪费，保留又很碍事，我们就可以使用条件编译，在编译的时候不编译这些调试性的代码在这里我们就可以使用一个技巧，在最开头使用#define定义一个符号，如果我们没有注释或者删除这个符号，那么我们就可以编译里面的调试性代码，进行正常调试，如果我们注释或者删除这个符号，那么我们就不编译里面的调试性代码，不影响代码的正常运行。
第八天: C语言深度探索：指针与函数的奥秘
qq_57484399的博客
10-31 597
通过今天的学习，我们了解了字符指针和字符串在C语言中的处理方式。希望大家能够掌握这些基本概念，并在实际编程中灵活运用。好了，今天的课就到这里。希望大家能够掌握指针与函数参数的关系，以及如何通过指针来改变外部变量的值。如果有任何问题，或者想要更多的练习题，随时告诉我。下课！好了，今天的课就到这里。希望大家能够掌握数组名作为函数参数的用法，以及如何通过函数来处理数组。如果有任何问题，或者想要更多的练习题，随时告诉我。下课！好了，今天的课就到这里。
C++之指针和引用
最新发布
weixin_42300449的博客
11-04 176
在C++中，指针和引用是两种不同的机制，它们都可以用来间接访问变量。
力扣——另一个的子树（C语言）
2401_83456040的博客
10-30 201
原理：这里调用前面比较两颗树是否相同的函数（小编之前文章里面有：相同的树），将节点与subRoot传入函数，向下递归，左右节点，只要找到一个返回true，说明存在子树，即最后返回true。具有相同结构和节点值的子树。的某个节点和这个节点的所有后代节点。也可以看做它自身的一棵子树。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值