十一、C++ 访问控制和继承

已于 2023-11-14 22:52:05 修改
阅读量46 收藏
点赞数
分类专栏： C++基础学习 文章标签： c++ 开发语言
于 2023-11-13 23:02:07 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/xhk951/article/details/134387559
版权

1.封装

a. 抽象出数据成员、成员函数

b. 访问控制

2.继承

private:外界不可见，不能直接访问

protected:外接不可见，不能直接访问；子类可以

public:外接可以直接访问

#include <iostream>
#include <string.h>
#include <unistd.h>

using namespace std;

class Person {
private:
	static int cnt;
	char *name;
	int age;

public:

	static int getCount(void); 

	Person() {//cout <<"Pserson()"<<endl;
		name = NULL;
		cnt++;
	}
	Person(char *name) 
	{
		//cout <<"Pserson(char *)"<<endl;
		this->name = new char[strlen(name) + 1];
		strcpy(this->name, name);
		cnt++;
	}

	Person(char *name, int age) 
	{
		cout <<"Pserson(char*, int), name = "<<name<<", age= "<<age<<endl;
		this->age = age;

		this->name = new char[strlen(name) + 1];
		strcpy(this->name, name);

		cnt++;
	}

	Person(Person &per) 
	{
		cout <<"Pserson(Person &)"<<endl;
		this->age = per.age;

		this->name = new char[strlen(per.name) + 1];
		strcpy(this->name, per.name);

		cnt++;
	}

	~Person()
	{
		cout << "~Person()"<<endl;
		if (this->name) {
			cout << "name = "<<name<<endl;
			delete this->name;
		}
	}

	void setName(char *name)
	{
		if (this->name) {
			delete this->name;
		}
		this->name = new char[strlen(name) + 1];
		strcpy(this->name, name);
	}
	int setAge(int a)
	{
		if (a < 0 || a > 150)
		{
			age = 0;
			return -1;
		}
		age = a;
		return 0;
	}
	void printInfo(void)
	{
		cout<<"name = "<<name<<", age = "<<age<<endl;
	}
};

int Person::cnt = 0; /* ����ͳ�ʼ�� */

int Person::getCount(void) 
{ 
	return cnt; 
}

class Student : public Person {
};


int main(int argc, char **argv)
{
	Student s;
	s.setName("zhangsan");
	s.setAge(16);
	s.printInfo();

	return 0;
}


执行结果：
name = zhangsan, age = 16
~Person
name = zhangsan

 public继承：

1.不能直接拿父亲的私房钱：派生类不能访问基类的私有成员

2.可以问父亲要钱：通过protected/public 的成员函数

#include <iostream>
#include <string.h>
#include <unistd.h>

using namespace std;

class Father {
private:
	int money;
public:
	void it_skill(void)
	{
		cout<<"father's it skill"<<endl;
	}

	int getMoney(void)
	{
		return money;
	}

	void setMoney(int money)
	{
		this->money = money;
	}
};

class Son : public Father {
private:
	int toy;
public:
	void play_game(void)
	{
		int m;
		
		cout<<"son paly game"<<endl;

		/* money -= 1; 
		 * 错：不能直接拿父亲的私房钱
		 */


        //但是可以问他要
		m = getMoney();
		m--;
		setMoney(m);
	}
};


int main(int argc, char **argv)
{
	Son s;

	s.setMoney(10);
	cout << s.getMoney()<<endl;

	s.it_skill();
	s.play_game();
	
	return 0;
}

2.儿子比外人要亲：派生类可以访问 protected成员，其他代码不可以

可以访问保护成员，不能在main函数里面访问

#include <iostream>
#include <string.h>
#include <unistd.h>

using namespace std;

class Father {
private:
	int money;

protected:
	int room_key;
	
public:
	void it_skill(void)
	{
		cout<<"father's it skill"<<endl;
	}

	int getMoney(void)
	{
		return money;
	}

	void setMoney(int money)
	{
		this->money = money;
	}
};

class Son : public Father {
private:
	int toy;
public:
	void play_game(void)
	{
		int m;
		
		cout<<"son paly game"<<endl;

		/* money -= 1; 
		 * 错：不能直接拿父亲的私房钱
		 */


        //但是可以问他要
		m = getMoney();
		m--;
		setMoney(m);

		
        //外人不能拿父亲的房门钥匙
        //儿子可以
		room_key = 1; 
	}
};


