迹忆客 专注技术分享

本文讨论 C++ 私有变量以及如何在 C++ 中访问它们。

在 C++ 中访问私有变量

封装保护敏感和重要数据免受未经授权的用户的侵害。private 关键字用于实现这种现象。

除了封装之外，数据隐藏的概念也在 C++ 中实现。在 C++ 中用 private 关键字声明的变量表明它只能由其类的成员函数访问。

任何对象或函数都不能直接访问它。

#include <iostream>
using namespace std;

class shape
{
    private:
        double r;

    public:
    void area(double rr)
    {
        r = rr;

        double ar = 3.14*r*r;

        cout << "Radius is: " << r << endl;
        cout << "Area is: " << ar;
    }

};

int main()
{
    shape obj;
    obj.area(1.5);

    return 0;

}

输出：

Radius is: 1.5
Area is: 7.065

除了类的 friend 函数或成员函数外，没有实体可以访问类的私有数据成员。这里，变量 r 由类 area() 的成员函数访问。

area() 函数通过访问类的私有数据成员来计算圆的面积。并且类的对象是在类的主函数中创建的。

通过该对象访问类成员函数，计算圆的面积。

friend 函数本身并不是访问私有数据成员的方式。除此之外，还可以使用指针在类外部访问私有变量。

这种使用指针访问私有数据成员的方法是 C++ 中的一个漏洞。请继续阅读以了解更多信息。

使用成员函数访问 C++ 中的私有变量

C++ 中的私有成员变量或函数不能在类外部访问或看到。C++ 的主要概念是其独特的数据安全特性。

私有数据成员只能由创建它的类及其类的 friend 函数访问。

关注下面的例子，了解类的成员函数如何访问数据成员。

#include <iostream>
using namespace std;

class Emp {
  private:
    int sal;

  public:
    void setSal(int s) {
      sal = s;
    }

    int getSal() {
      return sal;
    }
};

int main() {
  Emp myObj;
  myObj.setSal(50000);
  cout << myObj.getSal();
  return 0;
}

输出：

50000

在上面的程序中，类 emp 有私有成员和公共成员。sal 是两个类成员函数可以访问的私有变量：setSal() 和 getSal()。

setSal() 正在初始化私有数据成员 sal 的值，而 getSal() 返回私有数据成员 sal 的值。最后，在 main 方法中，创建了类的对象。

对象 myObj 访问类的成员函数 setSal()，以将值传递给私有数据成员 sal。最后，类对象访问 getSal() 返回 sal 数据成员。

默认情况下，一个类的所有成员都是私有的；例如，在下面的类中，w 是一个私有成员。因此，在你将成员标记为公共或受保护之前，它将被视为私有数据成员。

class B {
   double w;

   public:
      double len;
      void setW( double wid );
      double get( void );
};

实时的，数据定义在私有区域，成员函数在公共区域从类外调用，如下程序所示。

#include <iostream>

using namespace std;

class B {
   public:
      double len;
      void setW( double wid );
      double getW( void );

   private:
      double w;
};

double B::getW(void) {
   return w ;
}

void B::setW( double wid ) {
   w = wid;
}

int main() {
   B box;

   box.len = 10.0;
   cout << "Length: " << box.len <<endl;

   box.setW(10.0);
   cout << "Width: " << box.getW() <<endl;

   return 0;
}

在上面的程序中，类 B 有私有成员和公共成员。这里，w 是两个类成员函数可以访问的私有变量：setW() 和 getW()。

setW() 初始化私有数据成员 w 的值，getW() 返回私有数据成员 w 的值。对象框访问类的成员函数。

公共变量 len 可通过对象框访问并使用值进行初始化。setW() 将给定值分配给私有数据成员 w。

最后，类对象框访问 getW() 以返回 w 数据成员。

输出：

Length: 10
Width: 10

使用 friend 函数访问 C++ 中的私有变量

friend 函数位于类的私有或公共部分。它可以在不使用对象的情况下被称为普通成员函数。

类对象不调用它，因为它不在类的范围内。此外，它不能直接访问类的私有和受保护数据成员。

