菱形继承，虚继承，STL

已于 2022-09-10 15:21:35 修改
阅读量3k 收藏 2
点赞数 5
分类专栏： c++笔记 文章标签： udp http tcp/ip
于 2022-03-29 15:54:28 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_45510561/article/details/123805070
版权

文章目录

C++的4个子集

C子集
class子集
STL
template模板
//函数重载参数的类型或者个数不同,在C11里面也可以根据你的作之和右值来判断
void fun(int& a)//左值引用
{
	cout << "fun(int & a)" << endl;
}
void fun(const int& a)//万能引用不管你是左值还是右值
{
	cout << "fun(const int &a)" << endl;
}
void fun(int&& a)//右值引用
{
	cout << "fun(int && a)" << endl;
}
int main()
{
	int a = 10;
	const int b = 20;
	const int& x = b;
	const int& y = 20;
	fun(x);
	fun(y);
	fun(10);
	return 0;
}

在这里插入图片描述
void fun(const int& a)//常引用不管你是左值还是右值都以引用

//函数重载参数的类型或者个数不同,在C11里面也可以根据你的作之和右值来判断
void fun(int& a)//左值引用
{
	cout << "fun(int & a)" << endl;
}
void fun(const int& a)//万能引用不管你是左值还是右值
{
	cout << "fun(const int &a)" << endl;
}
//void fun(int&& a)//右值引用
//{
//	cout << "fun(int && a)" << endl;
//}
int main()
{
	int a = 10;
	const int b = 20;
	const int& x = b;
	const int& y = 20;
	fun(x);
	fun(y);
	fun(10);//首先找右值引用，其次是找常引用函数
	return 0;
}

在这里插入图片描述

void fun(int& a)//左值引用
{
	cout << "fun(int & a)" << endl;
}
void fun(const int& a)//万能引用不管你是左值还是右值
{
	cout << "fun(const int &a)" << endl;
}
void fun(int&& a)//右值引用
{
	cout << "fun(int && a)" << endl;
}
template<class T>
void fac(T&& a)//右值一旦拥有名字将变为左值
{
	fun(a);
}
int main()
{
	int a = 10;
	const int b = 20;
	fac(a);
	fac(b);
	fac(20);
	return 0;
}

在这里插入图片描述

完美转发 std::forward(a)

系统为了避免上述的右值引用的情况产生了新的概念完美转发

void fun(int& a)//左值引用
{
	cout << "fun(int & a)" << endl;
}
void fun(const int& a)//万能引用不管你是左值还是右值
{
	cout << "fun(const int &a)" << endl;
}
void fun(int&& a)//右值引用
{
	cout << "fun(int && a)" << endl;
}
template<class T>
void fac(T&& a)//右值一旦拥有名字将变为左值
{
	//fun(a);
	fun(std::forward<T>(a));
}
int main()
{
	int a = 10;
	const int b = 20;
	fac(a);
	fac(b);
	fac(20);
	return 0;
}

在这里插入图片描述

template<class T>
class Object
{
	T value;
public:
	Object(T x = T()) :value(x) {}
	static int num;
};
template<class T>
int Object<T>::num = 0;
class Base :public Object<int>
{
public: Base() { num += 1; }
	  void Print()const { cout << "Base" << num<<endl; }
};
class Test :public Object<int>
{
public:
	Test() { num += 1; }
	void Print()const { cout << "Test" << num << endl; }
};
int main()
{
	Base b1, b2;
	Test t1, t2;
	b1.Print();
	t1.Print();
	return 0;
}

在这里插入图片描述

template<class T>
class Object
{
	T value;
public:
	Object(T x = T()) :value(x) {}
	static int num;
};
template<class T>
int Object<T>::num = 0;
class Base :public Object<int>
{
public: Base() { num += 1; }
	  void Print()const { cout << "Base" << num<<endl; }
};
class Test :public Object<double>
{
public:
	Test() { num += 1; }
	void Print()const { cout << "Test" << num << endl; }
};
int main()
{
	Base b1, b2;
	Test t1, t2;
	b1.Print();
	t1.Print();
	return 0;
}

