行业资讯

C++友元如何使用

发布时间：2022-04-24 10:53:39 作者：iii
来源：亿速云 阅读：203

C++友元如何使用

1. 友元的概念

在C++中，友元（Friend）是一种特殊的机制，它允许一个类或函数访问另一个类的私有（private）和保护（protected）成员。通常情况下，类的私有成员只能被该类的成员函数访问，而友元机制打破了这一限制，使得外部函数或其他类可以直接访问这些私有成员。

友元机制的主要用途是提高程序的灵活性和效率，尤其是在需要频繁访问类的私有成员时。通过友元，可以避免使用公共接口（public interface）来访问私有成员，从而减少函数调用的开销。

2. 友元的类型

C++中的友元可以分为以下几种类型：

  1. 友元函数：一个非成员函数被声明为类的友元，可以访问该类的私有和保护成员。
  2. 友元类：一个类被声明为另一个类的友元，可以访问该类的私有和保护成员。
  3. 友元成员函数：一个类的成员函数被声明为另一个类的友元，可以访问该类的私有和保护成员。

3. 友元函数

3.1 友元函数的声明

友元函数是一个非成员函数，但它可以访问类的私有和保护成员。友元函数的声明通常在类的定义中进行，使用friend关键字。

class MyClass {
private:
    int privateData;

public:
    MyClass(int data) : privateData(data) {}

    // 声明友元函数
    friend void friendFunction(MyClass& obj);
};

// 定义友元函数
void friendFunction(MyClass& obj) {
    std::cout << "Accessing private data: " << obj.privateData << std::endl;
}

int main() {
    MyClass obj(42);
    friendFunction(obj);  // 输出: Accessing private data: 42
    return 0;
}

在上面的例子中，friendFunction是一个友元函数，它可以访问MyClass类的私有成员privateData。

3.2 友元函数的特点

3.3 友元函数的应用场景

友元函数通常用于以下场景：

class Complex {
private:
    double real;
    double imag;

public:
    Complex(double r = 0.0, double i = 0.0) : real(r), imag(i) {}

    // 声明友元函数
    friend Complex operator+(const Complex& c1, const Complex& c2);
};

// 定义友元函数
Complex operator+(const Complex& c1, const Complex& c2) {
    return Complex(c1.real + c2.real, c1.imag + c2.imag);
}

int main() {
    Complex c1(1.0, 2.0);
    Complex c2(3.0, 4.0);
    Complex c3 = c1 + c2;  // 使用友元函数重载的+运算符
    return 0;
}

在这个例子中，operator+是一个友元函数，它重载了+运算符，使得两个Complex对象可以直接相加。

4. 友元类

4.1 友元类的声明

友元类是指一个类可以访问另一个类的私有和保护成员。友元类的声明同样使用friend关键字。

class MyClass {
private:
    int privateData;

public:
    MyClass(int data) : privateData(data) {}

    // 声明友元类
    friend class FriendClass;
};

class FriendClass {
public:
    void accessPrivateData(MyClass& obj) {
        std::cout << "Accessing private data: " << obj.privateData << std::endl;
    }
};

int main() {
    MyClass obj(42);
    FriendClass friendObj;
    friendObj.accessPrivateData(obj);  // 输出: Accessing private data: 42
    return 0;
}

在这个例子中，FriendClass是MyClass的友元类，因此FriendClass的成员函数可以访问MyClass的私有成员privateData。

4.2 友元类的特点

4.3 友元类的应用场景

友元类通常用于以下场景：

class Node {
private:
    int data;
    Node* next;

public:
    Node(int d) : data(d), next(nullptr) {}

    // 声明友元类
    friend class LinkedList;
};

class LinkedList {
private:
    Node* head;

public:
    LinkedList() : head(nullptr) {}

    void addNode(int data) {
        Node* newNode = new Node(data);
        newNode->next = head;
        head = newNode;
    }

    void printList() {
        Node* current = head;
        while (current != nullptr) {
            std::cout << current->data << " ";
            current = current->next;
        }
        std::cout << std::endl;
    }
};

int main() {
    LinkedList list;
    list.addNode(1);
    list.addNode(2);
    list.addNode(3);
    list.printList();  // 输出: 3 2 1
    return 0;
}

