c++ 类的访问权限探讨

最新推荐文章于 2024-01-03 23:09:08 发布
最新推荐文章于 2024-01-03 23:09:08 发布
阅读量895 收藏 1
点赞数
分类专栏： c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/bluemaths/article/details/8691488
版权

1. 在类域外部（非类域中），类对象访问自身接口和成员的限制，示例如下。

#include <stdlib.h>
#include <iostream>

using namespace std;

class fruit
{
public:
	fruit(int id, int count, int price)
		:m_count(count), m_price(price), m_id(id)
	{
	}

	int count()
	{
		return m_count;
	}

public:
	int m_count;

protected:
	int price()
	{
		return m_price;
	}

protected:
	int m_price;

private:

	int id()
	{
		return m_id;
	}

private:
	int m_id;
};

int main(int argc, char **argv)
{
	fruit FRUIT_1(000, 100, 15);

	cout << "FRUIT_1.m_count" << FRUIT_1.m_count << endl;
	cout << "FRUIT_1.count()" << FRUIT_1.count() << endl;

	cout << "FRUIT_1.m_price" << FRUIT_1.m_price << endl;
	cout << "FRUIT_1.price()" << FRUIT_1.price() << endl;

	cout << "FRUIT_1.m_id" << FRUIT_1.m_id << endl;
	cout << "FRUIT_1.id()" << FRUIT_1.id() << endl;
}
编译时报错，如下，可见在类域外部，类对象只能访问声明为public的接口。


2. 在自身的类域中，类对象访问自身接口和成员的限制，示例如下：

#include <stdlib.h>
#include <iostream>

using namespace std;

class fruit
{
public:
	fruit(int id, int count, int price)
		:m_count(count), m_price(price), m_id(id)
	{
	}

	int count()
	{
		return m_count;
	}

	// 访问自身类对象的public成员
	int other_count_member(fruit other)
	{
		return other.m_count;
	}

	// 访问自身类对象的protected成员
	int other_price_member(fruit other)
	{
		return other.m_price;
	}

	// 访问自身类类对象的private成员
	int other_id_member(fruit other)
	{
		return other.m_id;
	}

	// 访问自身类对象的public函数
	int other_count_func(fruit other)
	{
		return other.count();
	}

	// 访问自身类对象的protected函数
	int other_price_func(fruit other)
	{
		return other.price();
	}

	// 访问自身类对象的private函数
	int other_id_func(fruit other)
	{
		return other.id();
	}

public:
	int m_count;

protected:
	int price()
	{
		return m_price;
	}

protected:
	int m_price;

private:

	int id()
	{
		return m_id;
	}

private:
	int m_id;
};

int main(int argc, char **argv)
{
	fruit FRUIT_1(111, 100, 10);
	fruit FRUIT_2(222, 200, 20);

	cout << "FRUIT_1.other_count_member(FRUIT_2):" << FRUIT_1.other_count_member(FRUIT_2) << endl;
	cout << "FRUIT_1.other_count_func(FRUIT_2):" << FRUIT_1.other_count_func(FRUIT_2) << endl;

	cout << "FRUIT_1.other_price_member(FRUIT_2):" << FRUIT_1.other_price_member(FRUIT_2) << endl;
	cout << "FRUIT_1.other_price_func(FRUIT_2):" << FRUIT_1.other_price_func(FRUIT_2) << endl;

	cout << "FRUIT_1.other_id_member(FRUIT_2):" << FRUIT_1.other_id_member(FRUIT_2) << endl;
	cout << "FRUIT_1.other_id_func(FRUIT_2):" << FRUIT_1.other_id_func(FRUIT_2) << endl;
}

可以正确编译，运行结果如下，可见在自身的类域中，类对象的所有成员和接口都是可见的。


3. 在其他类域（非继承关系）中，类对象访问自身的接口和成员的限制，示例如下

#include <stdlib.h>
#include <iostream>

using namespace std;

