Interaction entre les fonctions amies C++ et les fonctions virtuelles

En C++, les fonctions ami interagissent avec les fonctions virtuelles afin que la fonction ami puisse accéder à la fonction virtuelle et appeler la fonction ami dans la classe dérivée pour accéder aux membres privés de la classe de base. Cette interaction peut être utilisée pour accéder à des données cachées dans la hiérarchie d'héritage ou pour implémenter un comportement polymorphe.

Interaction entre la fonction ami et la fonction virtuelle en C++

En C++, une fonction ami est une fonction qui peut accéder aux membres privés et protégés d'une classe. Les fonctions virtuelles permettent aux classes dérivées de remplacer les méthodes des classes de base. L'interaction entre les fonctions amies et les fonctions virtuelles peut être réalisée des manières suivantes :

Cas 1 : Les fonctions amies et les fonctions virtuelles sont accessibles en même temps

Lorsque les fonctions amies et les fonctions virtuelles accèdent aux membres de la classe en même temps, la fonction ami doit être explicitement spécifiée. La fonction virtuelle à laquelle la classe est accessible.

class Base {
public:
  virtual void foo() { std::cout << "Base::foo()\n"; }
};

class Derived : public Base {
public:
  virtual void foo() override { std::cout << "Derived::foo()\n"; }
};

class Friend {
public:
  static void callFoo(Base& base) { base.foo(); } // 调用 Base::foo()
  static void callFoo(Derived& derived) { derived.foo(); } // 调用 Derived::foo()
};

Cas 2 : Appel de fonction ami dans une fonction virtuelle

Une fonction virtuelle dans une classe dérivée peut appeler une fonction ami pour accéder aux membres privés ou protégés de la classe de base.

class Base {
public:
  virtual void foo();
friend class Derived;
};

class Derived : public Base {
public:
  virtual void foo() override {
    // 调用友元函数访问 Base 的私有成员
    std::cout << m_privateMember << "\n";
  }

private:
  int m_privateMember;
};

Cas pratique : accéder aux données cachées

Les fonctions amies et les fonctions virtuelles peuvent être utilisées en combinaison pour accéder aux données cachées dans le système d'héritage.

class Shape {
public:
  virtual double getArea() const = 0;
};

class Circle : public Shape {
public:
  Circle(double radius) : m_radius(radius) {}
  double getArea() const override { return M_PI * m_radius * m_radius; }

private:
  double m_radius;
};

class Rectangle : public Shape {
public:
  Rectangle(double width, double height) : m_width(width), m_height(height) {}
  double getArea() const override { return m_width * m_height; }

private:
  double m_width, m_height;
};

// 友元函数，可访问派生类的私有成员以计算体积
template <typename T>
friend double getVolume(const T& shape) {
  return shape.getArea() * 2;
}

int main() {
  Circle circle(5);
  Rectangle rectangle(3, 4);
  std::cout << "Circle area: " << circle.getArea() << "\n";
  std::cout << "Rectangle area: " << rectangle.getArea() << "\n";
  std::cout << "Circle volume: " << getVolume(circle) << "\n";
  std::cout << "Rectangle volume: " << getVolume(rectangle) << "\n";
}

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!