Überschreiben von C++-Funktionen

In diesem Tutorial lernen wir anhand von Beispielen das Überschreiben von Funktionen in C++ kennen.

Wie wir wissen, ist Vererbung eine Funktion von OOP, die es uns ermöglicht, abgeleitete Klassen von einer Basisklasse zu erstellen. Die abgeleiteten Klassen erben Merkmale der Basisklasse.

Angenommen, dieselbe Funktion ist sowohl in der abgeleiteten Klasse als auch in der Basisklasse definiert. Wenn wir nun diese Funktion über das Objekt der abgeleiteten Klasse aufrufen, wird die Funktion der abgeleiteten Klasse ausgeführt.

Dies wird als Funktionsüberschreibung bezeichnet in C++. Die Funktion in der abgeleiteten Klasse überschreibt die Funktion in der Basisklasse.

Beispiel 1:Überschreiben von C++-Funktionen

// C++ program to demonstrate function overriding

#include <iostream>
using namespace std;

class Base {
   public:
    void print() {
        cout << "Base Function" << endl;
    }
};

class Derived : public Base {
   public:
    void print() {
        cout << "Derived Function" << endl;
    }
};

int main() {
    Derived derived1;
    derived1.print();
    return 0;
}

Ausgabe

Derived Function

Hier die gleiche Funktion print() ist in beiden Base definiert und Derived Klassen.

Wenn wir also print() aufrufen von Derived Objekt abgeleitet1 , der print() ab Derived wird durch Überschreiben der Funktion in Base ausgeführt .

Wie wir sehen können, wurde die Funktion überschrieben, weil wir die Funktion von einem Objekt des Derived aufgerufen haben Klasse.

Hätten wir die print() angerufen Funktion aus einem Objekt der Base Klasse, wäre die Funktion nicht überschrieben worden.

// Call function of Base class
Base base1;
base1.print(); // Output: Base Function

Auf überschriebene Funktion in C++ zugreifen

Um auf die überschriebene Funktion der Basisklasse zuzugreifen, verwenden wir den Bereichsauflösungsoperator :: .

Wir können auch auf die überschriebene Funktion zugreifen, indem wir einen Zeiger der Basisklasse verwenden, um auf ein Objekt der abgeleiteten Klasse zu zeigen, und dann die Funktion von diesem Zeiger aus aufrufen.

Beispiel 2:C++-Zugriff überschriebene Funktion auf die Basisklasse

// C++ program to access overridden function
// in main() using the scope resolution operator ::

#include <iostream>
using namespace std;

class Base {
   public:
    void print() {
        cout << "Base Function" << endl;
    }
};

class Derived : public Base {
   public:
    void print() {
        cout << "Derived Function" << endl;
    }
};

int main() {
    Derived derived1, derived2;
    derived1.print();

    // access print() function of the Base class
    derived2.Base::print();

    return 0;
}

Ausgabe

Derived Function
Base Function

Hier, diese Aussage

derived2.Base::print();

greift auf print() zu Funktion der Basisklasse.

Beispiel 3:C++-Aufruf einer überschriebenen Funktion aus einer abgeleiteten Klasse

// C++ program to call the overridden function
// from a member function of the derived class

#include <iostream>
using namespace std;

class Base {
   public:
    void print() {
        cout << "Base Function" << endl;
    }
};

class Derived : public Base {
   public:
    void print() {
        cout << "Derived Function" << endl;

        // call overridden function
        Base::print();
    }
};

int main() {
    Derived derived1;
    derived1.print();
    return 0;
}

Ausgabe

Derived Function
Base Function

In diesem Programm haben wir die überschriebene Funktion innerhalb von Derived aufgerufen Klasse selbst.

class Derived : public Base {
   public:
    void print() {
        cout << "Derived Function" << endl;
        Base::print();
    }
};

Beachten Sie den Code Base::print(); , die die überschriebene Funktion innerhalb von Derived aufruft Klasse.

Beispiel 4:C++-Aufruf überschriebene Funktion mit Zeiger

// C++ program to access overridden function using pointer
// of Base type that points to an object of Derived class

#include <iostream>
using namespace std;

class Base {
   public:
    void print() {
        cout << "Base Function" << endl;
    }
};

class Derived : public Base {
   public:
    void print() {
        cout << "Derived Function" << endl;
    }
};

int main() {
    Derived derived1;

    // pointer of Base type that points to derived1
    Base* ptr = &derived1;

    // call function of Base class using ptr
    ptr->print();

    return 0;
}

Ausgabe

Base Function

In diesem Programm haben wir einen Zeiger von Base erstellt Typ mit dem Namen ptr . Dieser Zeiger zeigt auf Derived Objekt abgeleitet1 .

// pointer of Base type that points to derived1
Base* ptr = &derived1;

Wenn wir die print() anrufen Funktion mit ptr , ruft es die überschriebene Funktion von Base auf .

// call function of Base class using ptr
ptr->print();

Denn obwohl ptr zeigt auf Derived Objekt, es ist eigentlich Base Typ. Also ruft es die Member-Funktion von Base auf .

Um den Base zu überschreiben statt darauf zuzugreifen, müssen wir virtuelle Funktionen im Base verwenden Klasse.

Öffentliche, geschützte und private Vererbung in C++ C++ Mehrfach-, Mehrebenen- und hierarchische Vererbung

C Sprache