C++学习之路（六）

继承的引出

继承允许我们依据另一个类来定义一个类，这使得创建和维护一个应用程序变得更容易。这样做，也达到了重用代码功能和提高执行效率的效果。

当创建一个类时，您不需要重新编写新的数据成员和成员函数，只需指定新建的类继承了一个已有的类的成员即可。这个已有的类称为基类，新建的类称为派生类。

继承代表了 is a 关系。例如，哺乳动物是动物，狗是哺乳动物，因此，狗是动物，等等。
一个类可以派生自多个类，这意味着，它可以从多个基类继承数据和函数。定义一个派生类，我们使用一个类派生列表来指定基类。类派生列表以一个或多个基类命名，形式如下：

class derived-class: access-specifier base-class

其中，访问修饰符 access-specifier 是 public、protected 或 private 其中的一个，base-class 是之前定义过的某个类的名称。如果未使用访问修饰符 access-specifier，则默认为 private。

继承方式

访问控制和继承

派生类可以访问基类中所有的非私有成员。因此基类成员如果不想被派生类的成员函数访问，则应在基类中声明为 private。
我们可以根据访问权限总结出不同的访问类型，如下所示：

访问	public	protected	private
同一个类	yes	yes	yes
派生类	yes	yes	no
外部的类	yes	no	no

一个派生类继承了所有的基类方法，但下列情况除外：

基类的构造函数、析构函数和拷贝构造函数。
基类的重载运算符。
基类的友元函数。

继承类型

当一个类派生自基类，该基类可以被继承为 public、protected 或 private 几种类型。继承类型是通过上面讲解的访问修饰符 access-specifier 来指定的。
我们几乎不使用 protected 或 private 继承，通常使用 public 继承。当使用不同类型的继承时，遵循以下几个规则：

公有继承（public）：当一个类派生自公有基类时，基类的公有成员也是派生类的公有成员，基类的保护成员也是派生类的保护成员，基类的私有成员不能直接被派生类访问，但是可以通过调用基类的公有和保护成员来访问。
保护继承（protected）： 当一个类派生自保护基类时，基类的公有和保护成员将成为派生类的保护成员。
私有继承（private）：当一个类派生自私有基类时，基类的公有和保护成员将成为派生类的私有成员。

#define _CRT_SECURE_NO_WARNINGS
#include<iostream>
using namespace std;

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

//公有继承
class Son1 : public Base1
{
public:
	void func()
	{
		//cout << m_C << endl; //基类中私有的属性 不可继承
		cout << m_A << endl; //基类中公有的属性 可继承，还是public
		cout << m_B << endl;//基类中保护的属性 可继承，还是protected 类外访问不到
	}

};
void myFunc()
{
	Son1 s1;
	s1.m_A;
	//s1.m_B;
}

保护继承

class Base2
{
public:
	int m_A;
protected:
	int m_B;
private:
	int m_C;
};
class Son2 :protected Base2
{
public:
	void func()
	{
		//cout << m_C << endl; //基类中私有的属性 不可继承
		cout << m_A << endl;//基类中公有的属性 可继承，是protected
		cout << m_B << endl;//基类中保护的属性 可继承，还是protected
	}

};
void myFunc2()
{
	Son2 s;
	//s.m_A; 不能访问
}


私有继承
class Base3
{
public:
	int m_A;
protected:
	int m_B;
private:
	int m_C;

};

class Son3 :private Base3
{
public:
	void func()
	{
		//cout << m_C << endl; //基类中私有的属性 不可继承
		cout << m_A << endl; //基类中公有的属性 可继承，是private
		cout << m_B << endl;//基类中保护的属性 可继承，是private
	}

};

class GrandSon3 :public Son3
{
public:
	void myFunc()
	{
		//cout << m_A << endl; //孙子类中 访问不到 m_A，因为在Son3中m_A已经是私有属性了
	}

};



int main(){



	system("pause");
	return EXIT_SUCCESS;
}

继承中的对象模型

子类会继承父类中所有的内容，包括私有属性，只是我们访问不到，编译器给隐藏了。

#define _CRT_SECURE_NO_WARNINGS
#include<iostream>
using namespace std;

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

};

//子类中 会继承父类的私有成员，只是被编译给隐藏起来，访问不到私有成员
class Son :public Base
{
public:
	int m_D;
};

void test01()
{
	cout << sizeof(Son) << endl;

}

int main(){

	test01();

	system("pause");
	return EXIT_SUCCESS;
}

在下边路径下可以找到VS 2017的开发人员命令提示符

C:\ProgramData\Microsoft\Windows\Start Menu\Programs\Visual Studio 2017\Visual Studio Tools

或者通过开始找到。
右键打开test.cpp文件所在的文件夹。复制路径，进入此路径下。dir查看文件列表，看test.cpp中son类一个结构图。代码如下：

