c++继承(万字详解)画图+原理解说

最新推荐文章于 2024-03-07 16:53:24 发布
最新推荐文章于 2024-03-07 16:53:24 发布
阅读量888 收藏 24
点赞数 20
分类专栏： c++ 文章标签： c++ 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_64076540/article/details/134583306
版权
本文介绍了面向对象编程中继承的原理，涉及不同访问权限的继承、构造函数与析构函数的调用规则，以及菱形继承和虚拟继承的解决方案。
摘要由CSDN通过智能技术生成

继承的概念和定义

  1. 继承的概念

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

  1. 继承使用，实例代码
class Person
{
public:
	void print()
	{
		cout << "name:" << _name << endl;
		cout << "age:" << _age << endl;
	}
protected:
	//c++11的补丁
	string _name = "peter";
	int _age = 18;
};

class Student : public Person
{
protected:
	int _stuid; //学号
};

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

int main()
{
	//Student 和 Teacher中都没有Print函数，但是他们继承了Person类，所以也可以调用，相当于有了
	Student s;
	Teacher t;
	s.print();
	t.print();

	return 0;
}
  1. 继承的定义
    在这里插入图片描述
  2. 继承关系和访问限定符
    在这里插入图片描述
    从这里可以看出，共有3*3 = 9种组合方式。那么，这些方式有什么区别呢？
类成员/继承方式public 继承protected继承private继承
基类的public成员派生类的public成员派生类的protected成员派生类的private成员
基类的protected成员派生类的protected成员派生类的protected成员派生类的private成员
基类的private成员派生类中不可见派生类中不可见派生类中不可见

总结：

  1. 基类private成员在派生类中无论以什么方式继承都是不可见的。这里的不可见是指基类的私有成员还是被继承到了派生类对象中，但是语法上限制派生类对象不管在类里面还是类外面都不能去访问它。
  2. 基类private成员在派生类中是不能被访问，如果基类成员不想在类外直接被访问，但需要在派生类中能访问，就定义protected。可以看出保护成员限定符是因继承才出现的。
  3. 实际上面的表格我们进行一下总结会发现，基类的私有成员在子类都是不可见。基类的其他
    成员在子类的访问方式 == Min(成员在基类的访问限定符，继承方式)，public > protected
    private。
  4. 使用关键字class时默认的继承方式是private，使用struct时默认的继承方式是public，不过最好显示的写出继承方式。
  5. 在实际运用中一般使用都是public继承，几乎很少使用protetced/private继承，也不提倡使用protetced/private继承，因为protetced/private继承下来的成员都只能在派生类的类里面使用，实际中扩展维护性不强。

代码示例演示：

  1. 继承方式为public，访问限定符为public在这里插入图片描述
  2. 继承方式是public,基类成员有protected和private
    在这里插入图片描述
    这里涉及到一个问题：当基类成员是protected的时候，派生类该如何访问？

在这里插入图片描述
当基类成员是protected的时候，派生类该如何修改？

在这里插入图片描述

  1. 继承方式是public，访问限定符是private
    在这里插入图片描述

  2. 继承方式是public,访问限定符是protected
    因为访问限定符是protected，就代表，最多只支持在派生类中访问，不支持在类外访问。
    这也证明了上面的总结，最后的权限由继承方式和访问限定符中小的那个决定。
    在这里插入图片描述
    如果一直用public继承和public的权限，就不会有那么多麻烦了，最多还会用到protected,private很少用到。

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

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

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

  3. 基类的指针/基类的引用可以通过强制类型转换赋值给派生类的指针/派生类的引用。

演示代码1：

class Person
{
protected:
	string _name;
	int _age;
	string _sex;
};

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

