Ganti fungsi virtual C ++ dengan aman

Saya memiliki kelas dasar dengan fungsi virtual dan saya ingin mengganti fungsi itu di kelas turunan. Adakah cara untuk membuat compiler memeriksa apakah fungsi yang saya deklarasikan di kelas turunan benar-benar menggantikan fungsi di kelas dasar? Saya ingin menambahkan beberapa makro atau sesuatu yang memastikan bahwa saya tidak secara tidak sengaja mendeklarasikan fungsi baru, alih-alih menimpa yang lama.

Ambil contoh ini:

class parent {
public:
  virtual void handle_event(int something) const {
    // boring default code
  }
};

class child : public parent {
public:
  virtual void handle_event(int something) {
    // new exciting code
  }
};

int main() {
  parent *p = new child();
  p->handle_event(1);
}

Di sini parent::handle_event()dipanggil alih-alih child::handle_event(), karena metode anak melewatkan constdeklarasi dan karenanya mendeklarasikan metode baru. Ini juga bisa menjadi kesalahan ketik pada nama fungsi atau beberapa perbedaan kecil dalam tipe parameter. Ini juga dapat dengan mudah terjadi jika antarmuka kelas dasar berubah dan di suatu tempat beberapa kelas turunan tidak diperbarui untuk mencerminkan perubahan tersebut.

Adakah cara untuk menghindari masalah ini, dapatkah saya memberi tahu kompiler atau alat lain untuk memeriksanya untuk saya? Adakah tanda compiler yang berguna (sebaiknya untuk g ++)? Bagaimana Anda menghindari masalah ini?

Sejak g ++ 4.7, ia memahami overridekata kunci C ++ 11 yang baru :

class child : public parent {
    public:
      // force handle_event to override a existing function in parent
      // error out if the function with the correct signature does not exist
      void handle_event(int something) override;
};

Sesuatu seperti overridekata kunci C # bukan bagian dari C ++.

Di gcc, -Woverloaded-virtualperingatkan agar tidak menyembunyikan fungsi virtual kelas dasar dengan fungsi dengan nama yang sama tetapi tanda tangan yang cukup berbeda sehingga tidak menimpanya. Namun, ini tidak akan melindungi Anda dari kegagalan mengganti fungsi karena salah mengeja nama fungsi itu sendiri.

Sejauh yang saya tahu, tidak bisakah Anda membuatnya abstrak?

class parent {
public:
  virtual void handle_event(int something) const = 0 {
    // boring default code
  }
};

Saya pikir saya membaca di www.parashift.com bahwa Anda benar-benar dapat menerapkan metode abstrak. Yang masuk akal bagi saya secara pribadi, satu-satunya hal yang dilakukannya adalah memaksa subclass untuk mengimplementasikannya, tidak ada yang mengatakan apa-apa tentang itu tidak diizinkan untuk memiliki implementasi itu sendiri.

Di MSVC, Anda dapat menggunakan overridekata kunci CLR meskipun Anda tidak sedang mengkompilasi untuk CLR.

Di g ++, tidak ada cara langsung untuk menerapkannya di semua kasus; orang lain telah memberikan jawaban yang baik tentang cara menangkap perbedaan tanda tangan menggunakan -Woverloaded-virtual. Di versi mendatang, seseorang mungkin menambahkan sintaks seperti __attribute__ ((override))atau yang setara menggunakan sintaks C ++ 0x.

Di MSVC ++ Anda dapat menggunakan kata kuncioverride

class child : public parent {
public:
  virtual void handle_event(int something) <b>override</b> {
    // new exciting code
  }
};

override berfungsi baik untuk kode asli dan CLR di MSVC ++.

Buat fungsi menjadi abstrak, sehingga kelas turunan tidak memiliki pilihan lain selain menimpanya.

@Ray Kode Anda tidak valid.

class parent {
public:
  virtual void handle_event(int something) const = 0 {
    // boring default code
  }
};

Fungsi abstrak tidak boleh memiliki badan yang ditentukan sebaris. Ini harus dimodifikasi untuk menjadi

class parent {
public:
  virtual void handle_event(int something) const = 0;
};

void parent::handle_event( int something ) { /* do w/e you want here. */ }

Saya akan menyarankan sedikit perubahan dalam logika Anda. Ini mungkin berhasil atau tidak, tergantung pada apa yang perlu Anda capai.

handle_event () masih dapat melakukan "kode default yang membosankan" tetapi alih-alih menjadi virtual, pada titik di mana Anda ingin melakukan "kode baru yang menarik" buatlah kelas dasar memanggil metode abstrak (yaitu harus-ditimpa) metode yang akan diberikan oleh kelas turunan Anda.

EDIT: Dan jika Anda kemudian memutuskan bahwa beberapa kelas turunan Anda tidak perlu memberikan "kode baru yang menarik" maka Anda dapat mengubah abstrak menjadi virtual dan menyediakan implementasi kelas dasar kosong dari fungsionalitas "yang disisipkan".

Kompilator Anda mungkin memiliki peringatan yang dapat dihasilkan jika fungsi kelas dasar disembunyikan. Jika ya, aktifkan. Itu akan menangkap bentrokan const dan perbedaan dalam daftar parameter. Sayangnya ini tidak akan mengungkap kesalahan ejaan.

Misalnya, ini adalah peringatan C4263 di Microsoft Visual C ++.

overrideKata kunci C ++ 11 ketika digunakan dengan deklarasi fungsi di dalam kelas turunan, itu memaksa kompilator untuk memeriksa bahwa fungsi yang dideklarasikan sebenarnya menimpa beberapa fungsi kelas dasar. Jika tidak, kompilator akan menampilkan kesalahan.

Oleh karena itu, Anda dapat menggunakan overridepenentu untuk memastikan polimorfisme dinamis (penggantian fungsi).

class derived: public base{
public:
  virtual void func_name(int var_name) override {
    // statement
  }
};