Нахождение типа объекта в C ++

У меня есть класс A и другой класс, который наследуется от него, B. Я переопределяю функцию, которая принимает объект типа A в качестве параметра, поэтому я должен принять A. Однако позже я вызываю функции, которые имеет только B, поэтому я хочу вернуть false и не продолжать, если переданный объект не относится к типу B.

Каков наилучший способ узнать, какой тип объекта передается моей функции?

dynamic_cast должен сделать свое дело

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

dynamic_castКлючевое слово бросает геодезическое от одного указателя или ссылочного типа к другому, выполняя проверку выполнения для обеспечения достоверности гипсе.

Если вы попытаетесь привести к указателю на тип, который не является типом фактического объекта, результатом приведения будет NULL. Если вы попытаетесь привести к ссылке на тип, который не является типом фактического объекта, приведение вызовет bad_castисключение.

Убедитесь, что в Базовом классе есть хотя бы одна виртуальная функция для работы dynamic_cast.

Википедия тема Информация о типе времени выполнения

RTTI доступен только для полиморфных классов, что означает, что у них есть хотя бы один виртуальный метод. На практике это не является ограничением, поскольку базовые классы должны иметь виртуальный деструктор, чтобы объекты производных классов могли выполнять надлежащую очистку, если они удалены из базового указателя.

Динамическое приведение является лучшим для вашего описания проблемы, но я просто хочу добавить, что вы можете найти тип класса с помощью:

#include <typeinfo>

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

Это называется RTTI , но вы почти наверняка захотите пересмотреть свой дизайн здесь, потому что поиск типа и выполнение специальных действий на его основе делает ваш код более хрупким.

Просто чтобы закончить, я соберу сборку из Robocide и укажу, что typeidее можно использовать отдельно, без использования name ():

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

Вывод:

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

Вероятно, встраивайте в ваши объекты идентификатор «тег» и используйте его, чтобы различать объекты класса А и объекты класса В.

Это однако показывает недостаток в дизайне. В идеале те методы в B, которых у A нет, должны быть частью A, но оставлены пустыми, и B перезаписывает их. Это устраняет специфический для класса код и больше соответствует духу ООП.

Ты ищешь dynamic_cast<B*>(pointer)

Потому что ваш класс не полиморфный. Пытаться:

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

Сейчас BaseClasполиморфный. Я изменил класс на struct, потому что члены структуры по умолчанию являются публичными.

Ваше описание немного сбивает с толку.

Вообще говоря, хотя некоторые реализации C ++ имеют механизмы для этого, вы не должны спрашивать о типе. Вместо этого вы должны сделать dynamic_cast для указателя на A. Что это будет делать, так это то, что во время выполнения будет проверяться фактическое содержимое указателя на A. Если у вас есть B, вы получите указатель на B. В противном случае вы получите исключение или ноль.

Как указали другие, вы можете использовать dynamic_cast. Но в целом использование dynamic_cast для определения типа производного класса, с которым вы работаете, указывает на плохой дизайн. Если вы переопределяете функцию, которая принимает указатель A в качестве параметра, тогда она должна иметь возможность работать с методами / данными самого класса A и не должна зависеть от данных класса B. В вашем случае вместо переопределения, если вы уверены, что метод, который вы пишете, будет работать только с классом B, тогда вам следует написать новый метод в классе B.

Используйте перегруженные функции. Не требует dynamic_cast или даже 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
    }
};

Если вы можете получить доступ к библиотеке надстроек , возможно, вам нужна функция type_id_with_cvr () , которая может предоставить тип данных без удаления модификаторов const, volatile, & и & && . Вот простой пример в 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;
}

Надеюсь, это полезно.