int main(int argc, char **argv)
{
	Son s;

	s.setMoney(10);
	cout << s.getMoney()<<endl;

	s.it_skill();
	s.play_game();

	//s.room_key = 1;    //不能在main函数里面访问
	
	return 0;
}

 3.调整访问控制

儿子继承来的财产，他可以捐给别人，也可以私藏

Son 可见到的成员，Son可以修改它的权限，

#include <iostream>
#include <string.h>
#include <unistd.h>

using namespace std;

class Father {
private:
	int money;

protected:
	int room_key;
	
public:
	void it_skill(void)
	{
		cout<<"father's it skill"<<endl;
	}

	int getMoney(void)
	{
		return money;
	}

	void setMoney(int money)
	{
		this->money = money;
	}
};

class Son : public Father {
private:
	int toy;
	//using Father::it_skill;  //可以，把它设为私有成员
    //using Father::room_key;  //可以，把它设为私有成员
public:
	using Father::room_key;   //可以，把它设为公有成员  
	//using Father::money;    //err
	
	void play_game(void)
	{
		int m;
		
		cout<<"son paly game"<<endl;


		m = getMoney();
		m--;
		setMoney(m);

		room_key = 1; 
	}
};


int main(int argc, char **argv)
{
	Son s;

	s.setMoney(10);
	cout << s.getMoney()<<endl;

	s.it_skill();
	s.play_game();

	s.room_key = 1;
	
	return 0;
}

 4.三种继承方式的差别

a.无论哪一种继承方式，在派生类内部使用父类时并无差别

b.不同的继承方式，会影响这两方面：外部代码对派生类的使用、派生类的子类怎么使用派生类的成员

 

 5.外部代码对派生类的使用

#include <iostream>
#include <string.h>
#include <unistd.h>

using namespace std;

class Father {
private:
	int money;

protected:
	int room_key;
	
public:
	int address;
	
	void it_skill(void)
	{
		cout<<"father's it skill"<<endl;
	}

	int getMoney(void)
	{
		return money;
	}

	void setMoney(int money)
	{
		this->money = money;
	}
};

class Son_pub : public Father {
private:
	int toy;
public:
	
	void play_game(void)
	{
		int m;
		
		cout<<"son play game"<<endl;

		m = getMoney();
		m--;
		setMoney(m);

		room_key = 1; 
	}
};


class Son_pro : protected Father {
private:
	int toy;
public:
	
	void play_game(void)
	{
		int m;
		
		cout<<"son play game"<<endl;


		m = getMoney();
		m--;
		setMoney(m);

		room_key = 1; 
	}
};


class Son_pri : private Father {
private:
	int toy;
public:
	
	void play_game(void)
	{
		int m;
		
		cout<<"son play game"<<endl;


		m = getMoney();
		m--;
		setMoney(m);

		room_key = 1; 
	}
};


int main(int argc, char **argv)
{
	Son_pub s_pub;
	Son_pro s_pro;
	Son_pri s_pri;

	s_pub.play_game();
	s_pro.play_game();
	s_pri.play_game();


	s_pub.it_skill();
	//s_pro.it_skill();  // error
	//s_pri.it_skill();	 // error

	return 0;
}

6.派生类的子类

#include <iostream>
#include <string.h>
#include <unistd.h>

using namespace std;

class Father {
private:
	int money;

protected:
	int room_key;
	
public:
	int address;
	
	void it_skill(void)
	{
		cout<<"father's it skill"<<endl;
	}

	int getMoney(void)
	{
		return money;
	}

	void setMoney(int money)
	{
		this->money = money;
	}
};

class Son_pub : public Father {
private:
	int toy;
public:
	
	void play_game(void)
	{
		int m;
		
		cout<<"son play game"<<endl;

		/* money -= 1; 
		 * ��: ����ֱ���ø��׵�˽��Ǯ
		 */

		/*
		 * ���ǿ�������Ҫ
		 */
		m = getMoney();
		m--;
		setMoney(m);

		room_key = 1; 
	}
};


class Son_pro : protected Father {
private:
	int toy;
public:
	
