【浅尝C++】继承机制=＞虚基表/菱形虚继承/继承的概念、定义/基类与派生类对象赋值转换/派生类的默认成员函数等详解

最新推荐文章于 2024-07-25 18:43:45 发布
最新推荐文章于 2024-07-25 18:43:45 发布
阅读量1k 收藏 14
点赞数 14
分类专栏： 浅尝C++ 文章标签： c++ 开发语言 c语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_66926829/article/details/137406353
版权

在这里插入图片描述

🏠专栏介绍：浅尝C++专栏是用于记录C++语法基础、STL及内存剖析等。
🎯每日格言：每日努力一点点，技术变化看得见。

文章目录

继承的概念及定义

继承的概念

我们生活中也有继承的例子，例如：小明继承了孙老师傅做拉面的手艺。继承就是一种延续、复用的方式。C++为了提高代码的可复用性，引入了继承机制，概念如下↓↓↓

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

继承的定义

定义格式

下图演示的继承的格式，其中Person是父类，也称作基类；Student是子类，也称作派生类。
在这里插入图片描述

下面给出代码示例（下面代码中，Student类继承父类Person）↓↓↓

#include <iostream>
using namespace std;

class Person
{
public:
	void Show()
	{
		cout <<  _name << " " << _age << endl;
	}
protected:
	string _name = "jammingpro";	//姓名
	int _age = 18;					//年龄
};

class Student : public Person
{
private:
	int _stuId;
};

int main()
{
	Person p;
	Student s;
	p.Show();
	s.Show();
	return 0;
}

在这里插入图片描述
上面代码中，Student继承父类Person的成员（成员函数+成员变量）后，这些成员都变成了子类的一部分。这里的Student复用了Person的成员。通过监视窗口可以看到，Student中也有自己的_name、_age成员变量。
在这里插入图片描述

继承关系与访问限定符

在C++的继承机制中，包含3种继承方式及3种类访问限定符（如下图所示），下面将分别介绍它们。
在这里插入图片描述

我们在学习类和对象时，就已经接触过访问限定符。其中public成员可以在类外访问，而protected与private成员不能在类外访问。但这里的protected和private在继承时是有区别的：
●如果父类愿意让自己的成员被外界访问并愿意让子类继承，则定义为public的；
●如果父类希望自己的成员不被外界访问而愿意让子类继承，则需要定义为protected；
●如果父类不希望自己的成员被外界访问、被继承，则需要定义为private的。

在这里插入图片描述

父类中的访问限定符表示父类愿不愿意让子类继承，而继承方式则可以让子类缩小父类成员的访问权限，但不能放大父类成员的访问权限。

父类成员/子类继承方式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继承下来的成员都只能在派生类的类里面使用，实际中扩展维护性不强。

针对于总结中的第一点，父类private成员实际上还是被子类继承了，只是子类无法访问，下面使用代码验证↓↓↓

#include <iostream>
using namespace std;

class Base
{
private:
	int _base;
};

class Son : public Base
{}

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

在这里插入图片描述

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

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

在这里插入图片描述
下面给出代码示例↓↓↓

#include <iostream>
using namespace std;

class Person
{
public:
	Person()
	{}
	Person(const string& name, const char& sex, const int& age)
		:_name(name)
		,_sex(sex)
		,_age(age)
	{}
protected:
	string _name;
	char _sex;
	int _age;
};

class Student : public Person
{
public:
	Student(const string& name, const char& sex, const int& age, const int& stuId)
		:Person(name, sex, age)
		,_stuId(stuId)
	{}
private:
	int _stuId;
};

int main()
{
	Student s("Jammingpro", 'M', 18, 123456);
	Person p;
	p=s;
	return 0;
}

从监视窗口可以看到，Person对象保存了Student对象的父类成员部分，而舍弃了子类自有成员，这就是切片。
在这里插入图片描述

●基类对象不能赋值给派生类对象。（基类对象无法用于构造派生类对象，也无法使用派生类对象的拷贝赋值函数；但可以显示提供派生类赋值给基类的operator=实现）

★ps：由于派生类中的成员函数、成员对象一般情况下都会多于基类，如果基类直接赋值给派生类会导致部分成员数值不确定。因此，C++默认不提供基类赋值给派生类。

