> -- AVC писал(а):
> А что тут гадать?

И все-такиИнтересно же, сколько это будет в граммахЯ не поленился и написал вот такой тестик: 100 миллионов сравнений на принадлежность одному из 3 расширений типа.

## Код:
```
MODULE TestCast;

TYPE
   X = EXTENSIBLE RECORD END;
   X1 = EXTENSIBLE RECORD (X) END;
   X2 = EXTENSIBLE RECORD(X1) END;
   X3 = EXTENSIBLE RECORD(X2) END;
   
PROCEDURE handle(IN x: X);
END handle;

PROCEDURE handle1(IN x: X1);
END handle1;

PROCEDURE handle2(IN x: X2);
END handle2;

PROCEDURE handle3(IN x: X3);
END handle3;

PROCEDURE test_cast(IN x: X);
BEGIN
   WITH 
      x: X3 DO
      handle3(x);
   |   x: X2 DO
      handle2(x);
   |   x: X1 DO
      handle1(x);
   ELSE
      handle(x);
   END
END test_cast;

PROCEDURE main*();
VAR 
   x: X;
   x1: X1;
   x2: X2;
   x3: X3;
   i: INTEGER;
BEGIN
   FOR i := 0 TO 100000000 DO
      test_cast(x);
      test_cast(x1);
      test_cast(x2);
      test_cast(x3);
   END
END main;

END TestCast.
```


И вот такой аналогичный тест для C++ и его тормозного dynamic_cast:
## Код:
```
struct X
{
    virtual ~X(){}
};

struct X1 : X
{
};

struct X2 : X1
{
};

struct X3 : X2
{
};

void handle(const X &x)
{
}

void handle1(const X1 &x)
{
}

void handle2(const X2 &x)
{
}

void handle3(const X3 &x)
{
}

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

int main()
{
X x;
X1 x1;
X2 x2;
X3 x3;
    for (int i = 0; i < 100000000; i++)
    {
    check_type(x);
    check_type(x1);
    check_type(x2);
    check_type(x3);
    }
    return 0;
}
```


Все этом варианте все функции были разнесены по разным единацам компиляции, чтобы оптимизатор не повыкидывал все нафиг.

Результат:
BB: 2.4 с
VC9: 49 с

Вывод: решения на основе "oberon message bus" с использованием dynamic_cast в C++ действительно могут оказаться неэффективными с точки зрения производительности. Разница в скорости динамической проверки типа порядка 20 раз.