在这个例子中，LinkedList是Node的友元类，因此LinkedList可以直接访问Node的私有成员data和next。

5. 友元成员函数

5.1 友元成员函数的声明

友元成员函数是指一个类的成员函数被声明为另一个类的友元，可以访问该类的私有和保护成员。友元成员函数的声明同样使用friend关键字。

class MyClass {
private:
    int privateData;

public:
    MyClass(int data) : privateData(data) {}

    // 声明友元成员函数
    friend void FriendClass::accessPrivateData(MyClass& obj);
};

class FriendClass {
public:
    void accessPrivateData(MyClass& obj) {
        std::cout << "Accessing private data: " << obj.privateData << std::endl;
    }
};

int main() {
    MyClass obj(42);
    FriendClass friendObj;
    friendObj.accessPrivateData(obj);  // 输出: Accessing private data: 42
    return 0;
}

在这个例子中，FriendClass的成员函数accessPrivateData是MyClass的友元成员函数，因此它可以访问MyClass的私有成员privateData。

5.2 友元成员函数的特点

5.3 友元成员函数的应用场景

友元成员函数通常用于以下场景：

class Node {
private:
    int data;
    Node* next;

public:
    Node(int d) : data(d), next(nullptr) {}

    // 声明友元成员函数
    friend void LinkedList::addNode(int data);
};

class LinkedList {
private:
    Node* head;

public:
    LinkedList() : head(nullptr) {}

    void addNode(int data) {
        Node* newNode = new Node(data);
        newNode->next = head;
        head = newNode;
    }

    void printList() {
        Node* current = head;
        while (current != nullptr) {
            std::cout << current->data << " ";
            current = current->next;
        }
        std::cout << std::endl;
    }
};

int main() {
    LinkedList list;
    list.addNode(1);
    list.addNode(2);
    list.addNode(3);
    list.printList();  // 输出: 3 2 1
    return 0;
}

在这个例子中，LinkedList的成员函数addNode是Node的友元成员函数，因此它可以访问Node的私有成员data和next。

6. 友元的注意事项

虽然友元机制提供了访问私有成员的便利，但在使用时需要注意以下几点：

  1. 破坏封装性：友元机制破坏了类的封装性，使得外部函数或类可以直接访问私有成员。因此，应谨慎使用友元，避免过度依赖。
  2. 增加耦合性：友元关系增加了类之间的耦合性，使得类的设计更加复杂。因此，在设计类时应尽量减少友元的使用。
  3. 不可继承：友元关系不可继承，即如果A是B的友元类，A的派生类并不自动成为B的友元类。
  4. 不可传递：友元关系不可传递，即如果A是B的友元类，B是C的友元类，A并不自动成为C的友元类。

7. 总结

友元是C++中一种强大的机制，它允许外部函数或类访问类的私有和保护成员。通过友元函数、友元类和友元成员函数，可以实现更灵活的类设计和更高效的代码实现。然而，友元机制也带来了封装性和耦合性的问题，因此在使用时应谨慎权衡利弊。

在实际编程中，友元机制通常用于以下场景：

通过合理使用友元机制，可以提高代码的灵活性和效率，但同时也应注意避免过度依赖友元，以保持代码的封装性和可维护性。

推荐阅读：
  1. C++语言学习（七）——友元
  2. 细说C++的友元

免责声明：本站发布的内容（图片、视频和文字）以原创、转载和分享为主，文章观点不代表本网站立场，如果涉及侵权请联系站长邮箱：is@yisu.com进行举报，并提供相关证据，一经查实，将立刻删除涉嫌侵权内容。

c++

上一篇：vue如何axios整合使用

下一篇：vue3中props组件抽离的方法

相关阅读

您好，登录后才能下订单哦！

密码登录
登录注册
获取短信验证码
其他方式登录
点击 登录注册 即表示同意《亿速云用户服务条款》
产品服务
地区划分
帮助支持
关于我们
行业资讯-文章归档 问答-问答归档
广州亿速云计算有限公司

7*24小时在线电话：400-100-2938

7*24小时在线QQ：800811969

Copyright © Yisu Cloud Ltd. All Rights Reserved. 2018 版权所有
粤ICP备17096448号-1 粤公网安备 44010402001142号