class book
{
public:
	book(int count, int price, int id)
		:m_count(count), m_price(price), m_id(id)
	{
	}

	int count()
	{
		return m_count;
	}

public:
	int m_count;

protected:
	int price()
	{
		return m_price;
	}

protected:
	int m_price;

private:
	int id()
	{
		return m_id;
	}

private:
	int m_id;
};

class fruit
{
public:
	fruit(int id, int count, int price)
		:m_count(count), m_price(price), m_id(id)
	{
	}

	int count()
	{
		return m_count;
	}

	// 访问其他类对象的public成员
	int other_count_member(book other)
	{
		return other.m_count;
	}
	
	// 访问其他类对象的public函数
	int other_count_func(book other)
	{
		return other.count();
	}

	// 访问其他类对象的protected成员
	int other_price_member(book other)
	{
		return other.m_price;
	}

	// 访问其他类对象的protected函数
	int other_price_func(book other)
	{
		return other.price();
	}

	// 访问其他类类对象的private成员
	int other_id_member(book other)
	{
		return other.m_id;
	}

	// 访问其他类对象的private函数
	int other_id_func(book other)
	{
		return other.id();
	}

public:
	int m_count;

protected:
	int price()
	{
		return m_price;
	}

protected:
	int m_price;

private:

	int id()
	{
		return m_id;
	}

private:
	int m_id;
};

int main(int argc, char **argv)
{
	fruit FRUIT_1(111, 100, 10);
	book BOOK_1(222, 200, 20);

	cout << "FRUIT_1.other_count_member(BOOK_1):" << FRUIT_1.other_count_member(BOOK_1) << endl;
	cout << "FRUIT_1.other_count_func(BOOK_1):" << FRUIT_1.other_count_func(BOOK_1) << endl;

	cout << "FRUIT_1.other_price_member(BOOK_1):" << FRUIT_1.other_price_member(BOOK_1) << endl;
	cout << "FRUIT_1.other_price_func(BOOK_1):" << FRUIT_1.other_price_func(BOOK_1) << endl;

	cout << "FRUIT_1.other_id_member(BOOK_1):" << FRUIT_1.other_id_member(BOOK_1) << endl;
	cout << "FRUIT_1.other_id_func(BOOK_1):" << FRUIT_1.other_id_func(BOOK_1) << endl;
}
编译时出错，如下，可见在非继承关系的类中，其他类对象只有public成员或接口是可见的。


4. 在子类的域中，父类对象的成员和接口的访问限制，示例如下

（1）访问自身基类对象的成员

#include <stdlib.h>
#include <iostream>

using namespace std;

class fruit
{
public:
	fruit(int count, int price, int id)
		:m_count(count), m_price(price), m_id(id)
	{
	}

	int count()
	{
		return m_count;
	}

public:
	int m_count;

protected:
	int price()
	{
		return m_price;
	}

protected:
	int m_price;

private:
	int id()
	{
		return m_id;
	}

private:
	int m_id;
};

class apple:public fruit
{
public:
	apple(int count, int price, int id)
		:fruit (count, price, id)
	{
	}

	// 访问基类的public成员
	int base_public_member()
	{
		return m_count;
	}
	
	// 访问基类的public函数
	int base_public_func()
	{
		return count();
	}

	// 访问基类的protected成员
	int base_protected_member()
	{
		return m_price;
	}

	// 访问基类的protected函数
	int base_protected_func()
	{
		return price();
	}

	// 访问基类的private成员
	int base_private_member()
	{
		return m_id;
	}

	// 访问基类的private函数
	int base_private_func()
	{
		return id();
	}
};

