Verständnis und Verwendung des Überladens und Umschreibens von C++-Funktionen

Funktionsüberladung in C++ ermöglicht die Definition von Funktionen mit demselben Namen in derselben Klasse, jedoch mit unterschiedlichen Parameterlisten. Eine Funktionsüberschreibung erfolgt, wenn eine Funktion mit demselben Namen und denselben Parametern wie die übergeordnete Klasse in einer Unterklasse und der Unterklasse definiert wird Die Funktion überschreibt die übergeordnete Klassenfunktion. Im praktischen Beispiel wird die überladene Funktion verwendet, um Additionsoperationen für verschiedene Datentypen auszuführen, und die überschriebene Funktion wird verwendet, um die virtuelle Funktion in der übergeordneten Klasse zu überschreiben und die Fläche verschiedener Formen zu berechnen.

C++-Funktionsüberladung und Umschreiben: tiefgehendes Verständnis und praktische Anwendung

Funktionsüberladung

Funktionsüberladung ermöglicht die Definition mehrerer Funktionen mit demselben Funktionsnamen, aber unterschiedlichen Parameterlisten in derselben Klasse.

class MyClass {
public:
  int add(int a, int b);
  double add(double a, double b);
};

int MyClass::add(int a, int b) {
  return a + b;
}

double MyClass::add(double a, double b) {
  return a + b;
}

Funktionsüberschreibung

Funktionsüberschreibung tritt auf, wenn eine Funktion in einer untergeordneten Klasse mit demselben Namen und derselben Parameterliste wie die übergeordnete Klasse definiert ist. Unterklassenfunktionen überschreiben übergeordnete Klassenfunktionen.

class ParentClass {
public:
  virtual int display() {
    return 10;
  }
};

class ChildClass : public ParentClass {
public:
  int display() { // 重写父类的 display()
    return 20;
  }
};

Praktischer Fall

Beispiel einer überladenen Funktion:

#include <iostream>

class Calculator {
public:
  int add(int a, int b) {
    return a + b;
  }

  double add(double a, double b) {
    return a + b;
  }

  std::string add(std::string a, std::string b) {
    return a + b;
  }
};

int main() {
  Calculator calc;
  std::cout << calc.add(1, 2) << std::endl;   // 输出：3
  std::cout << calc.add(1.5, 2.5) << std::endl; // 输出：4
  std::cout << calc.add("Hello", "World") << std::endl; // 输出：HelloWorld
  return 0;
}

Beispiel einer umgeschriebenen Funktion:

#include <iostream>

class Shape {
public:
  virtual double area() = 0; // 纯虚函数（强制子类实现 area()）
};

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

private:
  double m_width;
  double m_height;
};

class Circle : public Shape {
public:
  Circle(double radius) : m_radius(radius) {}
  double area() override {
    return 3.14 * m_radius * m_radius;
  }

private:
  double m_radius;
};

int main() {
  Rectangle rect(5, 10);
  Circle circle(5);
  std::cout << "Rectangle area: " << rect.area() << std::endl; // 输出：50
  std::cout << "Circle area: " << circle.area() << std::endl; // 输出：78.5
  return 0;
}

Das obige ist der detaillierte Inhalt vonVerständnis und Verwendung des Überladens und Umschreibens von C++-Funktionen. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!