●基类的指针或者引用可以通过强制类型转换赋值给派生类的指针或者引用。但是必须是基类的指针指向派生类对象时才是安全的。

下面代码演示了基类赋值给派生类指针，派生类赋值给基类指针↓↓↓

#include <iostream>
using namespace std;

class Person
{
public:
	Person()
	{}
	Person(const string& name, const char& sex, const int& age)
		:_name(name)
		, _sex(sex)
		, _age(age)
	{}
	string _name;
	char _sex;
	int _age;
};

class Student : public Person
{
public:
	Student(const string& name, const char& sex, const int& age, const int& stuId)
		:Person(name, sex, age)
		, _stuId(stuId)
	{}
	int _stuId;
};

int main()
{
	Student s("Jammingpro", 'M', 18, 123456);
	Person p("xiaoming", 'M', 20);
	
	Person* p_s = &s;//安全
	Student* s_p = (Student*) & p;//不安全

	cout << s_p->_stuId << endl;

	return 0;
}

为什么说，Student* s_p = (Student*) & p;是不安全的呢？由于Person对象中没有申请_stuId的空间，但在Student*类型看来，它认为它指向的对象有_stuId成员。如果用户访问了s_p->_stuId可能会因为内存非法访问而报错。
在这里插入图片描述

继承中的作用域

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

下面给出派生类成员变量与基类成员变量同名的例子↓↓↓
下面代码中，由于Son类中的成员变量与Base类中的成员变量重名，构成了隐藏。如果使用Son s; cout << s._name << endl;，则只能访问到Son对象中的成员变量，而无法访问到父类中的_name成员变量。若需要访问父类的_name成员变量，则可以使用类型+类作用域符号::来访问，即s.Base::_name。

#include <iostream>
using namespace std;

class Base
{
public:
	string _name = "Jammingpro";
};

class Son : public Base
{
public:
	string _name = "xiaoming";
};

int main()
{
	Son s;
	cout << s._name << endl;
	cout << s.Base::_name << endl;
	return 0;
}

在这里插入图片描述
下面给出派生类成员函数与基类成员函数同名的例子↓↓↓这里与成员变量同名的情况相同，同名成员函数也会构成隐藏关系，如果需要访问父类的同名成员函数，需要使用类名+类作用域运算符::。

#include <iostream>
using namespace std;

class Base
{
public:
	void Show()
	{
		cout << "I am _Base" << endl;
	}
};

class Son : public Base
{
public:
	void Show()
	{
		cout << "I am _Son" << endl;
	}
};

int main()
{
	Son s;
	s.Show();
	s.Base::Show();
	return 0;
}

在这里插入图片描述
★( ఠൠఠ )ﾉtest：下面的两个同名函数（函数名相同，参数列表不同）分别属于基类和派生类，它们构成的关系是隐藏还是函数重载呢？

#include <iostream>
using namespace std;

class Base
{
public:
	void print(char ch)
	{
		cout << "Base->" << ch << endl;
	}
};

class Son : public Base
{
public:
	void print(int num)
	{
		cout << "Son->" << num << endl;
	}
};

int main()
{
	Son s;
	s.print('A');
	return 0;
}

在这里插入图片描述
Base中的成员函数比Son中的成员函数更匹配（不需要隐式类型转换），而这里还是调用Son中的成员函数，说明两者构成的关系是隐藏，而不是函数重载。这里要注意：在继承关系中，派生类与基类只要存在同名函数（不管参数列表、返回值是否相同），都是隐藏关系。

派生类的默认成员函数

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

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

基类提供默认构造函数的情况
派生类在构造时，会自动调用基类的构造函数↓↓↓

#include <iostream>
using namespace std;

class Base
{
public:
	Base()
	{
		cout << "Base() is called" << endl;
	}
};

class Son : public Base
{
public:
	Son()
	{
		cout << "Son() is called" << endl;
	}
};

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

在这里插入图片描述
基类没有提供默认构造函数的情况
基类没有提供默认构造时，子类必须在初始化参数列表中显示调用基类的构造函数，否则会报错。

#include <iostream>
using namespace std;

class Base
{
public:
	Base(int b)
		:_b(b)
	{
		cout << "Base(int b) is called" << endl;
	}
private:
	int _b
};

class Son : public Base
{
public:
	Son(int b)
		:Base(b)
	{
		cout << "Son() is called" << endl;
	}
};