在这里插入图片描述

菱形继承

菱形继承的概念：

两个不同的派生类继承于同一个父类，又有一个子类多继承于这个两个派生类。 数据冗余导致的不一致性

class Person
{
private:
	string p_id;
	string p_name;
	string p_sex;
	int p_age;
public:
	Person(const string& id, const string& name, const string& sex, int age)
		:p_id(id), p_name(name), p_sex(sex), p_age(age)
	{}
	void print()const
	{
		cout << "id:   " << p_id << endl;
		cout << "name: " << p_name << endl;
		cout << "sex:  " << p_sex << endl;
		cout << "age:  " << p_age << endl;
	}
};
class Student :public Person
{
private:
	string s_id;
public:
	Student(const string& id, const string& name, const string& sex, int age, const string& d)
		:Person(id, name, "男", age), s_id(d)
	{}
};
class Staff :public Person
{
private:
	string s_id;
public:
	Staff(const string& id, const string& name, const string& sex, int age, const string& d)
		:Person(id, name, "女", age), s_id(d)
	{}
};
class Stud_Staff :public Student, public Staff
{
private:
public:
	Stud_Staff(const string& id, const string& name, int age, const string& dd, const string ss)
		:Student(id,name,"男",age,ss),Staff(id,name,"nv",age,dd)
	{

	}
};
int main()
{

	Stud_Staff ss("610431199900000000", "王伟", 23, "20200", "303030");
	ss.Student::print();
	ss.Staff::print();
	Student s1 = ss;
	Staff s2 = ss;
	//Person p = ss;erro因为此类里面有两个人//数据冗余导致的不一致性
	return 0;
}

在这里插入图片描述
在这里插入图片描述

虚继承

虚继承定义：

在继承体结构下，将其成员数据实例共享给也从这个基类型直接或间接派生的其它类。

虚继承就是为了解决菱形继承的缺陷
基类A B虚继承A,C虚继承A D公有继承B,C这时可以再D里面直接继承A里面的属性，避免BC二义性
解决上述多重继承导致的数据冗余下使用虚继承可以有效的使得D即Stud_Staff 直接从A即Person那里继承；注意一旦这样，如果通过D调用B和C里面的成员方法但凡涉及到A的成员，B和C里面分别会与一个指针分别指向新的A（D中构建的一个）
注意若BC不虚继承A,D这里不能直接继承,因为：不允许使用间接非虚拟机类

class Person
{
private:
	string p_id;
	string p_name;
	string p_sex;
	int p_age;
public:
	Person(const string& id, const string& name, const string& sex, int age)
		:p_id(id), p_name(name), p_sex(sex), p_age(age)
	{}
	void print()const
	{
		cout << "id:   " << p_id << endl;
		cout << "name: " << p_name << endl;
		cout << "sex:  " << p_sex << endl;
		cout << "age:  " << p_age << endl;
	}
};
class Student : virtual public Person
{
private:
	string s_id;
public:
	Student(const string& id, const string& name, const string& sex, int age, const string& d)
		:Person(id, name, "男", age), s_id(d)
	{}
};
class Staff :virtual public Person
{
private:
	string s_id;
public:
	Staff(const string& id, const string& name, const string& sex, int age, const string& d)
		:Person(id, name, "女", age), s_id(d)
	{}
};
class Stud_Staff :public Student, public Staff
{
private:
	int num = 10;
public:
	Stud_Staff(const string& id, const string& name, int age, const string& dd, const string ss)
		:Student(id,name,"男",age,ss),Staff(id,name,"女",age,dd)
	,Person("61010","yhping","男",23)
	{
	}
};
int main()
{

	Stud_Staff ss("610431199900000000", "王伟", 23, "20200", "303030");
	ss.Student::print();
	ss.Staff::print();
	Student s1 = ss;
	Staff s2 = ss;
	Person p = ss;
	return 0;
}