int main()
{
	Student s;
	//1.子类的对象可以赋值给基类的对象/引用/指针
	Person p = s;
	Person& rp = s;
	Person* pp = &s;

	//2.基类对象不能赋值给子类的对象
	//s = p;

	//3.基类的指针可以通过强制类型转换赋值给子类的指针
	pp = &s; //pp是基类的指针，但是派生类赋值给pp了
	Student* ps1 = (Student*)pp; // 强制类型转换了
	ps1->_No = 10;

	pp = &p;  //pp是基类的指针，指向自己
	Student* ps2 = (Student*)pp;      //这种情况虽然可以，但是会存在越界访问
	//ps2->_No = 20;

	return 0;
}

演示代码2：

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

	string _name = "zhangsan";
	string _sex = "男";
	int _age = 18;
};

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

int main()
{
	Student s;
	Person p;
	p.print();
	cout << "///" << endl;

	s._name = "lisi";
	Person* pp = &s;  //赋值给基类的指针
	pp->print();
	cout << "///" << endl;

	s._age = 90;
	Person& rp = s;  //赋值给基类的引用 
	rp.print();

	return 0;
}

运行结果：
在这里插入图片描述

继承中的作用域

  1. 在继承体系中基类和派生类都有独立的作用域。
  2. 子类和父类中有同名成员，子类成员将屏蔽父类对同名成员的直接访问，这种情况叫隐藏，也叫重定义。（在子类成员函数中，可以使用 基类::基类成员 显示访问）
  3. 需要注意的是如果是成员函数的隐藏，只需要函数名相同就构成隐藏。
  4. 注意在实际中在继承体系里面最好不要定义同名的成员。

构成隐藏的条件:

  1. 在不同的作用域
  2. 函数名/成员名相同

隐藏和重载的区别是:函数重载需要在同一个作用域,函数重载是相同的函数名,不同的参数列表和返回值,而隐藏只需要函数名相同即可.

  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:
    // 这里Student中的_num和Person中的_num构成隐藏
	int _num = 999; // 学号
};
void Test()
{
	Student s1;
	s1.Print();

};

int main()
{
	Test();

	return 0;

在这里插入图片描述
2. 函数名相同构成的隐藏

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

int main()
{
	Test();

	return 0;
}

在这里插入图片描述

派生类的默认成员函数

构造函数

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

什么是默认构造函数?

  1. 无参的
  2. 全缺省的
  3. 我们不写,编译器默认生成的

第一个版本,有默认构造函数的时候,派生类该怎么写构造函数?

class Person
{
public:
	//构造函数 -->  默认构造函数
	Person(const char* name = "peter")
		: _name(name)
	{
		cout << "Person()" << _name << endl;
	}

	string _name;
};

class Student : public Person
{
public:
	//这里Person存在默认构造，所以Student写构造函数的时候就可以不显式调用
	Student(int num = 19)
		:_num(num)
	{
		cout << "Student()" << _name << endl;
	}

	void print()
	{
		cout << _name << " " << _num << endl;
	}

	int _num;
};

int main()
{
	//这里的声明，因为Student的的构造函数有缺省值，是默认构造
	//所以可以直接写Student s,这样就会调用缺省值
	//但是不能写Student("张三", 19);因为根本没有传_name进去，所以不能这样初始化
	//Student s(19);这样的初始化形式是可以的，因为传了_num进去
	Student s;
	s._name = "张三";
	s.print();
	return 0;
}

运行结果:
在这里插入图片描述

在这里插入图片描述
第二个版本,没有默认构造的时候,派生类该怎么写构造函数?

错误的写法:
在这里插入图片描述
正确的写法:

class Person
{
public:
	//构造函数 -->  不是默认构造函数
	Person(const char* name)
		: _name(name)
	{
		cout << "Person()" << _name << endl;
	}

	string _name;
};

class Student : public Person
{
public:
	//这里Person没有默认构造，所以Student写构造函数的时候就必须显式调用
	Student(const char* name, int num = 19)
		:Person(name)
		,_num(num)
	{
		cout << "Student()" << _name << endl;
	}

	int _num;
};

int main()
{
	//这里之所以可以传"张三"和"19"，是因为Student的构造函数中传了name和num
	Student s("张三", 19);
}

运行结果:
在这里插入图片描述
从两次的运行结果可以看出,无论是否有默认构造函数,无论是否显式调用,最后调用派生类的时候,都是先调用父类的构造函数再调用派生类的构造函数

满足一下好奇心:基类有默认构造函数,派生类可以不显式写,但是派生类非要写呢?会报错吗?
不会

拷贝构造函数

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

class Person
{
public:
	Person(const char* name = "zahngsan")
	{}

	Person(const Person& p)
		:_name(p._name)
	{
		cout << "Person的拷贝构造函数" << endl;
	}

	string _name;
};

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

	//调用父类的拷贝构造函数，直接传对象， 通过“切片”拿到父类的那一部分
	Student(const Student& s)
		:Person(s)
		,_num(s._num)
	{
		cout << "Student的拷贝构造函数" << endl;
	}

	int _num;
};