int main()
{
	Son s(5);
	return 0;
}

在这里插入图片描述

  1. 派生类的拷贝构造函数必须调用基类的拷贝构造完成基类的拷贝初始化。
#include <iostream>
using namespace std;

class Base
{
public:
	Base(int b)
		:_b(b)
	{}
	Base(const Base& b)
	{
		_b = b._b;
		cout << "Base(const Base& b) is called" << endl;
	}
private:
	int _b;
};

class Son : public Base
{
public:
	Son(int s, int b)
		:_s(s)
		,Base(b)
	{}
	Son(const Son& s)
		:Base(s)
	{
		_s = s._s;
		cout << "Son(const Son& s) is called" << endl;
	}
private:
	int _s;
};

int main()
{
	Son s(55, 66);
	Son s2(s);
	return 0;
}

在这里插入图片描述
如果我们将上面代码中显示调用基类构造函数的代码去掉，则会出现如下报错↓↓↓
在这里插入图片描述
★ps：对于上面的报错，虽然可以通过给基类提供默认构造函数解决，但却无法完成子类中的基类成员的拷贝操作。

  1. 派生类的operator=可以调用基类的operator=完成基类的复制，这样可以避免代码冗余（这里派生类调用基类的operator=不是必须的，只是因为基类已经实现了该操作，派生类不必再重复编写相同内容）。

下面代码演示了派生类调用基类operator=函数带来的代码简化↓↓↓

#define _CRT_SECURE_NO_WARNINGS 1

#include <iostream>
#include <string>
#include <cstring>
using namespace std;

class Person
{
public:
	Person(const string& name, const int& age, const char& gender)
		:_name(name)
		,_age(age)
		,_gender(gender)
	{}
	Person& operator=(const Person& p)
	{
		_name = p._name;
		_age = p._age;
		_gender = p._gender;
		return *this;
	}
	void Show()
	{
		cout << "My name is " << _name << ", I am " << _age << " years old, I am a " 
		<< (_gender == 'M' ? " boy " : "girl") << endl;
	}
private:
	string _name;
	int _age;
	char _gender;
};

class Student : public Person
{
public:
	Student(const string& name, const int& age, const char& gender, const char* detail)
		:Person(name, age, gender)
	{
		_detail = new char[strlen(detail) + 1];
		strcpy(_detail, detail);
	}
	Student& operator=(const Student& s)
	{
		Person::operator=(s);
		char* detail = new char[strlen(s._detail)];
		return *this;
	}
	void Show()
	{
		Person::Show();
		cout << "My detail infomation is " << _detail << endl;
	}
	~Student()
	{
		delete[] _detail;
	}
private:
	char* _detail;
};

int main()
{
	Student s("Jammingpro", 18, 'M', "He is good at coding");
	Student copy = s;
	s.Show();
}

在这里插入图片描述

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

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

下面代码演示了基类与派生类的构造与析构顺序↓↓↓

#include <iostream>
using namespace std;

class Base
{
public:
	Base()
	{
		cout << "Base() is called" << endl;
	}
	~Base()
	{
		cout << "~Base() is deleted obj" << endl;
	}
};

class Son : public Base
{
public:
	Son()
	{
		cout << "Son is called" << endl;
	}
	~Son()
	{
		cout << "~Son() is deleted obj" << endl;
	}
};

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

在这里插入图片描述

  1. 编译器会对析构函数名进行特殊处理，处理成destrutor()，所以父类析构函数不加virtual的情况下，子类析构函数和父类析构函数构成隐藏关系。

★ps：关于virtual关键字将于多态中讲解

继承与友元

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

下面代码演示了友元关系无法继承↓↓↓

#include <iostream>
using namespace std;

class Base
{
	friend void print();
private:
	int _base = 88;
};

class Son : Base
{
private:
	int _son = 66;
};

void print()
{
	Base b;
	cout << b._base << endl;
	Son s;
	cout << s._son << endl;
}

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

在这里插入图片描述

继承与静态成员

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

#include <iostream>
using namespace std;

class Base
{
public:
	static int val;
};

//静态非const成员变量需要在类外初始化
int Base::val = 66;

class Son : public Base
{
};

class GrandSon : Son
{
};

