Mengapa Pewarisan Berbilang dengan Fungsi Terlalu Beban Membawa kepada Kekaburan dalam C ?

Pembebanan Fungsi dengan Pewarisan Berbilang Jenis Berbeza

Dalam pengaturcaraan berorientasikan objek, pewarisan berbilang membenarkan subkelas mewarisi kaedah dan atribut daripada berbilang kelas ibu bapa. Walau bagaimanapun, apabila berbilang kelas induk mentakrifkan kaedah dengan nama yang sama tetapi tandatangan berbeza (fungsi terlebih beban), ia boleh membawa kepada kekaburan semasa panggilan fungsi. Artikel ini menerangkan sebab fungsi terlampau beban dengan nama yang sama dan tandatangan berbeza tidak dilayan sedemikian dalam kes warisan berbilang dan meneroka kemungkinan penyelesaian.

Penerangan Masalah

Pertimbangkan coretan kod berikut:

#include <iostream>

struct Base1 {
    void foo(int) {}
};

struct Base2 {
    void foo(float) {}
};

struct Derived : public Base1, public Base2 {
};

int main() {
    Derived d;
    d.foo(5); // Ambiguous call to 'foo'
}

Dalam contoh ini, kelas Terbitan mewarisi dua fungsi foo() yang berlebihan daripada kelas induknya, Base1 dan Base2. Walau bagaimanapun, apabila kami cuba memanggil d.foo(5), kami mendapat ralat panggilan yang tidak jelas kerana pengkompil tidak dapat menentukan fungsi foo() yang hendak dipanggil. Ini kerana kedua-dua fungsi mempunyai nama yang sama tetapi jenis hujah yang berbeza.

Memahami Lebihan Fungsi dalam Warisan

Melebihi beban fungsi membenarkan kelas mempunyai berbilang kaedah dengan nama yang sama tetapi parameter berbeza. Setiap fungsi terlebih beban dibezakan berdasarkan bilangan, jenis dan susunan hujahnya. Dalam konteks warisan tunggal, lebihan fungsi berfungsi seperti yang dijangkakan: pengkompil memilih fungsi yang sesuai berdasarkan jenis argumen yang digunakan dalam panggilan fungsi.

Pewarisan Berbilang dan Kekaburan

Walau bagaimanapun, dalam kes pewarisan berbilang, peraturan untuk carian fungsi menjadi lebih kompleks. Apabila nama fungsi dicari dalam kelas C, pengkompil mempertimbangkan semua pengisytiharan fungsi itu dalam C dan kelas asasnya. Jika berbilang pengisytiharan fungsi yang sama ditemui, sebarang pengisytiharan yang disembunyikan oleh perisytiharan lain dalam kelas terbitan akan dihapuskan.

Jika pengisytiharan yang selebihnya bukan semua daripada subkelas jenis yang sama atau jika set termasuk ahli bukan statik dan ahli daripada subkelas yang berbeza, kekaburan berlaku, dan program itu dianggap tidak berbentuk. Ini betul-betul situasi dalam contoh sebelumnya, di mana d.foo(5) memanggil kedua-dua Base1::foo(int) dan Base2::foo(float), mengakibatkan kekaburan.

Menyelesaikan Kekaburan

Untuk menyelesaikan kekaburan dan menjadikan kod itu sah, satu penyelesaian ialah menggunakan menggunakan pengisytiharan. Pengisytiharan menggunakan memperkenalkan nama ke dalam skop kelas semasa yang dikaitkan dengan nama daripada kelas lain. Dalam contoh di atas, kita boleh menggunakan yang berikut:

struct Derived : public Base1, public Base2 {
    using Base1::foo;
    using Base2::foo;
};

Dengan menggunakan pengisytiharan penggunaan secara eksplisit, kami menentukan versi foo() yang hendak digunakan daripada setiap kelas asas. Ini menyelesaikan kekaburan dan membenarkan kod untuk disusun dengan jayanya.

Gelagat Fallback

Perlu diambil perhatian bahawa coretan kod kedua dalam soalan asal disusun tanpa ralat kerana fungsi foo(float) ditakrifkan dalam skop kelas Terbitan. Oleh itu, apabila d.foo(5) dipanggil, ia memutuskan kepada Derived::foo(float) tanpa sebarang kesamaran.

Atas ialah kandungan terperinci Mengapa Pewarisan Berbilang dengan Fungsi Terlalu Beban Membawa kepada Kekaburan dalam C ?. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!