int main()
{
	Student s("zhangsan", 19);
	//调用拷贝构造
	Student s1(s);

	return 0;
}

运行结果:
在这里插入图片描述
上述那样写是为了代码能跑起来,更直观的是:
在这里插入图片描述

赋值运算符重载

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

代码:

class Person
{
public:
	Person(const char* name = "zahngsan")
	{}

	Person(const Person& p)
		:_name(p._name)
	{}

	//返回的*this,所以返回类型是Person&
	Person& operator=(const Person& p)
	{
		//s != *this是错误的写法，没有这样的比较方法
		if (&p != this)
		{
			cout << "Person的operator=函数" << endl;
			_name = p._name;
		}

		return *this;
	}

	string _name;
};

class Student : public Person
{
public:
	Student(const char* name = "peter", int num = 12)
	{}

	//调用父类的拷贝构造函数，直接传对象， 通过“切片”拿到父类的那一部分
	Student(const Student& s)
		:Person(s)
		,_num(s._num)
	{}

	Student& operator=(const Student& s)
	{
		if (&s != this)
		{
			//注意这里必须使用域作用限定符，如果不用的话，operator=是一个隐藏
			//在Student作用域里，会优先调用自己作用域的函数，所以会无穷递归
			//也就是说,写成operator=(s)是错误的
			Person::operator=(s);

			_num = s._num;

			cout << "Studnet的operator=函数" << endl;
		}

		return *this;
	}

	int _num;
};

int main()
{
	Student s("zhangsan", 19);
	Student s1;

	//调用赋值重载函数
	s1 = s;
	return 0;
}

注意:上述的代码是为了能跑起来,更直观的代码如下:
在这里插入图片描述

析构函数

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

class Person
{
public:
	Person(const char* name = "zahngsan")
	{}

	~Person()
	{
		cout << "Person的析构函数" << endl;
	}
	string _name;
};

class Student : public Person
{
public:
	Student(const char* name = "peter", int num = 12)
	{}

	//在派生类中不要显式写基类的析构函数，
	//因为编译器要先调用基类的析构函数再调用派生类的析构函数
	//因为构造函数先调用派生类的再调用基类的
	~Student()
	{
		cout << "Student的析构函数" << endl;
	}

	int _num;
};

int main()
{
	Student s;

	return 0;
}

运行结果:
在这里插入图片描述
注意:在派生类的析构函数中,不要自己调用,有两个原因:

  1. 由于多态的一些原因，编译器会对析构函数名进行特殊处理，处理成destructor()，所以父类的析构函数在不加virtual的情况下，会和子类的析构函数构成隐藏关系。所以如果要自己调用，必须用域作用限定符，Person :: ~Person()
  2. 由于栈的特性，构造函数调用时先调父类再调子类，所以析构时先析构子类，再析构父类，编译器为了能保证这个特性，默认在子类析构完成后调用父类的析构函数，所以不需要在子类的析构函数中显式地调用父类的析构函数。

所以，我们在子类的析构函数中显式调用析构函数会造成父类析构两次的情况。