int main()
{
	cout << &Base::val << endl;
	cout << &Son::val << endl;
	cout << &GrandSon::val << endl;
	return 0;
}

在这里插入图片描述

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

单继承：一个子类只有一个直接父类时称这个继承关系为单继承
在这里插入图片描述
下面是一份单继承的代码↓↓↓

#include <iostream>
using namespace std;

class Base
{
public:
	void base_func()
	{}
	int _base;
};

class Son : public Base
{
public:
	void son_func()
	{}
	int _son;
};

class GrandSon : public Son
{
public:
	void gs_func()
	{}
	int _gs;
};

int main()
{
	GrandSon gs;
	cout << &gs << endl;
	gs._base = 1;
	cout << &gs._base << endl;
	gs._son = 2;
	cout << &gs._son << endl;
	gs._gs = 3;
	cout << &gs._gs << endl;

	cout << "===================================" << endl;

	Son s;
	cout << &s << endl;
	s._base = 1;
	cout << &s._base << endl;
	s._son = 2;
	cout << &s._son << endl;

	return 0;
}

在这里插入图片描述

上述代码调试时，通过监视窗口查看结果如下图所示。我们可以发现，GrandSon对象保存了其祖先类Son、Base的成员变量。Son对象保存了其基类成员变量。
在这里插入图片描述
下图为GrandSon对象的存储情况↓↓↓
在这里插入图片描述
通过分析上面的执行结果，可以得出如下结论：再单继承中，某个类的成员变量放置于类空间最后，该成员变量前放置的是直接父类，再往上是爷爷类，以此类推。类对象的地址，与最顶层的祖先的成员变量地址相同。

多继承：一个子类有两个或以上直接父类时称这个继承关系为多继承
在这里插入图片描述
下面给出多继承的演示代码↓↓↓

#include <iostream>
using namespace std;

class Base1
{
public:
	void base1_func()
	{}
	int _base1;
};

class Base2
{
public:
	void base2_func()
	{}
	int _base2;
};

class Son : public Base1, public Base2
{
public:
	void son_func()
	{}
	int _son;
};

int main()
{
	Son s;
	cout << &s << endl;
	s._base1 = 1;
	cout << &s._base1 << endl;
	s._base2 = 2;
	cout << &s._base2 << endl;
	s._son = 3;
	cout << &s._son << endl;
	return 0;
}

在这里插入图片描述
如果Son先继承Base1再继承Base2，则会将Base1的成员变量放在前面，后继承的Base2的成员变量放在后面。
在这里插入图片描述
如果将Son先继承Base2，再继承Base1呢？
在这里插入图片描述

由上面的执行结果可知，先继承的基类的成员变量放置于类对象的前面位置，后即成的基类的成员变量放置于类对象的后面位置，类自身的成员变量放置于最后。

菱形继承：菱形继承是多继承的一种特殊情况
在这里插入图片描述
下面给出多继承的演示代码↓↓↓

#include <iostream>
using namespace std;

class Share
{
public:
	void share_func()
	{}
	int _share;
};

class Base1 : Share
{
public:
	void base1_func()
	{}
	int _base1;
};

class Base2 : Share
{
public:
	void base2_func()
	{}
	int _base2;
};

class Son : public Base1, public Base2
{
public:
	void son_func()
	{}
	int _son;
};

int main()
{
	Son s;
	s._base1 = 1;
	s._base2 = 2;
	s._son = 3;
	return 0;
}

在上述代码的监视窗口可以看出菱形继承有数据冗余和二义性的问题。s中继承了两份Share类的成员变量_share。
在这里插入图片描述
C++中为了避免菱形继承导致的数据冗余和二义性，它引入了虚拟继承。虚拟继承可以解决菱形继承的二义性和数据冗余的问题。下面给出修改后的代码（引入虚拟继承的代码）↓↓↓

#include <iostream>
using namespace std;

class Share
{
public:
	void share_func()
	{}
	int _share;
};

class Base1 : virtual public Share
{
public:
	void base1_func()
	{}
	int _base1;
};

class Base2 : virtual public Share
{
public:
	void base2_func()
	{}
	int _base2;
};

class Son : public Base1, public Base2
{
public:
	void son_func()
	{}
	int _son;
};

