c++友元函数具体举例

下面是一个简单的例子，其中一个类定义了一个私有成员变量，而另一个类的成员函数可以访问该变量，这个成员函数就是友元函数。

class B; // 前向声明

class A {
private:
    int x;
public:
    void setX(int i) {
        x = i;
    }
    friend void showX(A a, B b); // 友元函数声明
};

class B {
private:
    int y;
public:
    void setY(int i) {
        y = i;
    }
    friend void showX(A a, B b); // 友元函数声明
};

void showX(A a, B b) { // 友元函数定义
    cout << "A's x is " << a.x << " and B's y is " << b.y << endl;
}

int main() {
    A a;
    B b;

    a.setX(10);
    b.setY(20);

    showX(a, b);

    return 0;
}

在这个例子中，类A和类B互为友元，它们之间的成员函数可以相互访问私有成员变量x和y。函数showX()是一个友元函数，它可以访问类A和类B的私有成员变量。在main()函数中，我们创建了类A和类B的对象，并设置了它们的成员变量。然后我们调用showX()函数来打印这些变量的值。

相关问题

c++友元函数的定义和使用。 内存管理，包括动态内存分配和释放。并详细举例

友元函数是一种特殊的函数，它可以访问一个类的私有成员和保护成员。友元函数可以是一个非成员函数，也可以是另一个类的成员函数。友元函数的定义格式如下：

class A {
  friend void B::funcName(); // B类中的成员函数作为友元函数
  friend void funcName2(); // 非成员函数作为友元函数
};

动态内存分配和释放是在程序运行时动态地为程序分配内存空间，这样可以提高内存的利用率。C++中使用`new`操作符进行动态内存分配，使用`delete`操作符进行内存释放。例子如下：

int* arr = new int[5]; // 动态分配长度为5的整型数组
for (int i = 0; i < 5; i++) {
  arr[i] = i+1; // 给数组赋值
}
delete[] arr; // 释放内存

此外，还可以使用`malloc()`和`free()`函数进行内存分配和释放，但需要注意的是，`malloc()`返回的是`void*`类型的指针，需要进行类型转换，而`new`操作符可以自动进行类型转换。例子如下：

int* p = (int*)malloc(5 * sizeof(int)); // 动态分配长度为5的整型数组
for (int i = 0; i < 5; i++) {
  *(p+i) = i+1; // 给数组赋值
}
free(p); // 释放内存

C++友元类举例说明，如何通过友元类，访问友元类的变量

在C++中，友元类是一种特殊类型的类，它允许一个类访问另一个类的私有和保护成员。通过友元关系，可以使得一个类访问另一个类的特定部分，而不必进行继承或者特化。下面是一个使用友元类的例子：

#include <iostream>

class FriendlyClass {
public:
    int public_member = 42;
    int private_member;
    
    // 声明一个友元函数
    friend void access_private_member(FriendlyClass& obj);
    
    // 声明一个友元类
    class FriendlyClassFriend {
    public:
        void print() {
            std::cout << "FriendlyClass's private member: " << obj.private_member << std::endl;
        }
    };
};

// 友元函数，访问FriendlyClass的私有成员
void access_private_member(FriendlyClass& obj) {
    std::cout << "Accessing private member of FriendlyClass: " << obj.private_member << std::endl;
}

int main() {
    FriendlyClass friend_class;
    friend_class.private_member = 3; // 设置私有成员的值
    std::cout << "Before accessing private member through friend class:" << std::endl;
    std::cout << "FriendlyClass's private member: " << friend_class.private_member << std::endl; // 通过友元类访问私有成员的值
    
    // 打印通过友元类可以访问的信息
    FriendlyClassFriend friendly_class_friend;
    friendly_class_friend.print(); // 输出"FriendlyClass's private member: 3"
    
    return 0;
}

在这个例子中，我们首先定义了一个名为`FriendlyClass`的类，它有一个私有成员`private_member`和一个公开成员`public_member`。我们声明了一个友元函数`access_private_member`和一个友元类`FriendlyClassFriend`。`FriendlyClassFriend`是`FriendlyClass`的一个友元，这意味着它可以访问`FriendlyClass`的私有成员。在主函数中，我们通过友元类访问了私有成员的值，并打印出了相关信息。

需要注意的是，使用友元关系需要谨慎，因为这可能会破坏封装性并导致代码难以理解和维护。通常情况下，应该尽量避免使用友元关系，除非有特殊的理由需要这样做。