在这里插入图片描述

class Object
{
	int value;
public:
	Object(int x = 10) :value(x) {}
 };
class Base :virtual public Object
{
	int num;
public:
	Base(int x = 0) :num(x), Object(x + 10) {}
};
class Test :virtual public Object
{
	int sum;
public:
	Test(int x = 0) :sum(x), Object(x + 10) {}
};
class Det :public Base, public Test
{
private:
	int total;
public:
	Det(int x = 0) :total(x), Base(x + 10), Test(x + 20), Object(x + 100) {}
};
int main()
{
	Det d(0);
	return 0;
}

这样一旦通过D来调用B和C里面的公有方法涉及到A的部分就会完全由新产生的Object去代替B和C里面有指针直接指向新的Object
在这里插入图片描述

菱形继承的多继承

class Object
{
	int value;
public:
	Object(int x = 10) :value(x) {}
	virtual void fun() { cout << "Object" << endl; }
	virtual void add() { cout << "Object::add" << endl; }
 };
class Base :public Object
{
	int num;
public:
	Base(int x = 0) :num(x), Object(x + 10) {}
	virtual void fun() { cout << "Base" << endl; }
};
class Test : public Object
{
	int sum;
public:
	Test(int x = 0) :sum(x), Object(x + 10) {}
	virtual void fun() { cout << "Test" << endl; }
	 void add() { cout << "Test::add" << endl; }
};
class Det :public Base, public Test
{
private:
	int total;
public:
	Det(int x = 0) :total(x), Base(x + 10), Test(x + 20) {}
	 void fun() { cout << "Det" << endl; }
	void add() { cout << "Det::add" << endl; }
};
int main()
{
	Det d(0);
	//Object* op = &d;erro因为d里面Base和Test都有Object
	Object* opa = (Base*)&d;
	Object* opb = (Test*)&d;//opa和opb 是不同的地址
	opa->add();
	opa->fun();

	opb->add();
	opb->fun();
	return 0;
}

在这里插入图片描述

在这里插入图片描述

虚继承的多继承

class Object
{
	int value;
public:
	Object(int x = 10) :value(x) {}
	virtual void fun() { cout << "Object" << endl; }
	virtual void add() { cout << "Object::add" << endl; }
 };
class Base :virtual public Object
{
	int num;
public:
	Base(int x = 0) :num(x), Object(x + 10) {}
	virtual void fun() { cout << "Base" << endl; }
};
class Test : virtual public Object
{
	int sum;
public:
	Test(int x = 0) : sum(x), Object(x + 10) {}
	virtual void fun() { cout << "Test" << endl; }
	 void add() { cout << "Test::add" << endl; }
};
class Det :public Base, public Test
{
private:
	int total;
public:
	Det(int x = 0) :total(x), Base(x + 10), Test(x + 20), Object(x + 100) {}
	 void fun() { cout << "Det" << endl; }
	void add() { cout << "Det::add" << endl; }
};
int main()
{
	Det d(0);
	Object* opa = &d;
	Object* opb = &d;//opa和opb 是不同的地址
	opa->add();
	opa->fun();

	opb->add();
	opb->fun();
	return 0;
}

在这里插入图片描述

STL

在这里插入图片描述在这里插入图片描述
在这里插入图片描述

STL问的最多的就是配置器和迭代器的失效问题
在这里插入图片描述

字符串库

#include<string>//c++里面的字符串类型
#include<string.h>//C库里面的字符串函数库
#include<cstring>//C库里面的字符串函数库
int main()
{
	string s1 = "yhpingll";
	string s2("yhpingll");
	//string::value_type p;
	string::value_type v;//char v
	string::pointer p = &v;
	string::reference x = v;
	//char&x=v;
	string::const_reference y = v;
	//char const&y=v;

	cout << typeid(p).name() << endl;

}

