Interaktion zwischen C++-Friend-Funktionen und virtuellen Funktionen

In C++ interagieren Friend-Funktionen mit virtuellen Funktionen, sodass die Friend-Funktion auf die virtuelle Funktion zugreifen und die Friend-Funktion in der abgeleiteten Klasse aufrufen kann, um auf die privaten Mitglieder der Basisklasse zuzugreifen. Diese Interaktion kann verwendet werden, um auf in der Vererbungshierarchie verborgene Daten zuzugreifen oder polymorphes Verhalten zu implementieren.

Interaktion zwischen Friend-Funktion und virtueller Funktion in C++

In C++ ist eine Friend-Funktion eine Funktion, die auf private und geschützte Mitglieder einer Klasse zugreifen kann. Virtuelle Funktionen ermöglichen abgeleiteten Klassen, Basisklassenmethoden zu überschreiben. Die Interaktion zwischen Freundfunktionen und virtuellen Funktionen kann auf folgende Weise erreicht werden:

Fall 1: Auf Freundfunktionen und virtuelle Funktionen wird gleichzeitig zugegriffen.

Wenn Freundfunktionen und virtuelle Funktionen gleichzeitig auf Klassenmitglieder zugreifen, Die Friend-Funktion muss explizit angegeben werden. Die virtuelle Funktion, auf die zugegriffen wird.

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()
};

Fall 2: Friend-Funktionsaufruf in einer virtuellen Funktion

Eine virtuelle Funktion in einer abgeleiteten Klasse kann eine Friend-Funktion aufrufen, um auf private oder geschützte Mitglieder der Basisklasse zuzugreifen.

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;
};

Praktischer Fall: Zugriff auf versteckte Daten

Freundfunktionen und virtuelle Funktionen können in Kombination verwendet werden, um auf versteckte Daten im Vererbungssystem zuzugreifen.

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";
}

Das obige ist der detaillierte Inhalt vonInteraktion zwischen C++-Friend-Funktionen und virtuellen Funktionen. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!