> -- Илья Ермаков писал(а):
> Вот ведь разработчикам компилятора наверняка даже в голову прийти не могло, что какой-то псих будет так dynamic_cast использовать.

Прикинув, что это интересная задачка, я реализовал "obron cast" для "oberon-style расширений типа". Вот что получилось:
## Код:
```
#include "oberon_cast.h"

struct X : oberon::inherit<X>
{
};    

struct X1 : oberon::inherit<X1, X>
{
};    

struct X2 : oberon::inherit<X2, X1>
{
};    

struct X3 : oberon::inherit<X3, X2>
{
};    

void check_type(const X &x)
{
    if (const X3 *x3 = oberon::cast<X3>(x))
        handle3(*x3);
    else if (const X2 *x2 = oberon::cast<X2>(x))
        handle2(*x2);
    else if (const X1 *x1 = oberon::cast<X1>(x))
        handle1(*x1);
    else               
        handle(x);
}
```


Так как все стало очень быстро, то я увеличил количество итераций. Вот результат:
BB: 24 c
VC9: 19 c

Вывод: если очень хочется, то можно и на C++
Можно сделать еще быстрее, если ограничить число глубину наследований разумным числом (вряд ли на практике глубина будет больше 10).

А вот и заветный "oberon_cast.h" для тех, кто вынужден писать на C++ (Владимир Лось?) и ему не хватает эффективного "oberon message bus" в C++В решении не используются нестандартные расширения, голый C++. Компилируется VC/gcc/comeau.

## Код:
```
namespace oberon {

typedef const int *type_signature;

struct type_hierarchy
{
    type_signature *m_phierarchy;
    int m_cn;
};

struct type
{
    static const int k_cn_inherited = -1;

    type() : m_type(0) {}

    const type_hierarchy *m_type;
};

template <typename T>
void
init_type_info(type_signature *hierarchy)
{
    hierarchy[T::k_cn_inherited] = &T::k_cn_inherited;
    init_type_info<typename T::base>(hierarchy);
}

template <>
inline
void
init_type_info<type>(type_signature *hierarchy)
{
}

template <typename T, typename B = type>
struct inherit : B
{
    typedef B base;
    static const int k_cn_inherited = base::k_cn_inherited + 1;

    struct type_info : type_hierarchy
    {
        type_signature m_hierarchy[k_cn_inherited + 1];

        type_info()
        {
            m_phierarchy = m_hierarchy;
            m_cn = k_cn_inherited;
            init_type_info<T>(m_hierarchy);
        }
    };

    inherit()
    {
    static type_info s_type_info;
        this->m_type = &s_type_info;
    }
};


template <typename T>
const T *
cast(const type &o)
{
const type_hierarchy &dynamic_type = *o.m_type;
    if (dynamic_type.m_cn < T::k_cn_inherited
     || dynamic_type.m_phierarchy[T::k_cn_inherited] != &T::k_cn_inherited)
        return 0;

    return static_cast<const T *>(&o);    
}

} // namespace oberon
```
