C++ menimpa Identifier

C++ 11 telah memberi kita pengidentifikasi baru override yang sangat berguna untuk menghindari bug saat menggunakan fungsi virtual.

Pengidentifikasi ini menetapkan fungsi anggota dari kelas turunan yang menggantikan fungsi anggota kelas dasar.

Misalnya,

class Base {
   public:
    virtual void print() {
        // code
    }
};

class Derived : public Base {
   public:
    void print() override {
        // code
    }
};

Jika kita menggunakan prototipe fungsi di Derived class dan mendefinisikan fungsi tersebut di luar class, maka kita menggunakan kode berikut:

class Derived : public Base {
   public:
    // function prototype
    void print() override;
};

// function definition
void Derived::print() {
    // code
}

Penggunaan penggantian C++

Saat menggunakan fungsi virtual, kemungkinan terjadi kesalahan saat mendeklarasikan fungsi anggota dari kelas turunan.

Menggunakan override pengenal meminta kompiler untuk menampilkan pesan kesalahan ketika kesalahan ini dibuat.

Jika tidak, program hanya akan dikompilasi tetapi fungsi virtual tidak akan diganti.

Beberapa kemungkinan kesalahan ini adalah:

• Fungsi dengan nama yang salah: Misalnya, jika fungsi virtual di kelas dasar diberi nama print() , tetapi kami secara tidak sengaja menamai fungsi utama di kelas turunan sebagai pint() .
• Fungsi dengan jenis pengembalian yang berbeda: Jika fungsi virtualnya, katakanlah, dari void ketik tetapi fungsi di kelas turunan adalah int ketik.
• Fungsi dengan parameter berbeda: Jika parameter fungsi virtual dan fungsi di kelas turunan tidak cocok.
• Tidak ada fungsi virtual yang dideklarasikan di kelas dasar.

Penggunaan Fungsi Virtual C++

Misalkan kita memiliki kelas dasar Animal dan kelas turunan Dog dan Cat .

Misalkan setiap kelas memiliki anggota data bernama type . Misalkan variabel ini diinisialisasi melalui konstruktor masing-masing.

class Animal {
   private:
    string type;
    ... .. ...
    public:
      Animal(): type("Animal") {}
    ... .. ...
};

class Dog : public Animal {
   private:
    string type;
    ... .. ...
    public:
      Animal(): type("Dog") {}
    ... .. ...
};

class Cat : public Animal {
   private:
    string type;
      ... .. ...
    public:
      Animal(): type("Cat") {}
    ... .. ...
};

Sekarang, misalkan program kita mengharuskan kita membuat dua public fungsi untuk setiap kelas:

1. getType() untuk mengembalikan nilai type
2. print() untuk mencetak nilai type

Kita bisa membuat kedua fungsi ini di setiap kelas secara terpisah dan menimpanya, yang akan lama dan membosankan.

Atau kita bisa membuat getType() virtual di Animal kelas, lalu buat satu print() . yang terpisah fungsi yang menerima pointer Animal ketik sebagai argumennya. Kami kemudian dapat menggunakan fungsi tunggal ini untuk mengganti fungsi virtual.

class Animal {
    ... .. ...
   public:
    ... .. ...
    virtual string getType {...}
};

... .. ...
... .. ...

void print(Animal* ani) {
    cout << "Animal: " << ani->getType() << endl;
}

Ini akan membuat kode lebih pendek , pembersih , dan kurang berulang .

Contoh 2:Demonstrasi Fungsi virtual C++

// C++ program to demonstrate the use of virtual function

#include <iostream>
#include <string>
using namespace std;

class Animal {
   private:
    string type;

   public:
    // constructor to initialize type
    Animal() : type("Animal") {}

    // declare virtual function
    virtual string getType() {
        return type;
    }
};

class Dog : public Animal {
   private:
    string type;

   public:
    // constructor to initialize type
    Dog() : type("Dog") {}

    string getType() override {
        return type;
    }
};

class Cat : public Animal {
   private:
    string type;

   public:
    // constructor to initialize type
    Cat() : type("Cat") {}

    string getType() override {
        return type;
    }
};

void print(Animal* ani) {
    cout << "Animal: " << ani->getType() << endl;
}

int main() {
    Animal* animal1 = new Animal();
    Animal* dog1 = new Dog();
    Animal* cat1 = new Cat();

    print(animal1);
    print(dog1);
    print(cat1);

    return 0;
}

Keluaran

Animal: Animal
Animal: Dog
Animal: Cat

Di sini, kami telah menggunakan fungsi virtual getType() dan Animal penunjuk ani untuk menghindari pengulangan print() fungsi di setiap kelas.

void print(Animal* ani) {
    cout << "Animal: " << ani->getType() << endl;
}

Di main() , kami telah membuat 3 Animal pointer untuk membuat objek Animal secara dinamis , Dog dan Cat kelas.

// dynamically create objects using Animal pointers
Animal* animal1 = new Animal();
Animal* dog1 = new Dog();
Animal* cat1 = new Cat();

Kami kemudian memanggil print() fungsi menggunakan pointer ini:

1. Kapan print(animal1) dipanggil, pointer menunjuk ke Animal obyek. Jadi, fungsi virtual di Animal kelas dieksekusi di dalam print() .
2. Kapan print(dog1) dipanggil, pointer menunjuk ke Dog obyek. Jadi, fungsi virtual diganti dan fungsi Dog dieksekusi di dalam print() .
3. Kapan print(cat1) dipanggil, pointer menunjuk ke Cat obyek. Jadi, fungsi virtual diganti dan fungsi Cat dieksekusi di dalam print() .