	void play_game(void)
	{
		int m;
		
		cout<<"son play game"<<endl;

		/* money -= 1; 
		 * ��: ����ֱ���ø��׵�˽��Ǯ
		 */

		/*
		 * ���ǿ�������Ҫ
		 */
		m = getMoney();
		m--;
		setMoney(m);

		room_key = 1; 
	}
};


class Son_pri : private Father {
private:
	int toy;
public:
	
	void play_game(void)
	{
		int m;
		
		cout<<"son play game"<<endl;

		/* money -= 1; 
		 * ��: ����ֱ���ø��׵�˽��Ǯ
		 */

		/*
		 * ���ǿ�������Ҫ
		 */
		m = getMoney();
		m--;
		setMoney(m);

		room_key = 1; 
	}
};

class Grandson_pub : public Son_pub {

public:
	void test(void) {
		room_key = 1; /* room_key is protected */ 
		address  = 2; /* address is public */ 
	}
};

class Grandson_pro : public Son_pro {

public:
	void test(void) {
		room_key = 1; /* room_key is protected */ 
		address  = 2; /* address is protected */ 
	}
};

class Grandson_pri : public Son_pri {

public:
	void test(void) {
		//room_key = 1;  // error
		//address  = 2;  // error
	}
};


int main(int argc, char **argv)
{
	Son_pub s_pub;
	Son_pro s_pro;
	Son_pri s_pri;

	s_pub.play_game();
	s_pro.play_game();
	s_pri.play_game();


	s_pub.it_skill();
	//s_pro.it_skill();  // error
	//s_pri.it_skill();	 // error

	Grandson_pub gs_pub;
	Grandson_pro gs_pro;

	gs_pub.address = 2;
	//gs_pro.address = 2;  // error

	return 0;
}

7.覆写

#include <iostream>
#include <string.h>
#include <unistd.h>

using namespace std;

class Father {
private:
	int money;

protected:
	int room_key;
	
public:
	void it_skill(void)
	{
		cout<<"father's it skill"<<endl;
	}

	int getMoney(void)
	{
		return money;
	}

	void setMoney(int money)
	{
		this->money = money;
	}
};

class Son : public Father {
private:
	int toy;
	//using Father::it_skill;
public:
	using Father::room_key;
	//using Father::money;
	
	void play_game(void)
	{
		int m;
		
		cout<<"son paly game"<<endl;

		/* money -= 1; 
		 * ��: ����ֱ���ø��׵�˽��Ǯ
		 */

		/*
		 * ���ǿ�������Ҫ
		 */
		m = getMoney();
		m--;
		setMoney(m);

		room_key = 1; 
	}

	/* ��д override */
	void it_skill(void)
	{
		cout<<"son's it skill"<<endl;
	}
	
};


int main(int argc, char **argv)
{
	Son s;

	s.setMoney(10);
	cout << s.getMoney()<<endl;

	s.it_skill();       //用的儿子的skill
	s.play_game();

	s.room_key = 1;
	
	return 0;
}

#include <iostream>
#include <string.h>
#include <unistd.h>

using namespace std;

class Person {
private:
	char *name;
	int age;

public:
	int address;
	
	Person() {//cout <<"Pserson()"<<endl;
		name = NULL;
	}
	Person(char *name) 
	{
		//cout <<"Pserson(char *)"<<endl;
		this->name = new char[strlen(name) + 1];
		strcpy(this->name, name);
	}

	Person(char *name, int age) 
	{
		cout <<"Pserson(char*, int), name = "<<name<<", age= "<<age<<endl;
		this->age = age;

		this->name = new char[strlen(name) + 1];
		strcpy(this->name, name);
	}

	Person(Person &per) 
	{
		cout <<"Pserson(Person &)"<<endl;
		this->age = per.age;

		this->name = new char[strlen(per.name) + 1];
		strcpy(this->name, per.name);
	}

	~Person()
	{
		cout << "~Person()"<<endl;
		if (this->name) {
			cout << "name = "<<name<<endl;
			delete this->name;
		}
	}

	void setName(char *name)
	{
		if (this->name) {
			delete this->name;
		}
		this->name = new char[strlen(name) + 1];
		strcpy(this->name, name);
	}
	int setAge(int a)
	{
		if (a < 0 || a > 150)
		{
			age = 0;
			return -1;
		}
		age = a;
		return 0;
	}
	void printInfo(void)
	{
		cout<<"name = "<<name<<", age = "<<age<<endl;
	}
};