int main(int argc, char **argv)
{
	apple APPLE_1(111, 100, 10);

	cout << "APPLE_1.base_public_member():" << APPLE_1.base_public_member() << endl;
	cout << "APPLE_1.base_public_func():" << APPLE_1.base_public_func() << endl;

	cout << "APPLE_1.base_protected_member():" << APPLE_1.base_protected_member() << endl;
	cout << "APPLE_1.base_protected_func():" << APPLE_1.base_protected_func() << endl;

	cout << "APPLE_1.base_private_member():" << APPLE_1.base_private_member() << endl;
	cout << "APPLE_1.base_private_func():" << APPLE_1.base_private_func() << endl;
}
编译报错，如下，可见默认情况下，自身子类对象只能访问父类的public，protected 成员和接口，private 接口和成员不可见。


（2）访问其他基类对象的成员，示例如下

#include <stdlib.h>
#include <iostream>

using namespace std;

class fruit
{
public:
	fruit(int count, int price, int id)
		:m_count(count), m_price(price), m_id(id)
	{
	}

	int count()
	{
		return m_count;
	}

public:
	int m_count;

protected:
	int price()
	{
		return m_price;
	}

protected:
	int m_price;

private:
	int id()
	{
		return m_id;
	}

private:
	int m_id;
};

class apple:public fruit
{
public:
	apple(int count, int price, int id)
		:fruit (count, price, id)
	{
	}

	// 访问基类的public成员
	int base_public_member(fruit other)
	{
		return other.m_count;
	}
	
	// 访问基类的public函数
	int base_public_func(fruit other)
	{
		return other.count();
	}

	// 访问基类的protected成员
	int base_protected_member(fruit other)
	{
		return other.m_price;
	}

	// 访问基类的protected函数
	int base_protected_func(fruit other)
	{
		return other.price();
	}

	// 访问基类的private成员
	int base_private_member(fruit other)
	{
		return other.m_id;
	}

	// 访问基类的private函数
	int base_private_func(fruit other)
	{
		return other.id();
	}
};

int main(int argc, char **argv)
{
	fruit FRUIT_1(111, 100, 10);
	apple APPLE_1(222, 200, 20);

	cout << "APPLE_1.base_public_member(fruit FRUIT_1):" << APPLE_1.base_public_member(FRUIT_1) << endl;
	cout << "APPLE_1.base_public_func(fruit FRUIT_1):" << APPLE_1.base_public_func(FRUIT_1) << endl;

	cout << "APPLE_1.base_protected_member(fruit FRUIT_1):" << APPLE_1.base_protected_member(FRUIT_1) << endl;
	cout << "APPLE_1.base_protected_func(fruit FRUIT_1):" << APPLE_1.base_protected_func(FRUIT_1) << endl;

	cout << "APPLE_1.base_private_member(fruit FRUIT_1):" << APPLE_1.base_private_member(FRUIT_1) << endl;
	cout << "APPLE_1.base_private_func(fruit FRUIT_1):" << APPLE_1.base_private_func(FRUIT_1) << endl;
}
编译报错，如下，可见访问基类的对象时，仿佛访问的是陌生类的对象一样，只能访问其 public 的成员和接口。


5. 父类的域中，子类对象的成员和接口访问限制

（1）在父类域中访问子类对象的成员和接口的限制。

#include <stdlib.h>
#include <iostream>

using namespace std;

class fruit;

class apple:public fruit
{
public:
	apple(int count, int price, int id)
		:m_count(count), m_price(price), m_id(id)
	{
	}

	int count()
	{
		return m_count;
	}

public:
	int m_count;

protected:
	int price()
	{
		return m_price;
	}

protected:
	int m_price;

private:
	int id()
	{
		return m_id;
	}

private:
	int m_id;
};

class fruit
{
public:
	// 访问子类的public成员
	int derived_public_member(apple &other)
	{
		return other.m_count;
	}

	// 访问子类的public函数
	int derived_public_func(apple &other)
	{
		return other.count();
	}

	// 访问子类的protected成员
	int derived_protected_member(apple &other)
	{
		return other.m_price;
	}

	// 访问子类的protected函数
	int derived_protected_func(apple &other)
	{
		return other.price();
	}