总结：
在这里插入图片描述

继承与友元

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

继承与静态成员

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

//这段代码的意思是：Person::_count为4，然后赋值Student::_count = 0, 
//如果不是静态成员，那么最后输出Person::_count应该还是4,但是最后输出为0,
// 意味着Person中的_count和Student中的_count是同一个_count

class Person
{
public:
	Person() { ++_count; }
protected:
	string _name; // 姓名
public:
	static int _count; // 统计人的个数。
};

int Person::_count = 0;

class Student : public Person
{
protected:
	int _stuNum; // 学号
};

class Graduate : public Student
{
protected:
 string _seminarCourse; // 研究科目
};

void TestPerson()
{
	Student s1;
	Student s2;
	Student s3;
	Graduate s4;
	cout << " 人数 :" << Person::_count << endl;
	Student::_count = 0;
	cout << " 人数 :" << Person::_count << endl;
}

int main()
{
	TestPerson();

	return 0;
}

运行结果：
在这里插入图片描述
如果为非静态成员，会发生什么？
在这里插入图片描述

菱形继承与菱形虚拟继承

单继承：一个子类只有一个直接父类时称这个继承关系为单继承
在这里插入图片描述
多继承：一个子类有两个或以上直接父类时称这个继承关系为多继承
在这里插入图片描述

菱形继承：：菱形继承是多继承的一种特殊情况。
在这里插入图片描述

菱形继承的问题

在这里插入图片描述
从上面这张图可以看出来，菱形继承具有数据冗余和二义性的问题。在Assistant的对象中Person成员会有两份。

二义性的问题好解决，只需要手动的指定类域就行了。

class Person
{
public:
	string _name;
};

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

class Teacher : public Person
{
protected:
	int _id;
};

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

int main()
{
	Assistant as;
	//会有二义性，定义不明确
	//as._name = "li ming";

	//指定才不会有二义性的问题，但是代码冗余的问题并没有解决
	as.Student::_name = "zhangsan";
	as.Teacher::_name = "lisi";

	return 0;
}

虚继承可以解决这两个问题

虚继承

//虚拟继承只能写在腰部的位置
//Student继承Person    Teacher继承Person
//Assistant继承Student和Teacher 
//这种情况下，在Student继承Person和Teacher继承Person的时候写virtual，这就是腰部的位置

class Person
{
public:
	string _name;
};

class Student : virtual public Person
{
protected:
	int _num;
};

class Teacher : virtual public Person
{
protected:
	int _id;
};

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

int main()
{
	Assistant as;
	//虚继承之后，不会有二义性
	as._name = "li ming";
	return 0;
}

虚继承只能写在腰部的位置
在这里插入图片描述

简化模型观察虚继承

这是有虚继承的代码

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;

	return 0;
}

上述代码是使用了虚继承的代码，不存在数据冗余和二义性的问题。

下面的图是没有使用虚继承的代码的内存图，存在数据冗余和二义性的问题。
在这里插入图片描述
下图是菱形虚拟继承的内存对象成员模型：这里可以分析出D对象中将A放到的了对象组成的最下面，这个A同时属于B和C，那么B和C如何去找到公共的A呢？

这里是通过了B和C的两个指针，指向的一张表。这两个指针叫虚基表指针，这两个表叫虚基表。虚基表中存的偏移量。通过偏移量可以找到下面的A。
在这里插入图片描述
总结：菱形继承绝对是一个大坑，非常麻烦，所以，为了解决这个问题，最好的办法就是，不用菱形继承。

