Menemukan jenis objek di C ++

Saya memiliki kelas A dan kelas lain yang mewarisi darinya, B. Saya mengganti fungsi yang menerima objek tipe A sebagai parameter, jadi saya harus menerima A. Namun, saya kemudian memanggil fungsi yang hanya dimiliki oleh B, jadi saya ingin mengembalikan false dan tidak melanjutkan jika objek yang dilewati bukan dari tipe B.

Apa cara terbaik untuk mengetahui tipe objek yang diteruskan ke fungsi saya?

dynamic_cast harus melakukan triknya

TYPE& dynamic_cast<TYPE&> (object);
TYPE* dynamic_cast<TYPE*> (object);

Itu dynamic_cast kunci melempar datum dari satu penunjuk atau tipe referensi ke yang lain, melakukan pemeriksaan runtime untuk memastikan validitas pemeran.

Jika Anda mencoba melakukan cast ke pointer ke tipe yang bukan tipe objek aktual, hasil dari cast akan NULL. Jika Anda mencoba melakukan cast untuk merujuk ke tipe yang bukan tipe objek aktual, para pemain akan melemparkan bad_castpengecualian.

Pastikan setidaknya ada satu fungsi virtual di kelas Base untuk membuat dynamic_cast berfungsi.

Topik Wikipedia Informasi jenis waktu berjalan

RTTI hanya tersedia untuk kelas yang polimorfik, yang berarti mereka memiliki setidaknya satu metode virtual. Dalam praktiknya, ini bukan batasan karena kelas dasar harus memiliki destruktor virtual untuk memungkinkan objek kelas turunan melakukan pembersihan yang tepat jika dihapus dari pointer basis.

Pemain dinamis adalah yang terbaik untuk deskripsi masalah Anda, tetapi saya hanya ingin menambahkan bahwa Anda dapat menemukan jenis kelas dengan:

#include <typeinfo>

...
string s = typeid(YourClass).name()

Ini disebut RTTI , tetapi Anda hampir pasti ingin mempertimbangkan kembali desain Anda di sini, karena menemukan jenis dan melakukan hal-hal khusus berdasarkan itu membuat kode Anda lebih rapuh.

Untuk melengkapi, saya akan membangun Robocide dan menunjukkan bahwa typeiddapat digunakan sendiri tanpa menggunakan nama ():

#include <typeinfo>
#include <iostream>

using namespace std;

class A {
public:
    virtual ~A() = default; // We're not polymorphic unless we
                            // have a virtual function.
};
class B : public A { } ;
class C : public A { } ;

int
main(int argc, char* argv[])
{
    B b;
    A& a = b;

    cout << "a is B: " << boolalpha << (typeid(a) == typeid(B)) << endl;
    cout << "a is C: " << boolalpha << (typeid(a) == typeid(C)) << endl;
    cout << "b is B: " << boolalpha << (typeid(b) == typeid(B)) << endl;
    cout << "b is A: " << boolalpha << (typeid(b) == typeid(A)) << endl;
    cout << "b is C: " << boolalpha << (typeid(b) == typeid(C)) << endl;
}

Keluaran:

a is B: true
a is C: false
b is B: true
b is A: false
b is C: false

Mungkin menanamkan ke dalam ID Anda "tag" dan menggunakannya untuk membedakan antara objek kelas A dan objek kelas B.

Namun ini menunjukkan kelemahan dalam desain. Idealnya metode-metode dalam B yang tidak dimiliki A, harus menjadi bagian dari A tetapi dibiarkan kosong, dan B menimpa mereka. Ini menghilangkan kode kelas khusus dan lebih dalam semangat OOP.

Anda sedang mencari dynamic_cast<B*>(pointer)

Karena kelas Anda bukan polimorfik. Mencoba:

struct BaseClas { int base; virtual ~BaseClas(){} };
class Derived1 : public BaseClas { int derived1; };

Sekarang BaseClasadalah polimorfik. Saya mengubah kelas menjadi struct karena anggota suatu struct adalah publik secara default.

Deskripsi Anda sedikit membingungkan.

Secara umum, meskipun beberapa implementasi C ++ memiliki mekanisme untuk itu, Anda tidak seharusnya bertanya tentang jenisnya. Sebagai gantinya, Anda seharusnya melakukan dynamic_cast pada pointer ke A. Apa yang akan dilakukan adalah saat runtime, isi aktual dari pointer ke A akan diperiksa. Jika Anda memiliki B, Anda akan mendapatkan pointer ke B. Jika tidak, Anda akan mendapatkan pengecualian atau null.

Seperti yang ditunjukkan orang lain, Anda dapat menggunakan dynamic_cast. Tetapi umumnya menggunakan dynamic_cast untuk mengetahui jenis kelas turunan yang Anda kerjakan menunjukkan desain yang buruk. Jika Anda meng-override fungsi yang mengambil pointer A sebagai parameter maka itu harus dapat bekerja dengan metode / data kelas A itu sendiri dan tidak boleh bergantung pada data kelas B. Dalam kasus Anda, alih-alih menimpa jika Anda yakin bahwa metode yang Anda tulis hanya akan bekerja dengan kelas B, maka Anda harus menulis metode baru di kelas B.

Gunakan fungsi kelebihan beban. Tidak memerlukan dynamic_cast atau bahkan dukungan RTTI:

class A {};
class B : public A {};

class Foo {
public:
    void Bar(A& a) {
        // do something
    }
    void Bar(B& b) {
        Bar(static_cast<A&>(b));
        // do B specific stuff
    }
};

Jika Anda dapat mengakses perpustakaan tambahan, mungkin fungsi type_id_with_cvr () adalah yang Anda butuhkan, yang dapat memberikan tipe data tanpa menghapus const, volatile, & dan && modifier . Berikut adalah contoh sederhana dalam C ++ 11:

#include <iostream>
#include <boost/type_index.hpp>

int a;
int& ff() 
{
    return a;
}

int main() {
    ff() = 10;
    using boost::typeindex::type_id_with_cvr;
    std::cout << type_id_with_cvr<int&>().pretty_name() << std::endl;
    std::cout << type_id_with_cvr<decltype(ff())>().pretty_name() << std::endl;
    std::cout << typeid(ff()).name() << std::endl;
}

Semoga ini bermanfaat.