C++-Record33—派生类的访问控制

最新推荐文章于 2023-03-30 11:22:55 发布

恋蛩音

最新推荐文章于 2023-03-30 11:22:55 发布

阅读量113

点赞数

分类专栏： C++基础课程笔记（传智扫地僧版本）

本文链接：https://blog.csdn.net/qq_17846375/article/details/104091412

版权

C++基础课程笔记（传智扫地僧版本）专栏收录该内容

44 篇文章 1 订阅

订阅专栏

单个类的访问控制

C++中的继承方式会影响子类的对外访问属性

派生类继承了基类的全部成员变量和成员方法（除了构造和析构之外的成员方法），但是这些成员的访问属性，在派生过程中是可以调整的。

单个类的访问控制

首先要明白：public： 修饰的成员变量方法在类的内部类的外部都能使用；protected: 修饰的成员变量方法,在类的内部使用 ,在继承的子类中可用 ;其他类的外部不能被使用；private: 修饰的成员变量方法只能在类的内部使用不能在类的外部。

注意在一个项目中，定义的两个文件中的类名如果有相同的，编译器可能会存在“串包”调用错误的风险，注意不要让类名重复。

万万注意：protected关键字是为了在家族中使用，就是为了继承而用的。

C++中的继承方式会影响子类的对外访问属性

public继承：父类成员在子类中保持原有访问级别

private继承：父类成员在子类中变为private成员

protected继承：父类中public成员会变成protected

父类中protected成员仍然为protected

父类中private成员仍然为private

private成员在子类中依然存在，但是却无法访问到。不论种方式继承基类，派生类都不能直接使用基类的私有成员。

举个例子，还是先定义一个父类：

class Parent
{
public:
			int a; //老爹的名字
protected:
			int b; //老爹的银行密码
private:
			int c; //老的情人
};

公有继承探究

公有继承，就说明子类跟父类是一致的，调用子类创建的对象，就是调用父类创建的对象。

class Child : public Parent
{
public:
	void useVar()
	{
		a = 0; //ok
		b = 0; //ok
		//c = 0; // err
	}

protected:
private:
};

void main21()
{
	Parent t1, t2;
	t1.a  = 10; //ok
	//t1.b = 20; //err
	//t2.c = 30 ; //err
	
	cout<<"hello..."<<endl;
	system("pause");
	return ;
}

私有继承探究

//私有继承
class Child2 : private Parent
{
public:
	void useVar()
	{
		a = 0; //ok
		b = 0; //ok
		//c = 0; // err
	}

protected:
private:
};

私有继承创建了一个子类，在子类中调用父类的公有属性，是可以的；调用父类的保护属性，是可以的；调用父类的私有属性是不可以的！

void main22()
{
	Child2 c2;
	//c1.a = 10; err
	//c2.b = 20; err
	//c3.b = 30;
}

通过主函来进行调用，由于是私有继承，那么子类中所调用到的所有父类属性，都是私有的，都不能通过外部直接访问，所以，只要涉及到的是父类的属性，都是不可以被调用的。

而c3是通过保护继承创建的，b本身是保护属性。保护属性很特殊，既不对外公开，也不对内公开，就是用来继承传递一些重要的属性来用。只能在保护继承的子类中调用父类的保护属性，才能成功！

保护继承探究

然后，通过保护继承的方式来创建一个子类，也可以说保护这个属性就是为了继承这个操作而准备的，看看子类的成员与父类的成员是什么关系：

class Child3 : protected Parent
{
public:
protected:
private:
public:	
	void useVar()
	{
		a = 0; // ok
		b = 0; // ok //b这这里 写在了子类Child3的内部  2看protected 3密码===>protected
		//c = 0; //err
	}
};

对于在保护继承的子类，可以调用父类的保护属性，但同样不能调用父类的私有属性。

通过主函来调用：

void main()
{
	Child3 c3;
	//c3.a = 10; //err
	//c3.b = 20; //err
	//c3.c = 30;//err

}

在保护继承的子类所创建的对象中，父类的属性对于子类来说，都是保护属性，不能通过外部来直接调用，故都不能通过创建的对象来使用。

保护属性很特殊，既不对外公开，也不对内公开，就是用来继承传递一些重要的属性来用。只能在保护继承的子类中调用父类的保护属性，才能成功！

判断总结

经过以上逐个的探查，现整理结论如下：

C++中的继承方式（public、private、protected）会影响子类的对外访问属性，判断某一句话，能否被访问，依据"三看"原则：