cl /d1 reportSingleClassLayoutSon test.cpp

继承中的构造和析构顺序

子类对象在创建时会首先调用父类的构造函数
父类构造函数执行完毕后，才会调用子类的构造函数
当父类构造函数有参数时，需要在子类初始化列表(参数列表)中显示调用父类构造函数
析构函数调用顺序和构造函数相反

#define _CRT_SECURE_NO_WARNINGS
#include<iostream>
using namespace std;

class Base
{
public:
	Base()
	{
		m_A = 10;
		cout << "Base默认构造函数调用" << endl;
	}
	~Base()
	{
		cout << "Base的析构函数调用" << endl;
	}

	int m_A;
};
// 子类会继承父类的成员属性，成员函数
//但是 子类 不会继承 父类 构造函数 和 析构函数
//只有父类自己知道如何构造和析构自己的属性，而子类不知道


class Son :public Base
{
public:
	Son()
	{
		cout << "Son默认构造函数调用" << endl;
	}
	~Son()
	{
		cout << "Son的析构函数调用" << endl;
	}
};

void test01()
{
	//Base b1;

	Son s1;
}



class Base2
{
public:
	Base2(int a)
	{
		this->m_A = a;
		cout << "有参构造函数调用" << endl;
	}
	int m_A;
};

class Son2:public Base2
{
public:
	Son2(int a ) : Base2(a)//利用初始化列表方式 显示调用 有参构造。如果是Son2（），因为要先调用基类的默认构造，但此时基类的默认构造没有。
	{
	}
};

void test02()
{
	Son2 s2(1000);
}


int main(){

	test01();

	system("pause");
	return EXIT_SUCCESS;
}

继承中的同名成员处理

当子类成员和父类成员同名时，子类依然从父类继承同名成员

如果子类有成员和父类同名，子类访问其成员默认访问子类的成员(本作用域，就近原则)>
在子类通过作用域::进行同名成员区分(在派生类中使用基类的同名成员，显示使用类名限定符)
如果子类和父类拥有同名的函数 属性 ，子类会覆盖父类的成员吗？ 不会
如果子类与父类的成员函数名称相同，子类会把父类的所有的同名版本都隐藏掉
想调用父类的方法，必须加作用域

#define _CRT_SECURE_NO_WARNINGS
#include<iostream>
using namespace std;

class Base
{
public:
	Base()
	{
		m_A = 100;
	}

	void fun()
	{
		cout << "Base func调用" << endl;
	}
	void fun(int a)
	{
		cout << "Base func (int a)调用" << endl;
	}


	int m_A;
};

class Son :public Base
{
public:
	Son()
	{
		m_A = 200;
	}

	void fun()
	{
		cout << "Son func调用" << endl;
	}

	int m_A;
};

void test01()
{
	Son s1;
	cout << s1.m_A << endl;//200
	//想调用 父类中 的m_A

	cout << s1.Base::m_A << endl;//100  s1.Son::m_A 会输出200

	s1.fun();

	//调用父类的func
	s1.Base::fun(10);   //改成s1.Son::fun()  会输出  Son func调用

}

//如果子类和父类拥有同名的函数 属性 ，子类会覆盖父类的成员吗？ 不会
//如果子类与父类的成员函数名称相同，子类会把父类的所有的同名版本都隐藏掉。此时如果输入代码s1.fun(10)会出错误。
//想调用父类的方法，必须加作用域


int main(){

	test01();

	system("pause");
	return EXIT_SUCCESS;
}

继承中静态成员的处理

假如static后，可以使用类名+作用域进行访问

#define _CRT_SECURE_NO_WARNINGS
#include<iostream>
using namespace std;

class Base
{
public:

	static void func()
	{
		cout << "base fun()" << endl;
	}
	static void func(int a)
	{
		cout << "base fun(int)" << endl;
	}


	static int m_A;
};
int Base::m_A = 10;

class Son :public Base
{
public:

	static void func()
	{
		cout << "son fun()" << endl;
	}

	static int m_A;
};
int Son::m_A = 20;

//静态成员属性 子类可以继承下来
void test01()
{
	Son s1;
    cout<<s1.m_A<<endl;
	cout << Son::m_A << endl;//20
	//访问父类的m_A
	cout << Base::m_A << endl;//10
	cout <<s1.Base::m_A << endl;

	Son::func();
	//访问 父类中同名的函数
	Son::Base::func(10);//或者Base::func(10)


}


int main(){

	test01();

	system("pause");
	return EXIT_SUCCESS;
}

多继承

多继承即一个子类可以有多个父类，它继承了多个父类的特性。
C++ 类可以从多个类继承成员，语法如下：

