C++:类和对象（继承）

一个类除了拥有另一个类的共性，还有自己的特性，可以使用继承，减少重复代码

• 基本语法：class 子类 : 继承方式（public、protect、private） 父类
  • 子类也称派生类，父类也称基类
• 继承方式
  • 公共继承（公共权限成员，到子类中依然是公共权限，保护权限成员，到子类中依然是保护权限，父类私有成员不可访问）
  • 保护继承（公共权限成员，到子类中变为保护权限，保护权限成员，到子类中依然是保护权限，父类私有成员不可访问）
  • 私有继承（公共权限与保护权限均变为私有权限，父类私有成员不可访问）

#include <iostream>

using namespace std;

class Base
{
public:
	int m_A;
protected:
	int m_B;
private:
	int m_C;
};

class Son1 :public Base
{
public:
	void func()
	{
		m_A = 10;	//公共权限
		m_B = 10;	//保护权限
		//m_C = 10;	//不可访问
	}
};

class Son2 :protected Base
{
public:
	void func()
	{
		m_A = 10;	//保护权限
		m_B = 10;	//保护权限
		//m_C = 10;	//不可访问
	}
};

class Son3 :private Base
{
public:
	void func()
	{
		m_A = 10;	//私有权限
		m_B = 10;	//私有权限
		//m_C = 10;	//不可访问
	}
};



int main()
{
	return 0;
}

• 继承中的对象模型
  • 父类中所有的非静态成员属性都会被子类继承，只是被编译器隐藏了，因此是访问不到，而不是没有继承
• 继承中构造和析构顺序
  • 子类继承父类后，当创建子类对象时，也会调用父类的构造函数
  • 先调用父类构造，然后子类构造，然后子类析构，然后父类析构

#include <iostream>

using namespace std;

class Base
{
public:
	Base()
	{
		cout << "父类构造函数" << endl;
	}

	~Base()
	{
		cout << "父类析构函数" << endl;
	}
};

class Son :public Base
{
public:
	Son()
	{
		cout << "子类构造函数" << endl;
	}

	~Son()
	{
		cout << "子类析构函数" << endl;
	}
};

void test()
{
	//Base b;
	Son s;
}

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

•  继承同名成员处理方式
  • 当子类与父类出现同名成员，如何通过子类对象访问父类中同名数据
    • 访问子类同名成员，直接访问
    • 访问父类同名成员，需加作用域（对象名.类名::成员名）

#include <iostream>

using namespace std;

class Base
{
public:
	Base()
	{
		m_A = 100;
	}
	void func()
	{
		cout << "Base函数调用" << endl;
	}
	int m_A;
};

class Son :public Base
{
public:
	Son()
	{
		m_A = 200;
	}
	void func()
	{
		cout << "Son函数调用" << endl;
	}
	int m_A;
};

void test()
{
	Son s;
	cout << "Son  m_A= " << s.m_A << endl;
	cout << "Base m_A= " << s.Base::m_A << endl;
	s.func();
	s.Base::func();
}

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

•  继承中同名静态成员处理方式
  • 访问子类同名成员，直接访问
  • 访问父类同名成员，需加作用域（对象名.类名::成员名）

#include <iostream>

using namespace std;

class Base
{
public:
	static void func()
	{
		cout << "Base" << endl;
	}
	static int m_A;
};

int Base::m_A = 100;

class Son :public Base
{
public:
	static void func()
	{
		cout << "Son" << endl;
	}
	static int m_A;
};

int Son::m_A = 200;

void test()
{
	Son s;
	cout << "通过对象访问" << endl;
	cout << "Son  m_A= " << s.m_A << endl;
	cout << "Base m_A= " << s.Base::m_A << endl;
	cout << "通过类名访问" << endl;
	cout << "Son  m_A= " << Son::m_A << endl;
	cout << "Base m_A= " << Son::Base::m_A << endl;
	cout << "通过对象访问" << endl;
	s.func();
	s.Base::func();
	cout << "通过类名访问" << endl;
	Son::func();
	Son::Base::func();
}

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

 

•  多继承语法（C++允许一个类继承多个类，一个儿子多个爹）
  • 语法：class 子类 : 继承方式 父类1,继承方式 父类2,..........
  • 多继承可能会引发父类中同名成员处出现，需要加作用域区分
  • 实际开发中不建议用多继承

#include <iostream>

using namespace std;

class Base1
{
public:
	Base1()
	{
		m_A = 100;
	}
	int m_A;
};

class Base2
{
public:
	Base2()
	{
		m_B = 200;
	}
	int m_B;
};


class Son :public Base1, public Base2
{
public:
	Son()
	{
		m_C = 300;
		m_D = 400;
	}
	int m_C;
	int m_D;
};


void test()
{
	Son s;
	cout << sizeof(s) << endl;
}

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

• 菱形继承
  • 概念：
    • 两个派生类继承同一个基类
    • 又有某个类同时继承两个派生类
    • 这种继承称为菱形继承，或者钻石继承 

• 羊继承了动物的数据，驼也继承了动物的数据，当草泥马使用数据时，就会产生二义性
• 草泥马继承自动物的数据继承了两份，这份数据我们只需要一份就可以
• 利用虚继承解决菱形继承问题（ virtual 关键字）
  • Animal类称为虚基类