class Student : public Person {
private:
	int grade;
	void setGrade(int grade) {this->grade = grade;}
	int getGrade(void) {return grade;}
public:
	void printInfo(void)
	{
		cout<<"Student ";
		Person::printInfo();  //不能直接打印父类的私有成员，可以调用父类的打印函数进行打印
	}
};

void test_func(Person &p)
{
	p.printInfo();
}

int main(int argc, char **argv)
{
	Person p("lisi", 16);

	Student s;
	s.setName("zhangsan");
	s.setAge(16);

	test_func(p);
	test_func(s); /* Person &p = s里面的Person部分;
	               * p引用的是"s里面的Person部分"
	               */
	s.printInfo();

	return 0;
}


执行结果：
Person(char*, int), name = lisi, age = 16
name = lisi, age = 16
name = zhangsan, age = 16    //调用的是person里面的函数
Student name = zhangsan, age = 16 
~Person()
name = zhangsan
~Person()
name = lisi

xhk951
关注
专栏目录
继承的访问控制（C++）
一只不努力还想前进的狗
07-27 358
派生类继承了基类中除了构造函数和析构函数之外的所有成员。 一.公有继承 1.基类的公有成员、保护成员在派生类中仍将保持原来的访问属性。 2.派生类的成员函数可以访问基类的公有成员和保护成员，但是不能访问基类的私有成员。 3.派生类以外的其他函数可以通过派生类的对象访问从基类继承来的公有成员。 二.保护继承 1.基类的公有成员、保护成员在派生类中都变成 protected 访问属性。 ...
C++中的访问控制与继承
razorEdge的博客
08-15 1614
访问控制与继承 在C++的继承体系中，每个类分别控制着其成员对于派生类来说是否可访问(accessible)。其中涉及到3种访控制修饰符，分别是public\protected\private，本篇文章来讨论关于C++继承中类成员可访问性的理解和判断。 继承体系中两个位置的访问说明符 下面首先给出一个表格清单： 从上面的表格中可以我们也可以清楚的知道，某个类对其继承而来的成员访问权限受...
C++类继承基础3——访问控制与继承
2301_80224556的博客
03-30 1362
我们看个例子我们看个例子。
深入理解C++继承：访问控制、虚函数机制和多重继承详解
BXA
05-08 1445
C++中访问控制通过 public、protected 和 private 关键字来实现。public 表示公开的可以被任何地方访问。protected 表示受保护的只有本类和其子类可以访问。private 表示私有的只有本类可以访问。 C++中的虚函数继承可以实现多态性。子类可以重载父类的虚函数，并且子类的对象可以看做是父类的对象从而实现多态性。 多重继承是 C++ 中的一个重要特性允许一个类从多个基类中继承属性和方法。在实现上如果一个类同时继承了多个基类就可能出现菱形继承问题。为了避免这种问题C++
C++访问权限以及继承权限方式
Lakers
01-30 1431
C++访问权限以及继承权限方式
C++继承中的访问控制实例分析
12-26
本文较为深入的探讨了C++继承中的访问控制，对深入掌握C++面向对象程序设计是非常必要的。具体内容如下： 通常来说，我们认为一个类有两种不同的用户：普通用户 和 类的实现者。其中，普通用户编写的代码使用类的...
C++ 类访问控制的条件总结
01-20
C++类的重要属性就是封装和继承。因此，最关键的问题就是权限 的问题，public，protected，private 控制的就是访问权限。 public protected private 类成员是否可以访问 Yes Yes Yes 友元函数是否可以访问...
C++ 访问控制
Chroniccandy的博客
08-25 940
什么是访问控制 C++标准中定义了三种类成员访问控制符 public, protected和private，分别译为公有的、保护的、私有的 这是在类的内部声明这三种控制符的意思 为什么需要访问控制 访问控制就是C++提供的一种用来保护类里的方法和属性的手端 保护-对谁可以调用某个方法和访问某个属性加上一个限制 如果某个对象试图调用一个它无权进行访问的函数 编译器将报错 控制符访问特点 （1）public成员：能被 本类的成员函数 （此类中任何类型的控制符声明的成员函数都可以访问）、友元函数、本类的对象、
【c++23种设计模式概述】
m0_45463480的博客
09-09 814
c++23种设计模式概述。
C语言作用域
天道酬勤
09-07 1029
作用域 (scope) 是描述程序可以访问标识符的区域。块是一对花括号 {} 括起来的区域 或 函数体内任意复合语句定义范围内的区域。定义在块中的变量具有块作用域。块作用域的变量的可见范围从定义处开始到该块定义范围的末尾为止。函数作用域是在整个函数体内可见的意思，在 C 程序中，函数形参和 goto 语句的标签具有函数作用域，在整个函数体内可见。在所有函数外定义的变量具有全局作用域，在整个程序都可见。在数据类型前加 static 关键字定义的全局变量具有文件作用域。
Linux和C语言（Day10）
weixin_65095004的博客
09-10 1053
实现特定功能的代码块定义函数： 存储类型 数据类型 函数名(参数列表){ 实现特定功能的代码块 }
＜C++＞ set、map模拟实现
prodigy623的博客
09-10 838
set、map仿STL模拟实现
C和指针：预处理(#include/define/if...)
暮色年华的博客
09-10 712
预处理器把所有name替换成 stuff。在程序中扩展#define定义符号和宏时，需要涉及几个步骤：1.在调用宏时，首先对参数进行检查，看看是否包含了任何由#define 定义的符号。如果是，它们首先被替换。2.替换文本随后被插入到程序中原来文本的位置。对于宏，参数名被它们的值所替代。3.最后，再次对结果文本进行扫描，看看它是否包含了任何由#define 定义的符号。如果是，就重复上述处理过程。这样，宏参数和#define 定义可以包含其他#define定义的符号。但是，宏不可以出现递归。
C++ #include ＜cstring＞（详解）
qq_51753728的博客
09-08 1036
是在 C++ 程序中引入头文件<cstring>的语句。这个头文件提供了用于处理 C 风格字符串（即以空字符'\0'结尾的字符数组）的函数。具体来说，<cstring>（1）strcpystrcpy是cstring中用于复制 C 风格字符串的函数，它将源字符串的内容复制到目标字符串中，包括末尾的空字符 ('\0'使用strcpy时需要确保目标数组有足够的空间来存放源字符串。source。
C 标准库 - `＜float.h＞`
wjs2024的博客
09-08 300
float.h>是 C 标准库中的一个头文件，它定义了与浮点数类型相关的宏。这些宏提供了关于浮点数的属性信息，如精度、最小和最大值、以及舍入误差等。这个头文件对于需要精确控制浮点数行为的程序非常有用，尤其是在数值计算和科学计算领域。<float.h>是 C 标准库中一个重要的头文件，它提供了关于浮点数的属性信息，对于需要精确控制浮点数行为的程序非常有用。掌握<float.h>中的宏，可以帮助开发者更好地理解和处理浮点数。
C语言程序设计(选择结构程序设计)
2301_79638883的博客
09-08 1331
条件运算符的执行顺序：先求解表达式１，若为非０（真），则求解表达式２，此时表达式２的值 就作为整个条件表达式的值。若表达式１的值为０（假），则求解表达式３，表达式３的值就是整个条 件表达式的值。
STL经典案例（四）——实验室预约综合管理系统（项目涉及知识点很全面，内容有点多，耐心看完会有收获的！）
beyond谚语的博客
09-08 441
高校实验室预约管理系统 管理员：创建实验室教师账号、学生账号、实验室；查看实验室教师、学校、实验室信息；清空所有学生的预约记录 学生：申请实验室预约、查看所有实验室预约 实验室教师：审核学生的申请、查看所有学生的实验室申请预约
C++（二）----类和对象
最新发布
weixin_73579966的博客
09-11 738
众所周知，C++与C语言不同的地方就是，C++引入了类和对象，可以在兼容C语言的同时面向对象编程，同时具备了封装、继承、多态三种特点（划重点）。面向对象可以说是C++最重要的部分了，而类和对象就是面向对象的基础，所以这一节我们学习类和对象。
C++继承恢复访问控制与继承机制详解
本课件主要讲解的是C++中的恢复访问控制方式，特别是针对基类中的public或protected成员，在通过protected或private继承时，可能会改变派生类中的访问权限。课程深入探讨了继承机制在C++中的应用，涉及以下几个关键...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值