int main()
{
	string s1 = "abcdefgh";
	string::iterator it = s1.begin();
	for (;it != s1.end(); ++it)
	{
		cout << *it;
	}
	cout << endl;
	string::reverse_iterator rt;
	for (rt = s1.rbegin(); rt != s1.rend(); ++rt)
	{
		cout << *rt;
	}
	cout << endl;
	for (auto& x : s1)
	{
		cout << x;
	}
	cout << endl;
	return 0;
}

在这里插入图片描述

int main()
{
	string s1("yhping");
	string s2("hello");
	cout << s1 << endl;
	cout << s2 << endl;
	s1 = s2;
	cout << s1 << endl;//底层已经对输出流进行了重载
	cout << s2 << endl;
}

在这里插入图片描述

int main()
{
	string s1("yhping");
	string s2("hello");
	cout << s1 << endl;
	cout << s2 << endl;
	s1 = std::move(s2);
	cout << s1 << endl;//底层已经对输出流进行了重载
	cout << s2 << endl;
}

在这里插入图片描述

#include<string>//c++里面的字符串类型
int main()
{
	string s1("yhping");
	cout << "size: " << s1.size() << endl;
	cout << "capacity: " << s1.capacity() << endl;
	s1 += "hellohelloniahoanihaoa";
	cout << "size: " << s1.size() << endl;
	cout << "capacity: " << s1.capacity() << endl;
	return 0;
}

在这里插入图片描述

int main()
{
	string s1("yhping");
	int n = s1.size();
	for (int i = 0; i < n; ++i)
	{//下标访问
		cout << s1[i] << " ";
	}
	cout << endl;
	//在某些STL库里面[]访问并不检查是否越界，函数检查是否越界
	for (int i = 0; i < n; ++i)
	{//函数访问
		cout << s1.at(i) << " ";
	}
	cout << endl;
	return 0;
}

在这里插入图片描述

int main()
{
	string s1("yhping");
	char cha = s1[1];

	char& chb = s1[1];//一般情况下不要以引用接收

	s1.clear();//清除函数
	s1 = "hello";
	cout << chb << endl;

	return 0;
}

在这里插入图片描述

int main()
{
	string s1("yhping");
	cout << "size: " << s1.size() << endl;
	cout << "Capt: " << s1.capacity() << endl;
	cout << "max_size: "<<s1.max_size() <<endl;
	s1.reserve(128);
	cout << "size: " << s1.size() << endl;
	cout << "Capt: " << s1.capacity() << endl;
	cout << "max_size: " << s1.max_size() << endl;
}

在这里插入图片描述

int main()
{

	string s1("yhping");
	cout << s1.size() << " " << s1.capacity() << endl;
	s1.reserve(200);//正常情况每一次空间不够的时候扩容，我们现在直接一次性给200个字节空间，不需要反复的对空间进行操作
	for (int i = 0; i < 10; ++i)
	{
		s1 += "hello";
		cout << s1.size() << " " << s1.capacity() << endl;
	}
}

在这里插入图片描述

#include<vector>
class Object
{
private:
	int value;
public:
	Object(int x = 0) :value(x) { cout << "Object" << endl; }
	Object(const Object& obj) :value(obj.value) { cout << "Object &" << endl; }
	Object(Object&& obj) :value(obj.value) { cout << "move Object&&" << endl; }
	Object& operator=(const Object& obj)
	{
		value = obj.value;
		cout << "operator=" << endl;
		return *this;
	}
	Object& operator=(const Object&& obj)
	{
		value = obj.value;
		cout << "operator=" << endl;
		return *this;
	}
	~Object()
	{
		cout << "~Object" << endl;
	}
};
int main()
{
	vector<Object> vecobj;

	for (int i = 0; i < 5; ++i)
	{
		vecobj.push_back(Object(10));
		cout << vecobj.size() << endl;
		cout << vecobj.capacity() << endl;
	}
	return 0;
}

反复的扩容导致产生更多的构造和析构函数并且产生了更多的对象
增空间将原来的对象挪到新空间，在释放原来的旧空间
在这里插入图片描述