1）看调用语句，这句话写在子类的内部还是外部；

2）看子类如何从父类继承（public、private、protected）；

3）看父类中的访问级别（public、private、protected）；

C++中子类对外访问属性表

	父类成员访问级别
继承方式		public	proteced	private
	public	public	proteced	private
	proteced	proteced	proteced	private
	private	private	private	Private

其中，红色表明在父类中的成员属性；蓝色表示子类的继承方式。

派生类访问控制的结论：
1 protected 关键字修饰的成员变量和成员函数 ,是为了在家族中使用 ,是为了继承
2 项目开发中一般情况下是 public继承
3 只能在当前类中访问的成员设置为private

总体代码

dm02_单个类的访问控制.cpp

#include <iostream>
using namespace std;

//public 修饰的成员变量 方法 在类的内部 类的外部都能使用
//protected: 修饰的成员变量方法,在类的内部使用 ,在继承的子类中可用 ;其他 类的外部不能被使用
//private: 修饰的成员变量方法 只能在类的内部使用 不能在类的外部

//派生类访问控制的结论
//1 protected 关键字 修饰的成员变量 和成员函数 ,是为了在家族中使用 ,是为了继承
//2 项目开发中 一般情况下 是 public
//3


class Parent
{
public:
			int a; //老爹的名字
protected:
			int b; //老爹的银行密码
private:
			int c; //老的情人
};


//保护继承
class Child3 : protected Parent
{
public:
protected:
private:
public:	
	void useVar()
	{
		a = 0; // ok
		b = 0; // ok //b这这里 写在了子类Child3的内部  2看protected 3密码===>protected
		//c = 0; //err
	}
};

void main()
{
	Child3 c3;
	//c3.a = 10; //err
	//c3.b = 20; //err
	//c3.c = 30;//err

}



//私有继承
class Child2 : private Parent
{
public:
	void useVar()
	{
		a = 0; //ok
		b = 0; //ok
		//c = 0; // err
	}

protected:
private:
};

void main22()
{
	Child2 c2;
	//c1.a = 10; err
	//c2.b = 20; err
	//c3.b = 30;
}



class Child : public Parent
{
public:
	void useVar()
	{
		a = 0; //ok
		b = 0; //ok
		//c = 0; // err
	}

protected:
private:
};


/*
C++中的继承方式（public、private、protected）会影响子类的对外访问属性	
	判断某一句话，能否被访问
	1）看调用语句，这句话写在子类的内部、外部
	2）看子类如何从父类继承（public、private、protected）	
	3）看父类中的访问级别（public、private、protected）
*/
//共有继承 
void main21()
{
	Parent t1, t2;
	t1.a  = 10; //ok
	//t1.b = 20; //err
	//t2.c = 30 ; //err
	
	cout<<"hello..."<<endl;
	system("pause");
	return ;
}

dm03_派生类访问控制综合训练.cpp

//类的继承方式对子类对外访问属性影响

#include <cstdlib>
#include <iostream>

using namespace std;

class A
{
private:
	int a;
protected:
	int b;
public:
	int c;

	A()
	{
		a = 0;		b = 0;		c = 0;
	}

	void set(int a, int b, int c)
	{
		this->a = a;		this->b = b;		this->c = c;
	}
};
class B : public A
{
public:
	void print()
	{
		//cout<<"a = "<<a; //err
		cout<<"b = "<<b; //ok
		cout<<"c = "<<endl; //ok
	}
};

class C : protected A
{
public:
	void print()
	{
		//cout<<"a = "<<a; //err
		cout<<"b = "<<b; // ok
		cout<<"c = "<<endl; //ok
	}
};

class D : private A
{
public:
	void print()
	{
		//cout<<"a = "<<a; //err
		cout<<"b = "<<b<<endl;  //ok
		cout<<"c = "<<c<<endl; // ok
	}
};

int main()
{
	
	A aa;
	B bb;
	C cc;
	D dd;

	aa.c = 100;  //ok
	bb.c = 100; // ok
	//cc.c = 100; // err 保护的
	//dd.c = 100;  // err
	
	aa.set(1, 2, 3); //ok
	bb.set(10, 20, 30); //ok
	//cc.set(40, 50, 60); // err
	//dd.set(70, 80, 90);  //err
	

	bb.print(); //ok
	cc.print(); //ok
	dd.print(); //


	/**/
	system("pause");
	return 0;
}