C ++ 'da bir nesnenin türünü bulma

Bir A sınıfım ve ondan miras alan başka bir sınıfım var, B, A tipi bir nesneyi parametre olarak kabul eden bir işlevi geçersiz kılıyorum, bu yüzden bir A'yı kabul etmem gerekiyor. Ancak, daha sonra yalnızca B'nin sahip olduğu işlevleri çağırıyorum, bu yüzden yanlış döndürmek ve iletilen nesne B tipi değilse devam etmek istemiyorum.

İşlevime iletilen nesnenin hangi tür olduğunu bulmanın en iyi yolu nedir?

dynamic_cast hile yapmalı

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

dynamic_castAnahtar kelime döküm geçerliliğini sağlamak için bir çalışma zamanı kontrolü yaptıktan, başka bir işaretçi veya referans türünden bir referans noktasını düşürdü.

Gerçek nesne türü olmayan bir türe işaretçi çevirmeye çalışırsanız, çevrimin sonucu NULL olacaktır. Gerçek nesne türü olmayan bir türe gönderme yapmaya çalışırsanız, çevrim bir bad_castistisna atar .

Dynamic_cast'in çalışması için Base sınıfında en az bir sanal işlev olduğundan emin olun.

Wikipedia konusu Çalışma zamanı türü bilgisi

RTTI, yalnızca polimorfik sınıflar için kullanılabilir, yani en az bir sanal yöntemi vardır. Uygulamada, bu bir sınırlama değildir çünkü temel sınıfların, bir temel işaretçiden silindikleri takdirde, türetilmiş sınıfların nesnelerinin düzgün temizleme gerçekleştirmesine izin vermek için sanal bir yıkıcıya sahip olması gerekir.

Dinamik döküm, problem tanımınız için en iyisidir, ancak sınıf türünü şu şekilde bulabileceğinizi eklemek istiyorum:

#include <typeinfo>

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

Buna RTTI denir , ancak neredeyse kesinlikle tasarımınızı burada yeniden gözden geçirmek istersiniz, çünkü türü bulmak ve ona göre özel şeyler yapmak kodunuzu daha kırılgan hale getirir.

Tamamlamak için, Robocide'den oluşturacağım ve bunun typeidname () kullanmadan tek başına kullanılabileceğini göstereceğim :

#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;
}

Çıktı:

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

Muhtemelen nesnelerinize bir kimlik "etiketi" gömün ve bunu A sınıfı nesneler ile B sınıfı nesneler arasında ayrım yapmak için kullanın.

Ancak bu, tasarımda bir kusur olduğunu gösterir. İdeal olarak, B'de A'nın sahip olmadığı yöntemler, A'nın bir parçası olmalı, ancak boş bırakılmalıdır ve B bunların üzerine yazar. Bu, sınıfa özgü kodu ortadan kaldırır ve daha çok OOP ruhuna uygundur.

Sen arıyorsun dynamic_cast<B*>(pointer)

Çünkü sınıfınız polimorfik değil. Deneyin:

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

Şimdi BaseClaspolimorfik. Sınıfı struct olarak değiştirdim çünkü bir yapının üyeleri varsayılan olarak geneldir.

Açıklamanız biraz kafa karıştırıcı.

Genel olarak konuşursak, bazı C ++ uygulamalarının bunun için mekanizmaları olmasına rağmen, tür hakkında soru sormanız gerekmez. Bunun yerine, A'ya gösterici üzerinde bir dynamic_cast yapmanız gerekir. Bunun yapacağı şey, çalışma zamanında, A'ya göstericinin gerçek içeriğinin kontrol edilmesidir. Eğer bir B'niz varsa, işaretçinizi B'ye götürürsünüz. Aksi takdirde, bir istisna veya sıfır alırsınız.

Diğerlerinin belirttiği gibi dynamic_cast kullanabilirsiniz. Ancak üzerinde çalıştığınız türetilmiş sınıfın türünü bulmak için genellikle dynamic_cast kullanmak kötü tasarıma işaret eder. Parametre olarak A işaretçisini alan bir işlevi geçersiz kılıyorsanız, A sınıfının kendi yöntemleriyle / verileriyle çalışabilmelidir ve B sınıfının verilerine bağlı olmamalıdır. yazdığınız yöntemin yalnızca B sınıfıyla çalışacağından eminseniz, B sınıfına yeni bir yöntem yazmalısınız.

Aşırı yüklenmiş fonksiyonları kullanın. Dynamic_cast veya hatta RTTI desteği gerektirmez:

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
    }
};

Yükseltme kitaplığına erişebiliyorsanız, belki ihtiyacınız olan type_id_with_cvr () işlevi, const, volatile, & ve && değiştiricilerini kaldırmadan veri türü sağlayabilir . İşte C ++ 11'de basit bir örnek:

#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;
}

Umarım bu yararlıdır.