10.1定义子类对象，包含父类成员，内存分布先父类后子类
（1）定义子类对象包含父类
（2）内存分布先父类后子类
10.2
（1）定义子类对象，构造顺序，父类->子类，父类的默认无参构造可以自动调用
（2）如果父类中无无参的构造函数，仅有带参构造函数，那么在子类的初始化列表中手动调用父类带参的构造函数
（3）子类对象、生命周期结束时，调用析构顺序是子类-父类
（错误写法）
（正确写法）
10.3继承的好处
（1）不使用继承的示例代码
#include<iostream>
using namespace std;
class CYellowPeo
{
public:
int m_money;
void cost(int a)
{
m_money-=a;
}
void eat()
{
cout<<"五常大米"<<endl;
}
};
class CWhitePeo
{
public:
int m_money;
void cost(int a)
{
m_money-=a;
}
void eat()
{
cout<<"牛排"<<endl;
}
};
class CBackPeo
{
public:
int m_money;
void cost(int a)
{
m_money-=a;
}
void eat()
{
cout<<"牛排"<<endl;
}
};
int main()
{
system("pause");
return 0;
}
（2）使用继承的父类代码
#include<iostream>
using namespace std;
class CPeople
{
int m_money;
void cost(int a)
{
m_money-=a;
}
};
class CYellowPeo:public CPeople
{
public:
void eat()
{
cout<<"五常大米"<<endl;
}
};
class CWhitePeo:public CPeople
{
public:
void eat()
{
cout<<"牛排"<<endl;
}
};
class CBackPeo:public CPeople
{
public:
void eat()
{
cout<<"牛排"<<endl;
}
};
int main()
{
system("pause");
return 0;
}
即对比上述代码可得到继承的好处如下：
将一些功能相似的公共成员，单独抽离出来形成一个类，这个类就是父类，子类继承父类，包含了这些公共的成员，即提高了代码的复用性、扩展性、后期更容易维护。
复用性：可重复使用的功能。
扩展性：只需在父类增加所需功能，其余子类不需更改。
10.4继承的方式：描述了父类成员在子类中所表现的属性。
（1）public:公有继承：
?????? 父类??????????????????????????? 子类????
<1>public??????????????????????? public
<2>protected????????????????? protected??
<3>private?????????????????????? 不可访问
实例代码
#include<iostream>
using namespace std;
class CFather
{
public:
int m_pub;
protected:
int m_pro;
private:
int m_pri;
};
class CSon:public CFather
{
public:
void show_public()
{
cout<<m_pub<<endl;
cout<<m_pro<<endl;
//cout<<m_pri<<endl;不可访问
}
};
class CSonson:public CSon
{
void show_test()
{
cout<<m_pro<<endl;
cout<<m_pub<<endl;
}
};
int main()
{
CSon son;
system("pause");
return 0;
}
（2）protected:保护继承
<1>public??????????????????????? protected??
<2>protected????????????????? protected??
<3>private?????????????????????? 不可访问
同理，私有的依旧不可访问
示例代码
#include<iostream>
using namespace std;
class CFather
{
public:
int m_pub;
protected:
int m_pro;
private:
int m_pri;
};
class CSon:protected CFather
{
public:
void show_protected()
{
cout<<m_pub<<endl;
cout<<m_pro<<endl;
//cout<<m_pri<<endl;
}
};
class CSonson:protected CSon
{
void show_test()
{
cout<<m_pro<<endl;
cout<<m_pub<<endl;
}
};
int main()
{
CSon son;
cout<<son.m_pro<<endl;
cout<<son.m_pub<<endl;
system("pause");
return 0;
}
（3）private：私有继承
<1>public??????????????????????? private
<2>protected????????????????? private
<3>private?????????????????????? 不可访问
均是不可访问
示例代码
#include<iostream>
using namespace std;
class CFather
{
public:
int m_pub;
protected:
int m_pro;
private:
int m_pri;
};
class CSon:private CFather
{
public:
void show_private()
{
cout<<m_pub<<endl;
cout<<m_pro<<endl;
//cout<<m_pri<<endl;
}
};
class CSonson:private CSon
{
void show_test()
{
cout<<m_pro<<endl;
cout<<m_pub<<endl;
}
};
int main()
{
CSon son;
cout<<son.m_pro<<endl;
cout<<son.m_pub<<endl;
system("pause");
return 0;
}
10.5隐藏
对于函数重载而言，我们调用的时候，可以根据参数类型、参数个数，编译器环境自动区分该具体调用的哪个函数，同样如果一个类小红存在两个同名函数（参数列表不同），那么也可以根据调用者传递的参数自动的区分执行哪个函数，因为这也是一个函数重载的关系。
那么对于父类和子类，如果有同名的函数但是参数列表不同，则不能够自动区分，因为他们之间的关系并不是函数重载的关系，作用域不同，必须使用类名：：去区分到底该调用哪个函数。子类中的重名函数我们谓之为隐藏。
示例代码
#include<iostream>
using namespace std;
class CFather
{
public:
void show(int a,int b,int c)
{
cout<<a<<" "<<b<<" "<<c<<endl;
}
};
class CSon:public CFather
{
public:
void show(int a)
{
cout<<a<<endl;
}
void show(int a,int b)
{
cout<<a<<" "<<b<<endl;
}
};
int main()
{
CSon son;
son.show(10);
son.show(10,20);
//son.show(10,20,30);
son.CFather::show(10,20,30);
system("pause");
return 0;
}