int main()
{
	Son s;
	cout << &s << endl;
	s._share = 0;
	cout << &s._share << endl;
	s._base1 = 1;
	cout << &s._base1 << endl;
	s._base2 = 2;
	cout << &s._base2 << endl;
	s._son = 3;
	cout << &s._son << endl;
	return 0;
}

在这里插入图片描述

在这里插入图片描述

这里是通过了两个指针，指向的一张表。这两个指针叫虚基表指针，这两个表叫虚基表。虚基表中存的偏移量。通过偏移量可以找到下面的Share。

🎈欢迎进入浅尝C++专栏，查看更多文章。
如果上述内容有任何问题，欢迎在下方留言区指正b(￣▽￣)d

Jammingpro
关注
  • 14
    点赞
  • 踩
  • 14
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
基于GPRS通信和uC/OS-II的网络电能表设计
08-07
GPRS通信模块则作为数据上传的关键，负责与基表和主站之间的可靠通信，遵循相应的通信协议标准。 硬件设计中，GPRS通信模块的系统框图包括ARM微处理器LPC2138、GPRS模块、FLASH和铁电存储器、红外收发、RS232串行...
c++继承中的内存布局
05-07
- 虚继承：虚基类的子对象只在最远的派生类中出现一次，以解决钻石继承问题。这需要一个虚基表（VBT，Virtual Base Table）来指示到达虚基类的路径。 2. **成员变量如何访问？** - 非虚成员可以直接通过对象指针...
C++继承详解——基类派生类对象赋值转换、菱形虚拟继承
bang___bang_的博客
05-15 1935
详细讲解C++特性——继承，派生类的默认构造函数（及派生类和基类的函数顺序），基类和派生类的赋值转换，继承的3个模型——单继承、多继承、菱形继承。并且讲解菱形继承的菱形虚拟继承（原理：虚基表存偏移量），最后对继承总结，并提出组合。
【C++】解决菱形继承而产生的虚基表（偏移量表）
Front123456的博客
07-27 257
菱形继承对象模型，菱形虚拟继承对象模型，虚基表分析，为什么存偏移量而不直接存地址？
C++ 继承：父子类赋值转换、菱形继承、虚继承、继承与组合
林慢慢的博客
06-02 1264
C++ 继承：父子类赋值转换、菱形继承、虚继承、继承与组合
c++对象模型05：虚继承内存布局
effort_study的博客
08-07 3155
虚继承 虚继承解决了菱形继承中最派生类拥有多个间接父类实例的情况。虚继承的派生类的内存布局与普通继承很多不同，主要体现在： 虚继承的派生类，如果定义了新的虚函数，则编译器为其生成一个虚函数指针（vptr）以及一张虚函数表。该vptr位于对象内存最前面。（非虚继承时，派生类新的虚函数直接扩展在基类虚函数表的下面。） 虚继承的派生类有单独的虚函数表，基类也有单独的虚函数表，两部分之间用一个四个字节的0x00000000来作为分界。 虚继承的派生类对象中，含有四字节的虚基表指针。 在C++对象模型中，虚继承而
C++必修：深入理解继承与虚继承
Bettysweetyaaa的博客
07-04 1651
欢迎来到我们的C++继承博客，深入探讨继承的精髓与实战技巧。从基础概念到高级应用，解锁面向对象编程的新视角。无论您是初学者还是专家，这里都有适合您的内容，助您在C++的世界中腾飞！
C++多继承，菱形继承，虚继承 ，虚基表和虚基表指针
Misszhoudandan的博客
05-04 1294
多继承 当一个子类只有一个直接父类时，称这个继承关系为单继承 当一个子类有两个或两个以上的直接父类时，称这个继承关系为多继承 当存在多继承时，就有可能形成这样一种继承关系 我们称上面的继承关系为菱形继承，来看看菱形继承如何实现   class Person { public:  Person(const string name = "") :_name(name)   {...
【c++继承、菱形继承、基类派生类对象转换、虚继承等】
Willing_hope的博客
08-16 319
一、继承的概念和定义 1、继承的概念 继承是实现代码可复用性的重要方法，在保留原类的特征基础上做一些扩展，形成新的类，叫做派生类。 一个例子： 父亲有一套房子，儿子长大了，父子两人共同拥有这套房。但是经过儿子的奋斗，自己又买了一套房，此时儿子可以说是拥有两套房，一套与父亲共享，一套完全属于自己。就像派生类一样，既有父类的东西，又有自己的东西。 2、继承的定义 （1）定义格式 class Student : public Person { public: int _stuid;
C++ 多重继承与虚基类
偶然i的博客
04-23 913
技术交流qq：1032492413 技术交流VX:Chamfion
C++_继承(菱形继承与虚基表)
qq_45928272的博客
05-08 569
什么是继承 继承是什么： 继承是面向对象程序设计、使得代码可以复用的重要手段，它允许程序员在保持原有特性的基础上进行扩展，增加功能，这样产生的新类，称之为派生类 继承的目的： 让子类继承和复用父类定义的成员和方法、继承下来的变量是独立的、各自拥有各自的内存空间。 继承方式和访问限定符 可见在派生类中，子类的访问方式是，MIN(继承方式,基类访问方式) 实际基类的private成员在派生类不可见，只是语法上无法访问，假如你调用基类的方法还是可以用的。 但是调用继承的方法可以用 使用关键字c
面向对象C++用虚继承来消灭菱形结构二义性,解决俩爷爷的问题.zip
01-22
总结来说，C++中的虚继承是一种解决多继承菱形结构问题的策略，它通过确保共享基类的单一实例来消除二义性。理解虚继承的原理和使用场景对于编写清晰、无冲突的面向对象代码至关重要。通过阅读《C++通过虚继承来消灭...
嵌入式系统/ARM技术中的基于GPRS通信和uC/OS-ii的网络电能表设计
11-02
GPRS通信模块则负责数据的可靠上传，遵循DT/L645通信协议和Q/GDW 376.1-2009标准，确保与基表和主站之间的通信。 在硬件设计上，GPRS通信模块的核心是ARM微处理器LPC2138，内含丰富的外设资源，如定时器、ADC、DAC...
（mysql面试题）MySQL中的视图的概念及其作用及代码展示.txt
08-18
2. 提高数据安全性：视图可以限制用户访问数据的权限，只允许用户访问视图中定义的数据，而不是直接访问基表，从而提高数据的安全性。 3. 隐藏数据的复杂性：视图可以将复杂的数据结构简化，隐藏底层数据的复杂性，...
2024年C++面试题汇总及答案解析
最新发布
soaring_casia的专栏
07-25 347
唯一的指针，不允许其他指针与他共享指向的对象。比如指针指向的内存被释放了，但是指针没有置nullptr. 多个指针指向同一个内存，当free掉一个指针之后，其他指针就变成了野指针。C++这些年虽然难度大，但是热度仍然不减，在编程排行榜基本上都是前几位，得益于它良好的薪资待遇。SPI协议是一种采用主从模式的串行，全双工，同步通信总线，包括时钟，输入，输出，片选四个信号线，片选信号用于选择slave设备，输入输出的每个bit都需要和时钟沿同步。区别：指针指向一块儿内存，他的内容是所指内存的地址。
C语言 之 理解指针（1）
fallzzzzz的博客
07-20 1159
就是先获取该数组的首元素的地址，从前面我们知道，指针的类型的作用是指针+1 所跳过的字节数，int为整形，大小为4个字节，所以p+1就跳过4个字节，p+2就跳过8个字节，计算机的CPU（中央处理器）在处理数据的时候，需要的数据是在内存中读取的，处理后数据也会放回内存中，如果想对这些空间进行高效的管理，就可以。并且我们知道，数组的元素存放是随着下标增长，内存地址变大的。上面的代码创建了一个整型变量n，因为一个整形的大小是4个字节，所以内存中申请了4个字节，⽤于存放整数10，其中每个字节都有地址。
Delphi5实现鱼C屏幕保护程序
weixin_52116519的博客
07-24 326
使用Form1的events的oncreate事件，双击命名为FormCreate。即上面的“- □ ×”不显示。
C++中的模板函数和模板类
2302_81171591的博客
07-22 666
T1 ,classT2 ,... ,classTnclass类模板名//类内成员定义。
c++继承多态虚基表
07-29
C++中的继承和多态是面向对象编程的重要特性之一。在C++中，虚函数和虚基类是实现多态的关键。 首先，让我们来了解一下继承的概念。继承是一种从已有类创建新类的机制，其中新类可以继承已有类的属性和方法。在C++...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值