1.继承方式
首先引入继承的语法:class 子类 : 继承方式 父类
1.1继承方式有三种:
1.public(公共继承)
2.protected(保护继承)
3.private(私有继承)
1.2三种继承方式的不同
1.public(公共继承):
子类继承父类的属性的时:
父类的public到子类依旧为public
父类的protected到子类依旧为protected
父类的private到子类依旧为private
2.protected(保护继承):
子类继承父类的属性的时:
父类的public到子类变为protected
父类的protected到子类依旧为protected
父类的private到子类依旧为private
3.private(私有继承):
子类继承父类的属性的时:
父类的public到子类变为protected
父类的protected到子类变为privat
父类的private到子类依旧为private
//我认为以上是最简洁明了的解释
1.3三种继承方式的子类对象在类外访问权限的不同
其实这个内容主要还是与“1.2三种继承方式的不同”有关:
1.若是public继承:
子类可以访问父类中public和protected的属性,不可访问父类中的private;
子类的对象可以访问父类中public和protected的属性,不可访问父类中的private;
2.若是protected继承:
子类可以访问父类中public和protected的属性,不可访问父类中的private;
子类的对象不可访问父类中public和protected的属性,也不可访问父类中的private;
3.若是private继承:
子类不可以直接访问父类中的任何属性。
子类的对象不可以直接访问父类中的任何属性。
eg:
#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()
{
m_A; //可访问 public权限
m_B; //可访问 protected权限
//m_C; //不可访问
}
};
void myClass()
{
Son1 s1;
s1.m_A; //其他类只能访问到公共权限
}
//保护继承
class Base2
{
public:
int m_A;
protected:
int m_B;
private:
int m_C;
};
class Son2:protected Base2
{
public:
void func()
{
m_A; //可访问 protected权限
m_B; //可访问 protected权限
//m_C; //不可访问
}
};
void myClass2()
{
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()
{
m_A; //可访问 private权限
m_B; //可访问 private权限
//m_C; //不可访问
}
};
class GrandSon3 :public Son3
{
public:
void func()
{
//Son3是私有继承,所以继承Son3的属性在GrandSon3中都无法访问到
//m_A;
//m_B;
//m_C;
}
};
2.继承中构造和析构的顺序
继承中:
先调用父类构造函数,再调用子类构造函数。
先调用子类析构函数,再调用父类析构函数。
eg:
#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 test01()
{
//继承中 先调用父类构造函数,再调用子类构造函数,析构顺序与构造相反
Son s;
}
int main() {
test01();
system("pause");
return 0;
}