c++ oop访问控制与继承

class Base

{

public:

Base() = default;

~Base(){}

friend class Pal;//pal在访问Base的派生类时不具有特殊性

int size()const { return count; }

protected:

int num;

private:

int count;

};

受保护成员protected

受保护成员对于类的用户不可访问

受保护成员对于派生类的成员和友元来说是可访问的

派生类的成员或友元只能通过派生类对象来访问基类的受保护成员

派生类对于一个基类对象中的受保护成员没有访问特权

class Sneaky : public Base

{

public:

friend void clobber(Sneaky&);

friend void clobber(Base&);

protected:

int s_num;

};

void clobber(Sneaky& s)

{

//正确：clobber可以访问Sneaky的私有成员和受保护成员

s.s_num = 0;

s.num = 0;

}

void clobber(Base& b)

{

//错误 clobber不能访问Base的受保护成员，因为它不是Base的友元函数

//b.num = 0;

}

友元与继承

友元关系是不允许继承的。

class Pal

{

public:

int f(Base b) { return b.num * b.count; }//正确 Pal是Base的友元

//int f2(Sneaky s) { return s.s_num; }//错误 Pal不是Sneaky的友元

//正确 对派生类中基类部分的访问权限受基类控制，Pal是Base的友元所以可以访问Sneaky中基类部分的成员。

int f3(Sneaky s) { return s.num; }

};

class Pal_Child : Pal

{

public:

int mem(Base b)

{

return b.num;//错误 友元关系不能继承，Pal_Child不是Base的友元，故不能访问。

}

};

改变个别成员的可访问性

派生类只能使用using改变基类中可以访问的成员，私有的成员不能使用using来改变访问权限

class Change : private Base //私有方式继承，继承来的成员都是私有的

{

public:

using Base::num;

protected:

using Base::size;

};

int main()

{

访问说明符

public：公有

private：私有

protected：受保护，只有派生类和友元可以访问

 

公有、私有和受保护继承

类对于继承而来的成员的访问权限受两个因素影响

一是在基类中该成员的访问说明符

二是在派生类的派生列表中访问权限的说明符

class Sneaky : public Base//公有方式继承，继承来的成员与基类中的受访问权限一样。

class Sneaky : private Base//私有方式继承，继承来的成员在Sneaky中都是私有的。

class Sneaky : protected Base//受保护继承，继承来的成员除私有的外其他都是受保护的。

 

如果基类的公有成员是可访问的，则派生类向基类的类型转换也是可以访问的，反之不行。

 

默认的继承保护

class Base {};

struct D1 :Base {};//默认public继承

class D2 :Base {};//默认private继承

 

继承中的类作用域

当存在继承关系时，派生类的作用域嵌套在其基类的作用域之内。

当编译器在派生类中无法找到作用域内的成员时，会在外层的基类的作用域中继续寻找。

是在编译时进行名字查找的

 

名字冲突与继承

派生类的成员将隐藏同名的基类成员

可以使用域作用符使用被隐藏的基类成员

class Base { public:int x; };

class D3 : public Base { public:int x; };

D3 d3;

cout << d3.x << endl;//打印的是D3自己定义的x

cout << d3.Base::x << endl;//打印的是Base的x

 

名字查找优先于类型检查

当有重名的成员函数时，在派生类中找到，即使形参列表不同也不会再继续在基类中查找。

 

虚函数与作用域

成员函数无论是否是虚函数都能被重载。

因为基类中的虚函数可能会被派生类覆盖，故以基类的类型调用虚函数时可能是派生类的版本。

class Base {

public:

virtual int fcn();

};

class D1 :public Base

{

public:

//隐藏基类的fcn，这个fcn不是虚函数

//D1继承了Base::fcn()的定义

int fcn(int);

virtual void f2();

};

class D2 :public D1

{

public:

int fcn(int);//覆盖一个非虚函数，隐藏了D1::fcn(int)

int fcn();//覆盖了Base的虚函数fcn

int f2();//覆盖了D1的虚函数f2

};

Base bobj;

D1 d1obj;

D2 d2obj;

 

Base* bp1 = &bobj, * bp2 = &d1obj, * bp3 = &d2obj;

bp1->fcn();//虚调用，将在运行时调用Base::fnc

bp2->fcn();//虚调用，将在运行时调用Base::fnc

bp3->fcn();//虚调用,将在运行时调用D2::fnc

 

D1* d1p = &d1obj;

D2 *b2p = &d2obj;

dp2->f2();//错误，Base没有f2

b1p->f2();//虚调用,将在运行时调用D1::f2

b2p->f2();//虚调用,麻将在运行时调用D2::f2

 

return 0;

}