gaogo12
关注
专栏目录
C++：定义类的+=，+，及++运算符
风静如云的博客
05-26 4210
如果打算为自定义的类，比如： class A 定义+=运算符及+运算符，虽然两个运算符的功能比较接近，但是在定义上的区别还是很大的： +=运算符，需要定义为A的成员函数，返回值类型为A& +运算符，需要定义为A的非成员函数，返回值为const A，且通过成员函数版的+=实现 #include <iostream> using namespace std; class A{ public: A(int a):d(a){} A& operator +=(const
C++ 类继承图 所有类关系
03-17
C++ MSDN的类总图，显示了所有类 之间的关系 非常有用！~~
【C++从入门到入土】第五篇：继承（爆肝画图详解）
qq_52145272的博客
08-26 1946
系列文章目录 【C++从入门到入土】第一篇：从C到C++. 【C++从入门到入土】第二篇：类和对象基础. 【C++从入门到入土】第三篇：类和对象提高. 【C++从入门到入土】第四篇：运算符重载. 提示：写完文章后，目录可以自动生成，如何生成可参考右边的帮助文档 文章目录系列文章目录前言一、继承是什么？继承的基本语法继承方式二、继承中的对象模型三、继承中构造和析构顺序四、继承同名成员处理方式五、继承同名静态成员处理方式六、多继承语法总结 前言 接下来让我们一起来学习面向对象三大特性之一——继承，它重要
c++继承图解
准备的永远在准备，迈出下一步，也许你能走的很远
06-25 525
什么是继承： 子类获得父类的特性的概念即称为继承继承图解
C++类继承内存布局详解图（一目了然）
07-24
看了这个内存布局图详解之后，对于C++的了解更加深刻了，之前不懂得一头雾水的东西全都清楚了。
一个C++类继承的例子-图形
weixin_34247299的博客
01-24 313
本文是我做家教时的题目，希望没有版权问题。这是一个简单的C++类继承的例子，继承关系为图形->三角形->左（右）三角形，图形->矩形->正方形，里面还包括填充图形等类，同时展示了多态性。 注意，本程序需要用支持C++11的编译器编译，如VS2013，DEV C++等 1、主程序 //prog.cpp #include "shapes.hpp" using na...
C++入门基础(万字总结）（建议收藏！！！）
热门推荐
IamGreeHand的博客
09-22 26万+
文章目录什么是C++C++的发展史C++关键字命名空间命名空间的定义1.命名空间的普通定义2.命名空间可以嵌套3. 同一个工程中允许存在多个相同名称的命名空间,编译器最后会合成同一个命名空间中。命名空间使用1.加命名空间名称及作用域限定符2.使用using namespace 命名空间名称引入3.使用using将命名空间中的成员引入C++中的输入和输出缺省参数全缺省半缺省参数函数重载函数重载的原理extern “C”引用引用的特征1.引用在定义时必须初始化2.一个变量可以有多个引用3.引用一旦引用了一个实体
C++多重继承及多态性原理实例详解
08-18
主要介绍了C++多重继承及多态性原理实例详解,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
C++继承详解
博客记录学习轨迹，方便日后复习
09-03 3553
在现实生活中我们会遇到不同身份的人具有相同属性，比如说在一个学校的管理系统中，我们有教师身份、学生身份等等，他们各自都有如下的属性：我们可以发现，教师和学生除了入职年限和入学年限这一属性不同，其他的姓名、年龄、性别属性是相同的，于是我们可以把不同身份的相同属性提取出来，成为一个公共的属性。在C++中引入了继承的概念，将不同类的相同属性提取出来成为一个独立的公共类，其他类只需要继承这个公共类就可以使用共同的属性。
Visual C++游戏开发经典案例详解.pdf
03-01
《Visual C++游戏开发经典案例详解》这本书是针对使用Visual C++进行游戏开发的专业指南，旨在帮助读者通过实例学习和掌握C++编程语言在游戏开发中的应用。书中的内容覆盖了从基础到高级的游戏开发技术，包括图形...
C++ 图解单继承&多继承&菱形继承
askunix
11-15 670
一：重点概念 1> 继承概念 继承是面向对象的重要特征。继承一方面使基类和派生类之间建立逻辑上的层次关系，另一方面使一个派生类获得其基类的属性和行为。 2> 继承作用 3> 继承权限 如果不写继承方式，则默认为私有继承。 二：继单继承&多继承&菱形继承 1> 一个子类只有一个直接父类时称这个继承关系为单继承。 2> 一个子类有两个或以
C++编程——继承
professor_tao的博客
04-25 4305
文章目录1. 继承的基本语法2. 继承方式 继承的知识点结构： 继承是面向对象三大特性之一，例如动物类下可以有猫类、狗类。显然猫类、狗类都具有动物类的属性，于此同时，也就有自己独特的属性。这个时候，猫类、狗类就是继承于动物类，采用继承的技术，可以减少重复的代码。 1. 继承的基本语法 语法：class 子类：继承方式 基类 继承示例： 一般网页都有很多部分相似的，我们可以将这些相似的部分抽象出来，作为一个基类。然后子类只需要继承基类，在基类的基础上添加自身其他的属性或者方法就可以实现基本的功能，同时减少
生成C++工程的UML类图和类继承关系图
百鸣的专栏
05-04 4286
在进行软件开发时，了解代码结构和关系、类之间的继承关系以及类内部的成员函数和变量定义是非常重要的。为此，我们可以使用Doxygen和Graphviz工具来生成UML类图和类集成关系图。Doxygen是一个用于从注释的C++源代码中生成文档的工具，支持多种编程语言，包括C，Objective-C，C#，PHP，Java，Python等。而Graphviz则是一款开源的图形可视化软件，用于生成各种类型的图形。我们可以将这两款工具结合起来使用，生成C++工程的UML类图和类集成关系图。
一张图让你看懂C++中类的组合与继承
最新发布
WenJieya的博客
03-07 414
@TOC一张图让你看懂C++中类的组合与继承
C++知识总结（内附超详细知识框架图）
2021dragon的博客
10-04 5万+
由于在学习C++的同时博主也在学习Linux系统编程、Linux网络编程以及数据库，所以从开始学习C++到现在结束已经有一年多时间了。C++是博主学习的第一个面向对象的语言，在学习过程中也是逐渐体会到了面向对象编程的种种好处，但C++相比C语言来说其语法会更加复杂，特别是继承和多态的语法(ಥ _ ಥ)，以及C++11中新增的很多特性，让C++的语法变得更加复杂。下面博主将各大模块的思维导图罗列出来了，并在每张思维导图下面放上了博主的相关博客，对某一知识点有疑问的博友可以跳转阅读对应的博客。
C++软件调试与异常排查从入门到精通系列文章汇总
dvlinker的技术专栏
06-29 19万+
根据近几年排查软件异常的实践与经验，系统地讲解了C++软件异常常见原因与常用排查方法，以图文并茂的方式给出具体的分析实例，带领大家逐步掌握C++软件异常排查的相关技术与要领。
C与C++中++i和i++的区别
superhoner的博客
03-03 5190
C与C++中++i和i++的区别 文章目录C与C++中++i和i++的区别前言一、C++中区别二、C中区别 前言 i++和++i很明显的区别就是：++i是先对i进行加一操作然后再返回i的值，而i++是先返回i的值再对i进行加一操作。 int main() { int i = 1, j = 1; cout << "i++:" << i++ << endl; cout << "++j:" << ++j << en
C++三种继承方式对比图
看看世界看看你
09-04 242
C++ ---- 继承
小张的博客
06-07 1498
本文主要介绍继承的相关知识，如继承相关的面试题，继承的概念及定义。基类和派生类的赋值转换。继承中的作用域，派生类的默认成员函数特点。继承与友元，继承与静态成员函数。单继承，多继承，菱形虚拟继承以及菱形虚拟继承带来的二义性问题，什么是虚继承，虚继承的原理，虚基表的概念。继承和组合的比较等。
C++继承和多态核心重点知识刨析，一文必拿下
小杰312的博客
03-02 3493
C++继承和多态核心重点知识刨析，思考着学习
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值