【C++】继承和多态[2]

继承：

单继承

多继承

菱形继承

存在的问题：间接基类的数据会出现多份，会导致访问出错。解决方法：虚表指针

虚继承

虚基类构造优先级高

非虚基类布局优先于虚基类

#include<iostream>

class Animal//抽象类
{
public:
	Animal(std::string name):mname(name)
	{}
	virtual void Shark() = 0;//纯虚函数
	virtual ~Animal(){}
private:
	std::string mname;
};

class Dog:public Animal
{
public:
	Dog(std::string name):Animal(name)
	{}
	virtual void Shark()
	{
		std::cout<<"wang wang wang"<<std::endl;
	}
	virtual ~Dog(){}
};

class Cat:public Animal
{
public:
	Cat(std::string name):Animal(name)
	{}
	virtual void Shark()
	{
		std::cout<<"miao miao miao"<<std::endl;
	}
	virtual ~Cat(){}
};


//Show   //Animal  派生出来的类 实例化的对象  都能当参数传递调动Shark方法
void Show(Animal &animal)
{
	animal.Shark();
}
int main()
{
	Cat cat("cat");
	Dog dog("dog");
	Show(dog);
	Show(cat);
	return 0;
}

Animal 派生出来的类实例化的对象都能当参数传递调动Shark方法

C++中类型的转化：

const_cast 去除常性

static_cast 安全性高

reinterpret_cast 类似C的转化一般用于指针的转化

dynamic_cast RTTI(运行时类型识别)信息

eg.

int main()
{
	const int a = 10;
	const int* p = &a;
	int *q = const_cast<int*>(p);
	*q = 20;
	return 0;
}

#include<iostream>

class Bird
{
public:
	Bird(std::string name):mname(name){}
	virtual void Fly() = 0;
	virtual ~Bird(){};
private:
	std::string mname;
};

class Egal:public Bird
{
public:
	Egal(std::string name):Bird(name){}
	void Fly()
	{
		std::cout<<"Egal can fly 50m"<<std::endl;
	}
	~Egal(){}
};

class Pengine:public Bird
{
public:
	Pengine(std::string name):Bird(name){}
	void Fly()
	{
		std::cout<<"Pengine can not fly"<<std::endl;
	}
	~Pengine(){}
};

void Skill(Bird* bird)
{   //②
	Pengine* ppen = dynamic_cast<Pengine*>(bird);
	if(ppen == NULL)
	{
		bird->Fly();
	}
	else
	{
		std::cout<<"Pengine can swimming"<<std::endl;
	}
	/*
	①
	if(typeid(*bird) == typeid(Pengine))
	{
		std::cout<<"Pengine can swimming"<<std::endl;
	}
	else
		bird->Fly();
		*/
}

int main()
{
	Egal egal("egal");
	Pengine pengine("pengine");
	Skill(&egal);
	Skill(&pengine);
	return 0;
}

菱形继承的内存布局：

对下面代码进行分析


class  A
{
public:
	A(int a) :ma(a)
	{
		std::cout << "A" << std::endl;
	}
	~A()
	{
		std::cout << "~A" << std::endl;
	}
public:
	int ma;
};
class B : virtual public A
{
public:
	B(int b) :A(b), mb(b)
	{
		std::cout << "B" << std::endl;
	}
	~B()
	{
		std::cout << "~B" << std::endl;
	}
public:
	int mb;
};
class C :virtual public A
{
public:
	C(int c) :A(c), mc(c)
	{
		std::cout << "C" << std::endl;
	}
	~C()
	{
		std::cout << "~C" << std::endl;
	}
public:
	int mc;
};
class E
{
public:
	E(int e) :me(e)
	{
		std::cout << "E" << std::endl;
	}
	~E()
	{
		std::cout << "~E" << std::endl;
	}
public:
	int me;
};
class D :public B, virtual public E ,public C
{
public:
	D(int d) :md(10), B(d), C(d), A(d), E(d)
	{
		std::cout << "D" << std::endl;
	}
	~D()
	{
		std::cout << "~D" << std::endl;
	}
public:
	int md;
};

int main()
{
	return 0;
}

【C++】继承和多态[2]

猜你喜欢