C++友元函数

类的友元函数定义在类作用域之外，但它有权访问类的所有私有和保护成员。即使友元函数的原型出现在类定义中，友元也不是成员函数。

友元可以是函数、函数模板、成员函数或类或类模板，在这种情况下，整个类及其所有成员都是友元。

声明友元函数

要将函数声明为类的友元，请在类定义中使用关键字**friend**在函数原型之前：

语法

class Box {
   double width;
   
   public:
      double length;
      friend void printWidth( Box box );
      void setWidth( double wid );
};

要将 ClassTwo 类的所有成员函数声明为 ClassOne 类的友元，请在 ClassOne 的定义中添加以下声明：

friend class ClassTwo;

友元函数示例

以下是 C++ 中友元函数的代码：

#include <iostream>
 
using namespace std;
 
class Box {
   double width;
   
   public:
      friend void printWidth( Box box );
      void setWidth( double wid );
};

// Member function definition
void Box::setWidth( double wid ) {
   width = wid;
}

// Note: printWidth() is not a member function of any class.
void printWidth( Box box ) {
   /* Because printWidth() is a friend of Box, it can
   directly access any member of this class */
   cout << "Width of box : " << box.width <<endl;
}
 
// Main function for the program
int main() {
   Box box;
 
   // set box width without member function
   box.setWidth(10.0);
   
   // Use friend function to print the wdith.
   printWidth( box );
 
   return 0;
}

编译并运行上述代码后，将产生以下结果：

Width of box : 10

访问私有和保护成员

类的私有和保护成员在类外部是不可访问的。但是，如果要访问它们，可以使用友元函数。友元函数提供了直接访问类私有和保护成员的能力。

示例

以下示例演示了使用友元函数访问类的私有和保护成员。

#include <iostream>
using namespace std;

class ClassName {
 private:
  int privateData;  // Private member

 protected:
  int protectedData;  // Protected member

 public:
  ClassName() : privateData(0), protectedData(0) {}

  // Declare a friend function
  friend void friendFunction(ClassName& obj);
};

// Friend function definition
void friendFunction(ClassName& obj) {
  obj.privateData = 42;    // Access private member
  obj.protectedData = 24;  // Access protected member
  cout << "Private Data: " << obj.privateData << endl;
  cout << "Protected Data: " << obj.protectedData << endl;
}

int main() {
  ClassName obj;
  friendFunction(obj);  // Call the friend function
  return 0;
}

编译并运行上述代码后，将产生以下结果：

Private Data: 42
Protected Data: 24

友元函数与成员函数

在 C++ 中，友元函数和成员函数都用于访问和操作类的成员数据，但是它们在作用域和用法上存在显著差异。

友元函数

友元函数是非成员函数，它在类内使用“friend”关键字声明，它可以特殊访问类的私有和保护成员。由于它不是成员函数，因此它不绑定到特定对象，不能根据对象重载，不能使用this指针，也不能被派生类继承。它们定义在类之外，但在类内声明。

成员函数

而成员函数定义在类内，并使用 this 指针操作。它可以访问类的所有成员（私有、保护和公有），并且因为它与类对象绑定，所以它可以被重载和被派生类继承。

友元类

在 C++ 中，友元类是可以访问另一个类私有和保护成员的类。当一个类声明另一个类为友元时，第二个类（友元）可以直接访问第一个类的私有和保护成员。

这个概念类似于友元函数，但这里友元是整个类而不是特定函数。

语法

以下是 C++ 中友元类的语法：

class ClassB;  // Forward declaration of ClassB

class ClassA {
private:
  int dataA;

public:
  // Declare ClassB as a friend of ClassA
  friend class ClassB;  
};
Example
The following example demonstrates the example of a friend class in C++:
#include <iostream>
using namespace std;

class ClassB;  // Forward declaration of ClassB

class ClassA {
 private:
  int dataA;

 public:
  ClassA() : dataA(42) {}  // Initialize dataA with a value

  // Declare ClassB as a friend of ClassA
  friend class ClassB;
};

class ClassB {
 public:
  void showDataFromA(const ClassA& objA) {
    // Access private member of ClassA
    cout << "Data from ClassA: " << objA.dataA << endl;
  }
};

int main() {
  ClassA objA;
  ClassB objB;

  // Use ClassB to access ClassA's private data
  objB.showDataFromA(objA);

  return 0;
}


   
    
      Print Page
   
   
   
   
   
      Previous
   
   
   
   Next
   
   
   
   

   
      
         Advertisements