class <派生类名>:<继承方式1><基类名1>,<继承方式2><基类名2>,…
{
<派生类类体>
};

其中，访问修饰符继承方式是 public、protected 或 private 其中的一个，用来修饰每个基类，各个基类之间用逗号分隔，如上所示。
多继承会带来一些二义性的问题， 如果两个基类中有同名的函数或者变量，那么通过派生类对象去访问这个函数或变量时就不能明确到底调用从基类1继承的版本还是从基类2继承的版本？
解决方法就是显示指定调用那个基类的版本。

#define _CRT_SECURE_NO_WARNINGS
#include<iostream>
using namespace std;

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

class Base2
{
public:
	Base2()
	{
		m_A = 20;
	}
public:
	int m_A;
};

//多继承
class Son :public Base1, public Base2
{
public:

	int m_C;
	int m_D;
};

//多继承中很容易引发二义性
void test01()
{
	cout << sizeof(Son) << endl;

	Son s1;
	//s1.m_A; //二义性

	cout << s1.Base1::m_A << endl; 
	cout << s1.Base2::m_A << endl;
}

int main(){

	test01();

	system("pause");
	return EXIT_SUCCESS;
}

菱形继承的问题以及解决方案

两个派生类继承同一个基类而又有某个类同时继承这两个派生类，这种继承被称为菱形继承，或者钻石型继承。

#define _CRT_SECURE_NO_WARNINGS
#include<iostream>
using namespace std;

class Animal
{
public:
	int m_Age;
};
class Sheep :public Animal
{
};
class Tuo :public Animal
{
};
class SheepTuo :public Sheep, public Tuo
{

};
void test01()
{
	SheepTuo st;
	st.Sheep::m_Age = 10;
	st.Tuo::m_Age = 20;
	cout << st.Sheep::m_Age << endl;
	cout << st.Tuo::m_Age << endl;

}
int main(){
	test01();
	system("pause");
	return EXIT_SUCCESS;
}

#define _CRT_SECURE_NO_WARNINGS
#include<iostream>
using namespace std;

class Animal
{
public:
	int m_Age;
};
class Sheep :virtual public Animal
{
};
class Tuo :virtual public Animal
{
};
class SheepTuo : public Sheep, public Tuo
{
};
void test01()
{
	SheepTuo st;
	st.Sheep::m_Age = 10;
	st.Tuo::m_Age = 20;
	cout << st.Sheep::m_Age << endl;
	cout << st.Tuo::m_Age << endl;
}

int main(){
	test01();
	system("pause");
	return EXIT_SUCCESS;
}

这种继承所带来的问题：
1.羊继承了动物的数据和函数，鸵同样继承了动物的数据和函数，当草泥马调用函数或者数据时，就会产生二义性。
2.草泥马继承自动物的函数和数据继承了两份，其实我们应该清楚，这份数据我们只需要一份就可以。（造成资源浪费）
解决问题用虚基类，sheepTuo内部结构，vbptr 虚基类指针，指向一张虚基类表，通过表找到偏移量，找到共有的数据。

#define _CRT_SECURE_NO_WARNINGS
#include<iostream>
using namespace std;

class Animal
{
public:
	int m_Age;
};

//虚基类 Sheep
class Sheep :virtual public Animal
{
};
//虚基类 Tuo
class Tuo :virtual public Animal  //若将此处改为class Tuo :public Animal，则布局显示为附录1
{
};

class SheepTuo :public Sheep, public Tuo
{

};

//菱形继承的解决方案 利用虚继承
//操作的是共享的一份数据

void test01()
{
	SheepTuo st;
	st.Sheep::m_Age = 10;
	st.Tuo::m_Age = 20;

	cout << st.Sheep::m_Age << endl;//20
	cout << st.Tuo::m_Age << endl;//20
	cout << st.m_Age << endl; //可以直接访问，原因已经没有二义性的可能了，只有一份m_Age
}

//通过地址 找到 偏移量
//内部工作原理
void test02()
{
	SheepTuo st;
	st.m_Age = 100;

	//找到Sheep的偏移量操作
	//cout<< *(int *)((int *)*(int *)&st + 1) << endl;

	cout << *(int*)((int*)*(int *)&st + 1) << endl;
	// *(int*)((int*)*(int *)&st + 1)可以写成 *((int*)*(int *)&st + 1)
	//*(int*)&st 是指针，指向虚基表首地址。+1是使地址加1，指向偏移量的地址。

	//找到Tuo的偏移量
	cout << *((int *)((int *)*((int *)&st + 1) + 1)) << endl;
	
	//输出Age
	cout << ((Animal*)((char *)&st + *(int*)((int*)*(int *)&st + 1)))->m_Age << endl;

}

int main(){

	//test01();
	test02();

	system("pause");
	return EXIT_SUCCESS;
}

附录1