friend 函数使用类的对象并使用点运算符访问成员。它可以是全局函数或另一个类的成员。

#include <iostream>
using namespace std;

class Dist {
    private:
        int m;

        friend int add(Dist);

    public:
        Dist() : m(0) {}

};

int add(Dist d) {

    d.m += 5;
    return d.m;
}

int main() {
    Dist D;
    cout << "Distance: " << add(D);
    return 0;
}

输出：

Distance = 5

在上面的程序中，我们可以看到一个带有私有成员 m 的类 Dist。我们有一个公共构造函数来初始化 m 的值。

然后，有一个 friend 函数 add()，它使用 m 计算距离。add() 是一个 friend 函数，它不在类的范围内。

在 main 方法中，创建类的一个对象并传递 add() 函数。add() 函数计算距离并显示结果。

C++ 中的 friend 类

friend 类就像可以创建的 friend 函数。friend 类可以访问与它成为朋友的类的秘密和受保护成员。

与 friend 函数类似，还有一个 friend 类。它可以访问它是朋友的私有和受保护的类成员。

语法：

class X{

Data members;
Member Functions;

friend class Y;

};

class B{
……..
};

如语法所示，类 X 是类 Y 的朋友。这意味着类 Y 可以访问类 X 的私有成员和受保护成员。

但是这种友谊不是相互的，并且类 X 不能访问类 Y 的私有和受保护成员。我们必须将类 X 指定为类 Y 的朋友。

此外，友谊不是继承的，所以类 Y 不会是类 X 的子类的朋友。

C++ 中 friend 类的示例

#include <iostream>
#include <string>
using namespace std;
class Ar{
   int len,br,arr;

   public:

   Ar(int l,int b)
   {
    len = l;
    br = b;
   };

   void computeArea(){
      arr = len * br;
   }

   friend class prClass;

};
class prClass{

   public:
   void prAr(Ar &a){
      cout<<"Area = "<<a.arr;
   }
 };
int main(){
   Ar a(20,10);
   a.computeArea();
   prClass p;
   p.prAr(a);

   return 0;
}

输出：

Area = 200

在上面的程序中，有两个类。Ar 类使用 len 和 br 变量计算面积。

此类具有三个私有数据成员：arr、len 和 br。创建的另一个类是 prClass，它打印由 Ar 类的成员函数 computeArea 计算的最终区域。

因为所有数据成员都是私有的，所以我们需要让 prClass 成为 Ar 类的朋友 来打印结果。Ar 类对象在主函数内部创建。

面积计算完成，Ar 类的对象被传递给 prClass 函数。该函数称为 prAr，用于显示区域。

在 C++ 中使用 friend 函数访问私有变量的缺点

C++ 最重要的特性是封装，即一组数据和函数。数据成员和成员函数一起处理数据，因此没有外部函数或类可以访问数据。

由于允许 friend 函数或类访问另一个类的私有成员，封装特性受到损害。数据安全面临危险。

使用指针访问 C++ 中的私有变量

指针在没有 friend 或类成员函数的情况下访问数据。

#include <bits/stdc++.h>
using namespace std;

class Hello {
private:
    int c;
    int d;
};



int main()
{
    Hello a;
    int* q = (int*)&a;
    *q = 4;
    q++;
    *q = 5;
    q--;
    cout << endl << "c = " << *q;
    q++;
    cout << endl << "d = " << *q;
    return 0;
}

输出：

c = 4
d = 5

在上面的程序中，a 是类 Hello 的对象。类对象 a 地址通过类型转换分配给整数指针 q。

指针 q 然后指向私有成员 c。整数值分配给*q，即 c。

然后对象 a 的地址增加，并通过访问内存位置值 5 分配给 d。q-- 语句设置 c 的内存位置。

使用 cout 语句，显示 c。

结论

在本文中，我们讨论了在 C++ 中访问私有变量。我们了解了在 C++ 中访问私有成员的各种方法。

此外，通过大量示例，我们讨论了 C++ 中的 friend 函数和指针的概念。一件重要的事情是不能在成员函数也是私有的类中创建对象。

牢记这一点，我们希望你喜欢阅读本文。请继续关注更多内容丰富的文章。