#include<iostream>
//#include<memory>
using namespace std;
class Parent
{
public://访问控制权限
int pub;//在类的内部和外部都能访问
protected:
int pro;//在类的内部可以访问,在类的外部不能访问
private:
int pri;//在类的内部可以访问,在类的外部不能访问,
//在单个类中和protected一样
};
//规则1:只要是父类中的private成员,不管是什么方式,儿子都访问不了
//规则2:如果是公有(public)继承,儿子中的访问控制权限保持不变
//规则3:如果是保护(protected)继承,儿子中的父亲中除了private成员,其余都是protected
//规则4:如果是私有(private)继承,儿子中的父亲中除了private成员,其余在儿子中都是protected
//公有继承
class Child :public Parent//继承方式:公有继承
{
public:
void func()
{
cout << pub << endl;//pub父类的public成员变量,
//在public继承后,在子类【内部外部】都可以访问
cout << pro << endl;//pro父类的public成员变量,
//在public继承后,在子类【内部】可以访问,【外部】不可访问
//该类的儿子可以访问
//cout << pri << endl;//pri父类的public成员变量,
//在public继承后,在子类【内部外 部】都不可以访问
}
};
//保护继承
class Child2 :protected Parent
{
public:
void func2()
{
pub;//此时pub通过protected继承,能够在类的内部访问,
//类的外部不能访问,类的儿子可以访问,pub就是protected成员
pro;//pro 与 pub是一样的性质
//pri;//在子类【内部外 部】都不可以访问
}
};
class Child3 :private Parent
{
public:
void func3()
{
pub;//pub在类的内部可以访问,在类的外部不可以访问
//pub在该类的儿子中访问不了,说明pub在Child3中是私有成员
pro;//pro 与 pub性质一样,也是私有成员
//pri;//不可见
}
};
//三看原则:
//1.看调用的成员是在类的外部还是类的内部
//2.看儿子的继承方式
//3.当前变量在儿子中的变量在父类中的de访问控制权限
//一般都是使用公有继承
int main()
{
Child c1;
c1.func();
c1.pub;
//c1.pro;
return 0;
}
继承方式的练习
#include<iostream>
using namespace std;
class A
{
public:
int c;
A()
{
a = 0;
b = 0;
c = 0;
}
void set()
{
this->a = a;
this->b = b;
this->c = c;
}
protected:
int b;
private:
int a;
};
class B :public A
{
public:
void print()
{
//cout << "a = " << a;//a是父类私有成员,不可访问
cout << "b = " << b;//b此时是该类的保护成员,可以在类的内部访问
cout << " c = " << c << endl;//此时c是该类的公有成员,类的内部可以访问
}
};
class C :protected A
{
public:
void print()
{
//cout << "a = " << a;//a是父类私有成员,不可访问
cout << "b = " << b;//b此时是该类的保护成员,可以在类的内部访问
cout << " c = " << c << endl;//此时c是该类的保护成员,类的内部可以访问
}
};
class D :private A
{
public:
void print()
{
// cout << "a = " << a;//a是父类私有成员,不可访问
cout << "b = " << b;//b此时是该类的私有成员,可以在类的内部访问
cout << " c = " << c << endl;//c此时是该类的私有成员,可以在类的内部访问
}
};
int main()
{
A aa;
B bb;
C cc;
D dd;
aa.c =100;//c在A类中是公有,类的外部可以访问。
bb.c = 100;//c在B类中是公有,类的外部可以访问。
// cc.c = 100;//c在C类中是保护,类的外部不可以访问。
// dd.c = 100;//c在D类中是私有,类的外部不可以访问。
aa.set();//set方法在A类中是公有方法,类的外部可以访问
bb.set();//set方法在B类中是公有方法,类的外部可以访问
//cc.set();//set方法在C类中是保护方法,类的外部不可以访问
// dd.set();//set方法在A类中是私有方法,类的外部不可以访问
bb.print();//print是定义在B类的public成员函数,在类的外部可以访问
cc.print();//print是定义在C类的public成员函数,在类的外部可以访问
dd.print();//print是定义在D类的public成员函数,在类的外部可以访问
return 0;
}
总结:
规则1:只要是父类中的private成员,不管是什么方式,儿子都访问不了
规则2:如果是公有(public)继承,儿子中的访问控制权限保持不变
规则3:如果是保护(protected)继承,儿子中的父亲中除了private成员,其余都是protected
规则4:如果是私有(private)继承,儿子中的父亲中除了private成员,其余在儿子中都是private成员