Conflit entre les fonctions amies C++ et le contrôle d'accès

En C++, les fonctions amies et le contrôle d'accès peuvent entrer en conflit. Pour accéder aux membres privés, vous pouvez déclarer le membre comme protégé ou utiliser une fonction proxy. Par exemple, la classe Student a un nom et un score de membres privés, et les fonctions amies printName et printScore peuvent imprimer ces membres respectivement.

Fonctions amies C++ et conflit de contrôle d'accès

En C++, les fonctions amies sont des fonctions non membres qui peuvent accéder aux membres privés d'une classe. Cependant, en matière de contrôle d'accès, les fonctions amies peuvent rencontrer des conflits avec le contrôle d'accès des membres de la classe.

Contrôle d'accès

C++ propose trois niveaux de contrôle d'accès :

• public : Accessible depuis n'importe où dans la classe.
• protected : Accessible uniquement à partir de la classe et de ses classes dérivées.
• privé : Accessible uniquement depuis l'intérieur de la classe.

Fonctions ami

Les fonctions ami sont déclarées via le mot-clé friend. Les fonctions Ami ont accès à tous les membres d’une classe, quel que soit le niveau de contrôle d’accès. Cependant, les fonctions d'ami ne font pas partie de la classe. friend 关键字声明的。友元函数可以访问类的所有成员，无论访问控制级别如何。但是，友元函数不会成为类的一部分。

访问控制冲突

当友元函数试图访问私有成员时，就会发生访问控制冲突。例如：

class MyClass {
private:
    int x;

friend void printX(MyClass& obj) {
    std::cout << obj.x << std::endl;
}
};

在这个例子中，printX 函数是类的友元，但它试图访问私有成员 x。这会导致编译器错误。

解决冲突

要解决访问控制冲突，可以使用以下方法：

1. 使用保护成员

将私有成员声明为受保护成员。这允许派生类和友元函数访问该成员。

class MyClass {
protected:
    int x;

friend void printX(MyClass& obj) {
    std::cout << obj.x << std::endl;
}
};

2. 使用代理函数

创建另一个类成员函数作为私有成员的代理。这个代理函数可以公开访问，供友元函数使用。

class MyClass {
private:
    int x;

public:
    int getX() const { return x; }

friend void printX(MyClass& obj) {
    std::cout << obj.getX() << std::endl;
}
};

实战案例

在以下实际案例中，我们有一个 Student 类，它有 name 和 score两个私有成员。我们想要创建两个友元函数 printName() 和 printScore()

Violation du contrôle d'accès

Une violation du contrôle d'accès se produit lorsqu'une fonction ami tente d'accéder à un membre privé. Par exemple : 🎜

class Student {
private:
    std::string name;
    int score;

friend void printName(Student& obj) {
    std::cout << "Name: " << obj.name << std::endl;
}

friend void printScore(Student& obj) {
    std::cout << "Score: " << obj.score << std::endl;
}
};

🎜Dans cet exemple, la fonction printX est une amie de la classe, mais elle essaie d'accéder au membre privé x. Cela peut provoquer des erreurs du compilateur. 🎜🎜🎜Résoudre les conflits🎜🎜🎜Pour résoudre les conflits de contrôle d'accès, vous pouvez utiliser les méthodes suivantes : 🎜🎜🎜1. Utilisez des membres protégés 🎜🎜🎜 pour déclarer les membres privés comme membres protégés. Cela permet aux classes dérivées et aux fonctions amies d'accéder au membre. 🎜

int main() {
    Student student;
    student.name = "John Doe";
    student.score = 95;

    printName(student);
    printScore(student);

    return 0;
}

🎜🎜2. Utilisez la fonction proxy🎜🎜🎜 pour créer une autre fonction de membre de classe en tant que proxy pour le membre privé. Cette fonction proxy est accessible publiquement pour être utilisée par les fonctions amies. 🎜

Name: John Doe
Score: 95

🎜🎜Cas pratique🎜🎜🎜Dans le cas réel suivant, nous avons une classe Étudiant, qui a deux classes privées : nom et score membre. Nous voulons créer deux fonctions amies printName() et printScore() pour imprimer respectivement ces membres privés. 🎜rrreee🎜Grâce aux fonctions d'ami, nous pouvons facilement imprimer les noms et les notes des étudiants même s'ils sont des membres privés. 🎜rrreee🎜Sortie : 🎜rrreee

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!