学习目标：
学习内容：
1.继承的方式
继承的基本语法：class 子类:继承方式 父类
继承方式主要有：
- 公共继承(public);
- 保护继承(protected);
- 私有继承(private)
1.1 公共继承
//公共继承
#include<iostream>
using namespace std;
class Base
{
public:
int m_A;
protected:
int m_B;
private:
int m_C;
};
class Son :public Base
{
public:
void func()
{
m_A = 10; //父类中公共权限成员到子类中依然是公共权限
m_B = 10; // 父类中保护权限成员到子类中依然是保护权限
//m_C = 10; //父类中私有权限成员到子类中依然是私有权限
}
};
void test()
{
Son s;
s.m_A = 100;
//s1.m_B = 100; //到son1中m_B是保护权限，类外是无法访问的
cout << s.m_A << endl;
}
int main()
{
test();
system("pause");
return 0;
}
1.2 保护继承
#include<iostream>
using namespace std;
class Base
{
public:
int m_A;
protected:
int m_B;
private:
int m_C;
};
class Son :protected Base
{
public:
void func()
{
m_A = 10; //父类中公共权限成员到子类中依然是保护权限
m_B = 10; // 父类中保护权限成员到子类中依然是保护权限
//m_C = 10; //父类中私有权限成员到子类中依然是私有权限,无法访问
}
};
void test()
{
Son s;
//s.m_A = 100; //继承的是保护权限，在类外无法访问
//s.m_B = 100;//继承的是保护权限，在类外无法访问
//s1.m_B = 100; //到son1中m_B是保护权限，类外是无法访问的
}
int main()
{
test();
system("pause");
return 0;
}
1.3 保护继承
#include<iostream>
using namespace std;
class Base1
{
public:
int m_A;
protected:
int m_B;
private:
int m_C;
};
class Son :private Base1
{
public:
void func()
{
m_A = 10; //父类中公共权限成员到子类中依然是私有权限
m_B = 10; // 父类中保护权限成员到子类中依然是私有权限
//m_C = 10; //父类中私有权限成员到子类中依然是私有权限,无法访问
}
};
void test()
{
Son s;
//s.m_A = 100; //继承的是私有权限，在类外无法访问
//s.m_B = 100;//继承的是私有权限，在类外无法访问
//s1.m_B = 100; //到son1中m_B是保护权限，类外是无法访问的
}
int main()
{
test();
system("pause");
return 0;
}
2.继承的对象模型
子类继承父类的相关属性之后，有哪些是属于子类上的对象。
//公共继承
#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 test()
{
//16个字节
//父类中所有的非静态成员属性都会被子类继承下去
//父类中私有属性是被编译器隐藏了，所以无法访问，但是是被继承下去了
cout << "Size of Son " << sizeof(Son) << endl;
}
int main()
{
test();
system("pause");
return 0;
}
3.继承中构造和析构的顺序
在继承中，构造函数和析构函数是如何调用的？
//继承中构造和析构顺序
#include<iostream>
using namespace std;
class Base
{
public:
Base()
{
cout << "父类Base的构造函数！！" << endl;
}
~Base()
{
cout << "父类Base的析构函数！！" << endl;
}
};
class Son:public Base
{
public:
Son()
{
cout << "子类Son的构造函数！！" << endl;
}
~Son()
{
cout << "子类Son的析构函数！！" << endl;
}
};
void test()
{
//Base b;
Son s;
//继承中构造函数和析构函数顺序如下：
//先构造父类，再构造子类，再析构子类，最后析构父类
}
int main()
{
test();
system("pause");
return 0;
}
4.继承中同名处理方式
当子类和父类出现同名的成员时，如何通过子类对象去访问子类或者父类中同名的数据？
访问子类同名成员，直接访问即可；访问父类同名成员，需要加上作用域；
4.1 继承中同名成员属性的处理
//继承中同名成员处理
#include<iostream>
using namespace std;
class Base
{
public:
Base()
{
m_A = 100;
}
int m_A;
};
class Son :public Base
{
public:
Son()
{
m_A = 200;
}
int m_A;
};
void test()
{
Son s;
cout << "Son m_A = " << s.m_A << endl;//访问子类同名成员，直接访问即可
cout << "Base m_A = " << s.Base::m_A << endl; //通过子类成员来访问父类成员，需要加上作用域
}
int main()
{
test();
system("pause");
return 0;
}
4.2 继承中同名成员函数的处理
#include<iostream>
using namespace std;
class Base
{
public:
void func()
{
cout << "Base--func()函数调用！！" << endl;
}
void func(int a)
{
cout << "Base--func(int a)函数调用！！" << endl;
}
};
class Son :public Base
{
public:
void func()
{
cout << "Son--func()函数的调用！！" << endl;
}
/*void func(int a)
{
cout << "Son--func(int a)函数的调用！！" << endl;
}*/
};
void test()
{
Son s;
s.func();
s.Base::func();
//若子类出现和父类同名的成员函数，子类的同名函数会直接隐藏掉父类中所有的同名成员函数
//s.func(100);//如果子类中有该函数形式，那么直接调用，但是子类中没有该函数形式，则会报错
//若想调用父类中有参成员函数要加上作用域
s.Base::func(100);
}
int main()
{
test();
system("pause");
return 0;
}
5.继承同名静态成员处理方式
问题：继承中同名静态成员在子类对象上如何访问？
- 静态成员和非静态成员出现同名时，处理方式一致；
- 访问子类同名成员，直接访问即可；
- 访问父类同名成员，需要加作用域；
5.1 继承中同名静态成员属性处理方式
//继承中同名静态成员处理方式
#include<iostream>
using namespace std;
class Base
{
public:
static int m_A;
};
int Base::m_A = 100;
class Son :public Base
{
public:
static int m_A;
};
int Son::m_A = 200;
void test()
{
//1.通过对象来访问数据
Son s;
cout << "通过对象访问：" << endl;
cout << "\tSon m_A: " << s.m_A << endl;
cout << "\tBase m_A: " << s.Base::m_A << endl;
cout << "--------------------------------------------------------------------------" << endl;
//2.通过类名来访问数据
cout << "通过类名访问：" << endl;
cout << "\tSon m_A: " << Son::m_A << endl;
cout << "\tBase m_A: " << Base::m_A << endl;//直接调用父类来得到成员属性，而非通过子类到父类得到父类的属性
cout << "\tBase m_A: " << Son::Base::m_A << endl;//第一个冒号表示通过类名来访问 第二个代表父类作用域下
}
int main()
{
test();
system("pause");
return 0;
}
5.2 继承中同名静态成员函数处理方式
//继承中同名静态成员函数处理方式
#include<iostream>
using namespace std;
class Base
{
public:
static void func()
{
cout << "父类的调用！！！！！" << endl;
}
};
class Son :public Base
{
public:
static void func()
{
cout << "子类的调用！！！！" << endl;
}
};
void test()
{
//1.通过对象来访问数据
cout << "通过对象访问：" << endl;
Son s;
s.func();
s.Base::func();
cout << "---------------------------------------------" << endl;
//2.通过类名来访问数据
cout << "通过类名访问：" << endl;
Son::func();
Base::func();//直接调用父类来得到成员属性，而非通过子类到父类得到父类的属性
Son::Base::func(); //第一个冒号表示通过类名来访问 第二个代表父类作用域下
}
int main()
{
test();
system("pause");
return 0;
}
6.多继承的语法
c++中允许一个类继承多个类
语法：class 子类: 继承方式 父类1，继承方式 父类, ……
多继承可能导致父类中有同名成员的出现，需要加上作用域；
在实际开发应用中，不建议用多继承！！！！！！！！！！
7.菱形继承问题和解决方案
概念：两个派生类继承同一个类，又有另一个类同时继承这两个派生类。
引发的问题：
- 羊和驼都继承了动物的属性，当羊驼使用数据时就会产生二义性；
- 羊驼继承了两份数据，造出来资源浪费。
#include<iostream>
using namespace std;
class Animal
{
public:
int m_Age;
};
class sheep : public Animal {};
class camel : public Animal {};
class Alpaca :public sheep, public camel {};
void test()
{
Alpaca al;
al.sheep::m_Age = 100;
al.camel::m_Age = 150;
//此时有两份数据，要用作用域进行区分
cout << "camel的年龄为：" << al.camel::m_Age << endl;
cout << "sheep的年龄为：" << al.sheep::m_Age << endl;
//菱形继承导致了数据有两份，造成资源浪费。利用虚继承来解决资源浪费的问题
}
int main()
{
test();
system("pause");
return 0;
}
7.1.虚继承解决菱形继承
#include<iostream>
using namespace std;
class Animal
{
public:
int m_Age;
};
class sheep:virtual public Animal{};
class camel:virtual public Animal{};
class Alpaca:public sheep, public camel{};
void test()
{
Alpaca al;
al.sheep::m_Age = 100;
al.camel::m_Age = 150;
//此时有两份数据，要用作用域进行区分
cout << "camel的年龄为：" << al.camel::m_Age << endl;
cout << "sheep的年龄为：" << al.sheep::m_Age << endl;
//菱形继承导致了数据有两份，造成资源浪费。利用虚继承来解决资源浪费的问题
}
int main()
{
test();
system("pause");
return 0;
}
