C++中的访问修饰符-yiteyi-C++库

访问修饰符用于实现面向对象编程的一个重要方面，即 数据隐藏 考虑一个真实的例子：拥有10名核心成员的研究与分析部（R&AW）掌握了有关国家安全的敏感机密信息。现在我们可以将这些核心成员与一个类的数据成员或成员函数相关联，而这个类又可以与R&a wing相关联。这10名成员可以直接从他们的分支机构（该类）访问机密信息，但除这10名成员之外的任何人都不能直接访问该信息，即除该类内部普遍存在的功能之外的外部功能不能访问无权访问的信息，既没有被分配的特权（如friend类和inherited类拥有的特权，本文将在前面介绍），也没有访问这10个成员中允许直接访问机密信息的一个（类似于通过直接访问私有成员的类的公共成员函数在外部世界访问类的私有成员）。这就是数据隐藏在实践中的意义。中的访问修饰符或访问说明符班用于将可访问性分配给类成员。也就是说，它对类成员设置了一些限制，使其不能被外部函数直接访问。 C++中有三种类型的访问修饰符：

null

平民的
私有的
受保护的

笔记：如果我们没有为类内的成员指定任何访问修饰符，那么默认情况下，成员的访问修饰符将为 私有的 .

现在让我们详细了解这些访问修饰符： 1.公众 ：所有在公共说明符下声明的类成员都将对所有人可用。声明为公共的数据成员和成员函数也可以被其他类和函数访问。使用直接成员访问操作符（.）可以从程序中的任何位置访问类的公共成员和那个类的对象。

例子：

CPP

                         // C++ program to demonstrate public                       
                         // access modifier                       
           
                         #include<iostream>                       
                         using                                     namespace                                     std;                       
           
                         // class definition                       
                         class                                     Circle                       
                         {                       
                                                 public                                     :                       
                                                 double                                     radius;                       
                                   
                                                 double                                     compute_area()                       
                                                 {                       
                                                 return                                     3.14*radius*radius;                       
                                                 }                       
                                   
                         };                       
           
                         // main function                       
                         int                                     main()                       
                         {                       
                                                 Circle obj;                       
                                   
                                                 // accessing public datamember outside class                       
                                                 obj.radius = 5.5;                       
                                   
                                                 cout <<                                     "Radius is: "                                     << obj.radius <<                                     ""                                     ;                       
                                                 cout <<                                     "Area is: "                                     << obj.compute_area();                       
                                                 return                                     0;                       
                         }                       

输出：

Radius is: 5.5Area is: 94.985

在上面的程序中，数据成员半径声明为public，因此可以在类外部访问它，因此允许从main（）内部访问。 2.私人 当前位置声明为 私有的 只能由类中的成员函数访问。类之外的任何对象或函数都不允许直接访问它们。只有成员或好友功能允许访问类的私有数据成员。

例子：

CPP

                         // C++ program to demonstrate private                       
                         // access modifier                       
           
                         #include<iostream>                       
                         using                                     namespace                                     std;                       
           
                         class                                     Circle                       
                         {                       
                                                 // private data member                       
                                                 private                                     :                       
                                                 double                                     radius;                       
                                   
                                                 // public member function                       
                                                 public                                     :                       
                                                 double                                     compute_area()                       
                                                 {                                     // member function can access private                       
                                                 // data member radius                       
                                                 return                                     3.14*radius*radius;                       
                                                 }                       
                                   
                         };                       
           
                         // main function                       
                         int                                     main()                       
                         {                       
                                                 // creating object of the class                       
                                                 Circle obj;                       
                                   
                                                 // trying to access private data member                       
                                                 // directly outside the class                       
                                                 obj.radius = 1.5;                       
                                   
                                                 cout <<                                     "Area is:"                                     << obj.compute_area();                       
                                                 return                                     0;                       
                         }                       

输出 :

 In function 'int main()':11:16: error: 'double Circle::radius' is private         double radius;                ^31:9: error: within this context     obj.radius = 1.5;         ^

上述程序的输出是编译时错误，因为我们不允许直接在类之外访问类的私有数据成员。然而，我们有机会接触到obj。radius被尝试，radius是一个私有数据成员，我们得到一个编译错误。

但是，我们可以使用类的公共成员函数间接访问类的私有数据成员。

例子：

CPP

                         // C++ program to demonstrate private                       
                         // access modifier                       
           
                         #include<iostream>                       
                         using                                     namespace                                     std;                       
           
                         class                                     Circle                       
                         {                       
                                                 // private data member                       
                                                 private                                     :                       
                                                 double                                     radius;                       
                                   
                                                 // public member function                       
                                                 public                                     :                       
                                                 void                                     compute_area(                                     double                                     r)                       
                                                 {                                     // member function can access private                       
                                                 // data member radius                       
                                                 radius = r;                       
                                   
                                                 double                                     area = 3.14*radius*radius;                       
                                   
                                                 cout <<                                     "Radius is: "                                     << radius << endl;                       
                                                 cout <<                                     "Area is: "                                     << area;                       
                                                 }                       
                                   
                         };                       
           
                         // main function                       
                         int                                     main()                       
                         {                       
                                                 // creating object of the class                       
                                                 Circle obj;                       
                                   
                                                 // trying to access private data member                       
                                                 // directly outside the class                       
                                                 obj.compute_area(1.5);                       
                                   
                                   
                                                 return                                     0;                       
                         }                       

输出 :

Radius is: 1.5Area is: 7.065

3.受保护 ：Protected access修饰符类似于private access修饰符，因为它不能在其类之外被访问，除非在friend类的帮助下，区别在于声明为Protected的类成员也可以被该类的任何子类（派生类）访问。

笔记：这种通过继承进行的访问可以改变派生类中基类元素的访问修饰符，具体取决于继承方式 .

例子：

CPP

                         // C++ program to demonstrate                       
                         // protected access modifier                       
                         #include <bits/stdc++.h>                       
                         using                                     namespace                                     std;                       
           
                         // base class                       
                         class                                     Parent                       
                         {                       
                                                 // protected data members                       
                                                 protected                                     :                       
                                                 int                                     id_protected;                       
                                   
                         };                       
           
                         // sub class or derived class from public base class                       
                         class                                     Child :                                     public                                     Parent                       
                         {                       
                                                 public                                     :                       
                                                 void                                     setId(                                     int                                     id)                       
                                                 {                       
                                   
                                                 // Child class is able to access the inherited                       
                                                 // protected data members of base class                       
                                   
                                                 id_protected = id;                       
                                   
                                                 }                       
                                   
                                                 void                                     displayId()                       
                                                 {                       
                                                 cout <<                                     "id_protected is: "                                     << id_protected << endl;                       
                                                 }                       
                         };                       
           
                         // main function                       
                         int                                     main() {                       
                                   
                                                 Child obj1;                       
                                   
                                                 // member function of the derived class can                       
                                                 // access the protected data members of the base class                       
                                   
                                                 obj1.setId(81);                       
                                                 obj1.displayId();                       
                                                 return                                     0;                       
                         }                       

输出 :

id_protected is: 81

文章版权归作者所有，未经允许请勿转载。

THE END

技术文章