	// 访问子类的private成员
	int derived_private_member(apple &other)
	{
		return other.m_id;
	}

	// 访问子类的private函数
	int derived_private_func(apple &other)
	{
		return other.id();
	}
};

int main(int argc, char **argv)
{
	fruit FRUIT_1;
	apple APPLE_1(222, 200, 20);

	cout << "FRUIT_1.derived_public_member(fruit FRUIT_1):" << FRUIT_1.derived_public_member(APPLE_1) << endl;
	cout << "FRUIT_1.derived_public_func(fruit FRUIT_1):" << FRUIT_1.derived_public_func(APPLE_1) << endl;

	cout << "FRUIT_1.derived_protected_member(fruit FRUIT_1):" << FRUIT_1.derived_protected_member(APPLE_1) << endl;
	cout << "FRUIT_1.derived_protected_func(fruit FRUIT_1):" << FRUIT_1.derived_protected_func(APPLE_1) << endl;

	cout << "FRUIT_1.derived_private_member(fruit FRUIT_1):" << FRUIT_1.derived_private_member(APPLE_1) << endl;
	cout << "FRUIT_1.derived_private_func(fruit FRUIT_1):" << FRUIT_1.derived_private_func(APPLE_1) << endl;
}

编译出错，可见父类域中访问子类对象的接口，如同陌生类一样，非public接口均不可访问。


（2）父类域中，仅仅访问子类对象的public接口，能否成功呢？如下

#include <stdlib.h>
#include <iostream>

using namespace std;

class fruit;

class apple:public fruit
{
public:
	apple(int count, int price, int id)
		:m_count(count), m_price(price), m_id(id)
	{
	}

	int count()
	{
		return m_count;
	}

public:
	int m_count;

protected:
	int price()
	{
		return m_price;
	}

protected:
	int m_price;

private:
	int id()
	{
		return m_id;
	}

private:
	int m_id;
};

class fruit
{
public:
	// 访问子类的public成员
	int derived_public_member(apple &other)
	{
		return other.m_count;
	}

	// 访问子类的public函数
	int derived_public_func(apple &other)
	{
		return other.count();
	}

	 访问子类的protected成员
	//int derived_protected_member(apple &other)
	//{
	//	return other.m_price;
	//}

	 访问子类的protected函数
	//int derived_protected_func(apple &other)
	//{
	//	return other.price();
	//}

	 访问子类的private成员
	//int derived_private_member(apple &other)
	//{
	//	return other.m_id;
	//}

	 访问子类的private函数
	//int derived_private_func(apple &other)
	//{
	//	return other.id();
	//}
};

int main(int argc, char **argv)
{
	fruit FRUIT_1;
	apple APPLE_1(222, 200, 20);

	cout << "FRUIT_1.derived_public_member(fruit FRUIT_1):" << FRUIT_1.derived_public_member(APPLE_1) << endl;
	cout << "FRUIT_1.derived_public_func(fruit FRUIT_1):" << FRUIT_1.derived_public_func(APPLE_1) << endl;

	//cout << "FRUIT_1.derived_protected_member(fruit FRUIT_1):" << FRUIT_1.derived_protected_member(APPLE_1) << endl;
	//cout << "FRUIT_1.derived_protected_func(fruit FRUIT_1):" << FRUIT_1.derived_protected_func(APPLE_1) << endl;

	//cout << "FRUIT_1.derived_private_member(fruit FRUIT_1):" << FRUIT_1.derived_private_member(APPLE_1) << endl;
	//cout << "FRUIT_1.derived_private_func(fruit FRUIT_1):" << FRUIT_1.derived_private_func(APPLE_1) << endl;
}
编译报错，说fruit类不完全。看来，要在父类中调用子类的接口是不太可能的了，因为两者是继承关系，父类要调用子类的接口，必须先定义子类，但是子类的定义依赖父类的定义，所以这样就陷入类似死锁的情况。不过这种需求也是没有必要的。