int main()
{
	vector<Object> vecobj;
	vecobj.reserve(200);
	for (int i = 0; i < 5; ++i)
	{
		vecobj.push_back(Object(10));
		cout << vecobj.size() << endl;
		cout << vecobj.capacity() << endl;
	}
	return 0;
}

在这里插入图片描述

随机性迭代器和双向迭代器的区别

int main()
{
	vector<int>ivec = { 12,2,3,34,45 };
	//随机性迭代器
	vector<int>::iterator it = ivec.begin();
	it++;
	it += 5;
	list<int>ilist = { 12,2,3,34,45 };
	//双向迭代器
	list<int>::iterator i = ilist.begin();
	i++;
	i += 5;//Erro链表不能
	return 0;
}
丽丽的代码
关注
  • 5
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C++继承详解三 ----菱形继承、虚继承
丁香枝上，豆蔻梢头
04-17 1006
今天呢，我们来讲讲菱形继承与虚继承。这两者的讲解是分不开的，要想深入了解菱形继承，你是绕不开虚函数这一点的。它俩有着什么关系呢？值得我们来剖析。 菱形继承也叫钻石继承，它是多继承的一种特殊实例吧，它的基本架构如下图： 在我们的设想中，D所对应的对象模型应该如下图所示： 下面我们来用一段代码验证一下： class A { public: A() { cout
菱形继承&菱形虚拟继承
婉茹的博客
08-05 227
菱形继承（钻石继承） 模型： 代码实现：
C++——菱形继承和虚继承
weixin_59913110的博客
05-31 1035
C++作为"第一个吃螃蟹的人"，勇敢地设计出了多继承的语法，多继承出现之后，由于一些顶尖程序员的脑洞非常大，就发现了菱形继承所带来数据冗余和二义性的问题，C++标准委员会为了解决这个问题，就设计出了虚继承。从此之后，后面"抄作业的人"就没有多继承的语法，例如java。
【C++】菱形继承和虚继承
weixin_52958292的博客
11-05 664
用两种方式去分别继承Base和Test类，因此Object中的虚表指针，在指向Det中的虚表时，有两个，一个继承Base中的虚表，另一个是继承test中的虚表。2.base用double类型继承，test用int类型继承，会推演出两个模板，自然而然，在各自的类型模板中，对静态成员变量只初始化一次。在Det的对象中Object成员会有两份。当虚继承的派生类被当做基类再次虚继承，虚基类指针也会被继承。Object基类中的虚表指针，开始指向Object中的虚表，虚继承：主要是通过虚继承，在。
C++_菱形继承(虚继承)
ciao_21的博客
01-06 528
本文主要介绍菱形继承 and 虚继承基本操作
[第五天】C++继承：单继承、多继承、菱形继承和虚继承的深度解析
最新发布
m0_75045191的博客
02-06 1487
class 父类{};class 子类:继承方式 父类名//新增子类数据继承方式：private protected public(推荐)公共继承 保持不变，保护继承变保护，私有继承变私有，所有父类私有在子类中不可见。子类虚继承父类 子类只会保存一份公共数据。方式：在继承方式 前加virtual修饰。
C++课程-4_继承与派生
08-25
这增加了设计的灵活性，但也会带来一些问题，如菱形问题（diamond problem），需要通过虚继承来解决。 3. **访问修饰符**：在继承过程中，基类的成员可以有不同的访问级别——公有（public）、受保护（protected）...
CPP：cpp标准模板库（STL），面向对象编程中的代码
02-21
C++支持单继承和多继承，但多继承可能导致菱形问题，需要谨慎使用。 - **多态**：多态允许不同类型的对象对同一消息作出不同的响应。在C++中，虚函数和纯虚函数是实现多态的主要手段。动态绑定（运行时多态）使我们...
c++复习资料大全 指针多态 函数 继承类等
10-04
同时，掌握封装和抽象原则，以及何时使用虚继承来解决菱形问题，是构建可维护和扩展的软件架构的基础。 最后，这份复习资料可能还包含了C++的其他重要主题，如异常处理、STL（标准模板库）、I/O流、模板元编程等。...
c/c++面试题（一些常出的面试题，包括多态，继承，函数参数等常考的内容）
03-20
此外，面试官可能还会询问关于构造函数和析构函数的理解，如何使用虚析构函数处理多态对象的销毁，以及如何使用C++的模板、STL（标准模板库）、异常处理等高级特性。这些都要求面试者具备扎实的C++基础和实践经验。 ...
Java版水果管理系统源码-c-plus-Interview:c-plus-面试
06-05
菱形继承的对象模型？ C++ 多态 dll 多态的两种方式 多态如何实现 C++ 虚函数 虚函数的实现原理，子类构造析构函数的调用顺序 虚函数怎么实现的 虚函数机制 虚函数的执行和类成员函数的执行在汇编的级别差了哪些指令...
虚继承——解决菱形继承的问题以及其底层实现
KingJamesX的博客
09-17 353
在c++中我们有一种继承方式叫做菱形继承，通俗来说就是有两个类（son1，son2）都继承了同一个类（base），然后又有一个类（grandson）来继承这两个类（就是多继承的一种，个人不建议在实际开发中使用多继承）。但是这样做会带来两个问题或许这样看不是很清楚，我们上代码看看那么c++给我们提供了虚继承用来解决这种问题，只需要在son1和son2继承base时使用虚继承即可（grandson正常继承son1和son2），语法：class son1 : virtual public base {};
菱形继承与虚继承
luhaowei0066的博客
08-07 3445
菱形继承 先介绍一下单继承和多继承                            单继承                                                                                            多继承   菱形继承 菱形继承是单继承和多继承的集合                        ...
菱形继承和虚继承
canvasa的博客
08-28 406
一、单继承和多继承 单继承：一个子类只有一个直接父类时，称这个继承为单继承。 多继承：一个子类有俩个或以上的直接父类时称这个继承关系为多继承。 单继承：可以有多个父类，但是只能由一个直接父类。示意图如下： 多继承示意图如下： 菱形继承示意图如下： 菱形继承对象模型：Assistant的对象中有两份Person成员，菱形继承存在数据冗余和二义性的问题。 菱形继承举例： class person { public: string _name; }; class studen
【C++基础之二十一】菱形继承和虚继承
热门推荐
偶尔e网事
01-05 3万+
菱形继承是多重继承中跑不掉的，Java拿掉了多重继承，辅之于接口。C++中虽然没有明确说明接口这种东西，但是只有纯虚函数的类可以看作Java中的接口。在多重继承中建议使用“接口”，来避免多重继承中可能出现的各种问题。 1.菱形继承 先看一下菱形继承长什么样。 B和C从A中继承，而D多重继承于B，C。那就意味着D中会有A中的两个拷贝。因为成员函数不体现在类的内存大小上，
菱形继承+虚继承
m0_62624752的博客
04-12 313
菱形继承的概念： 两个派生类继承同一个基类；又有某个类同时继承两个派生类；这种继承被称为菱形继承，或者钻石继承 带来的问题：子类继承两份相同的数据，导致资源浪费。 虚继承：解决菱形继承带来的问题 class Animal { public: int m_Age; }; //继承前加virtual关键字后，变为虚继承 //此时公共的父类Animal称为虚基类 class Sheep : virtual public Animal {}; class Tuo : virtual public
虚继承：解决菱形继承问题
一得同学
06-05 1261
羊驼类继承的实际是两个虚基类指针 vbptr
C++菱形继承与虚继承
随便记点东西
08-14 2683
虚继承，菱形继承
STL源码剖析电子书
"STL源码剖析是一本深入探讨C++标准模板库(STL)的电子书，以清晰的pdf格式提供，包含书签目录，便于读者查阅和学习。" STL，全称Standard Template Library，是C++编程语言中一个重要的部分，它提供了一组高效且...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值