总结一下：

（1）类域中，可以访问自身对象和此类的外部对象的所有成员和接口。

（2）继承关系的类域中，子类只能访问自身对象的基类的 public 和 protected 成员和接口

（3）继承关系的类域中，子类仅能访问其他的基类对象的 public 成员和接口

（4）继承关系的类域和，父类不能访问任何子类的成员和接口

（5）非继承关系的类域 以及 非类域中，仅能访问类对象的public成员和接口。


后续有新的发现再更新

bluemaths
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C++ 类的公用接口与私有实现分离（信息屏蔽）
chenxiansheng的博客
03-20 1211
//class.hpp class Student { private: //私有成员，只能通过公用接口访问 int num, score; public: //公用接口 void setdata(); //在类体内，只声明对外接口，而将具体实现定义在另一个文件 void display(); }; //class.cpp #include <io...
c++类的定义及类成员的访问控制
as745471的博客
09-15 607
类的定义 在c++中，类的定义方法如下 class 类名{ 访问范围说明符： 成员变量1 成员变量2 成员函数声明1 成员函数声明2 访问范围说明符： 更多成员变量 更多成员函数声明 ... }; 类的定义要以;结束。 类的基本思想是数据抽象和封装。数据抽象是一种把接口和实现分离的编程...
c++访问权限的控制
IT3689的博客
07-15 283
不同继承方式的影响主要体现在： 1、派生类成员对基类成员的访问控制。 2、派生类对象对基类成员的访问控制。 三种继承方式： 1、公有继承（public） ① 基类的public和protected成员的访问属性在派生类中保持不变，但基类的private成员不可访问。 ② 派生类中的成员函数可以直接访问基类中的public和protected成员，但不能访问基类的private成员。
c++学习笔记--book类的小结
Qin_xian_shen的博客
03-16 947
用这个book类简单总结了之前关于友元，内敛，复制构造函数 注释写了注意事项 #include #include using namespace std; class book{ private:     double price;     int date; public:     book():price(0),date(0){};     
C++ 类访问控制public/private/protected探讨
guotenfei的专栏
11-04 948
C++ 类访问控制public/private/protected探讨 摘要：本文是从饮水思源BBS C/C++版上一篇帖子引发的思考。当时看到帖子，突然觉得平时见惯了的，在这里似乎变得陌生了，究竟访问控制符怎样起作用，怎样使用，该怎样理解，本文试图给出讨论。 原帖如下  1 #include   2 using namespace std;  3   4 clas
C++类和对象初步探讨
m0_67789136的博客
08-11 228
类体用来声明类的成员，包括数据成员和成员函数，分别描述类所表达的属性和行为。关键词public，protected和private称为访问权限控制符，他们限制了类成员的访问控制范围。在类体内，出现的顺序和次数没有限制但在实际使用 中，一般先在类体内声明公有成员，再声明私有成员 ，公有成员是用户关心的。类的定义构成一般分为说明部分和实现部分。说明部分放在类体内，用来说明该类中的数据成员和成员函数的类型和名称。实现部分常放再类外，用以给出部分中声明的成员函数的定义，是类的内部实现。...
c++类全面讲解
最新发布
shopeeai的博客
01-03 1488
这次主要讲类的基础、构造函数与析构函数的使用，以及继承和多态。这次从类的基础知识开始，讲了构造函数、析构函数、以及类的成员变量和方法。接着，讲了重载构造函数、拷贝构造函数、赋值运算符以及静态成员。然后讲了继承、多态、友元类和友元函数。最后模板类的概念，还有一些高级特性的基本概念。
C++类的继承
小怪物爱吹牛的博客
11-23 5364
C/C++文件读写引言新的改变功能快捷键合理的创建标题，有助于目录的生成如何改变文本的样式插入链接与图片如何插入一段漂亮的代码片生成一个适合你的列表创建一个表格设定内容居中、居左、居右SmartyPants创建一个自定义列表如何创建一个注脚注释也是必不可少的KaTeX数学公式新的甘特图功能，丰富你的文章UML 图表FLowchart流程图导出与导入导出导入 引言 你好！ 这是你第一次使用 Mark...
如何通过指针突破C++类的访问权限
12-20
本文将详细探讨如何通过指针在C++中突破类的访问权限。 首先，理解C++类的访问控制规则至关重要。`private`成员变量只能在类的内部被访问，而不能在类外部直接访问。在示例代码中，`A`类的`m_a`和`m_b`被声明为`...
C++ 类访问控制public、private、protected探讨.docx
02-27
对象通过成员函数和 this 指针来操作自身的数据成员，而成员函数则可以访问其他对象的数据成员，前提是它们有适当的访问权限。 总结，C++ 中的访问控制是基于类的，而不是基于对象的，允许同类对象之间通过公共成员...
C++ 类访问控制public、private、protected探讨.pdf
02-27
`protected`成员的访问权限介于`public`和`private`之间。它对类的成员函数和派生类的成员函数开放，但在类的外部不能直接访问。在类`A`中，`int j`是一个`protected`成员，这意味着虽然在`main`函数中我们不能直接...
c++继承分类
04-28
6. 继承中的访问控制：解释公有继承、保护继承和私有继承的区别，以及它们对子类访问权限的影响。 7. 小结和最佳实践：总结继承的使用场景，提供关于何时以及如何使用继承的最佳实践。 通过学习这个视频教程，你将...
c++获取system权限代码
03-09
这个“c++获取system权限代码”是为了解决这类问题而设计的。下面将详细介绍如何在C++中获取系统权限，并探讨相关的安全性和实践注意事项。 首先，我们要明确一点：在大多数现代操作系统中，如Windows和Linux，为了...
c++类与对象
一怀明月的博客
03-08 1023
每一个实体都是对象。有一些对象是具有相同的结构和特性的。每个对象都属于一个特定的类型。在C++中对象的类型称为类(class )。类代表了某一批对象的共性和特征。类是对象的抽象，而对象是类的具体实例(instance)。 正如同结构体类型和结构体变量的关系一样，人们先声明一个结构体类型，然后用它去定义结构体变量。同一个结构体类型可以定义出多个不同的结构体变量。 在C然后++中也是先声明一个类类型，用它去定义若干个同类型的对象。对象就是类类型的一个变量。可以说类是对象的模板，是用来定义对象的一种抽象类型。类是
未定义的宏的值是多少？
bluemaths的专栏
03-19 2483
经常在定义头文件时， 加一个如下所示的宏定义，避免重复包含。 查看网络上的一些博客，说此处未定义的宏_TEST_H_的值是1，此文将探究一下此值到底是不是1。 #ifndef _TEST_H_ #define _TEST_H_ class test { ... }; #endif （1）定义其值为1，进行赋值等。 #include #include using namesp
c++ 类成员可以是引用吗？
bluemaths的专栏
03-08 2352
引用，即别名。定义引用对象时，并没有对其分配内存，它与原对象对应的是同一个内存地址的对象。 c++ 类成员，可以是引用。 1. 普通引用和类成员的引用 #include #include using namespace std; class fruit { public: fruit(int &id):m_id(id) { cout << "&id:
c++默认赋值操作符
bluemaths的专栏
01-08 1587
包含内置类型的类的默认赋值操作符，会对每一个成员逐一赋值。如下。 #include #include #include struct UNIT { int total; int used; char name[10]; }; int main() { UNIT test, asign; test.total = 100; test.used = 40; strcpy
C++类中成员访问详解：数据封装与权限控制
然而，为了控制对外部的可见性，C++提供了三种访问权限：public（公共）、private（私有）和protected（保护）。 - **Public成员**：默认为public，可以在类的任何地方访问，包括类的外部。这种方式使得类的接口...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值