Полиморфизм с++ Что не так с этим кодом? (2 стр)

Stuw
> Если ты собрался работать с интерфейсом, работай с интерфейсом, а не пытайся
> вылезти за его пределы.

Я собрался найти ответ, на чотко поставленный вопрос. Шо за манера дураццкая? Задаёшь один вопрос, ответы вапще на другие вопросы

Zefick
> Больше никак.

Ну а если даже, пусть и не портируемый полухаккерский трюк?
Хоть что нибудь можно придумать?

Kartonagnick
> Хоть что нибудь можно придумать?

тут не придумывать нужно, тут подумать нужно :)

innuendo
> тут не придумывать нужно, тут подумать нужно :)

Ну це пись пись же умеет как то определять фактический тип объекта.
Значит можно как то его выудить!

Вооот... надо подумать))

действительно, это цэ пись пись :)

Kartonagnick
> Ну а если даже, пусть и не портируемый полухаккерский трюк?
  Так ты уже предложил сам, что ещё надо?

Kartonagnick
> Нет. Формально там Derived*. Но компилятор почему то парсит в Base*
> Типа правила языка такие на этот случай предусмотрены.
>
> ((Derrived*)(ptr->clone()))->Test(); //вот так можно.

Так нельзя. Компилятор правильно делает, Base - интерфейс для работы с группой классов. Решений несколько

В твоем случае наиболее правильным будет

struct BaseEx: public Base
{
  virtual void Test() const =0;
};
struct Derived : public BaseEx
{
...
};
...
void main()
{
  Base* ptr;
...
  if(BaseEx *pDeri = dynamic_cast<BaseEx*>(ptr)) 
  {
    pDeri->Test();
  }
}

Kartonagnick
> Stuw
> > Если ты собрался работать с интерфейсом, работай с интерфейсом, а не пытайся
> > вылезти за его пределы.
>
> Я собрался найти ответ, на чотко поставленный вопрос. Шо за манера дураццкая?
> Задаёшь один вопрос, ответы вапще на другие вопросы

Я на это отвечал:
Kartonagnick
> ((Derrived*)(ptr->clone()))->Test(); //вот так можно.
>
> Как сделать тоже самое, ток без явного приведения?

Stuw
> делать dynamic_cast
Не обязательно:

template <typename T> class Base {
public:
  virtual T* clone() = 0;
};

class Derived : public Base<Derived> {
public:
  Derived* clone() { return new Derived; }
  int test() { return 1; }
};

int main()
{
  Derived *foo = new Derived;
  return foo->clone()->test();
}

KpeHDeJIb
с шаблоном не айс, ибо смысл теряется. Смысл как раз таки в том, что бы "не ведая типа" в рантайме толкнуть метод, который знание об этом самом типе вернет.

В псевдокоде это могло бы выглядеть вот так: 

int main()
{
  Base*foo = new Derived;

   ( typeof(foo) ) newFoo;

   newFoo.test();
}

Но на с++ нет такой конструктивы, которая бы вернула знание о типе так, что бы его можно было нормально использовать.
Я пробовал сам задавать свой костыльный typeof , но все мои потуги разбивались о неприступную "требуется константа времени компиляции". И хоть ты тресни!

Неее, ну сделать что то типа вот такого: 

Kartonagnick
> Смысл как раз таки в том, что бы "не ведая типа" в рантайме толкнуть метод,
> который знание об этом самом типе вернет.
Вендошная Component Object Model не подойдет? Через IUnknown всегда можно спросить GUID объекта.

Kartonagnick
> Неее, ну сделать что то типа вот такого:
> myClass obj; typeof(obj) newObj; //будит создан новый объект такого же типа,
> как указанный в аргументе
>
> Не сложно. Но опять таки, подобная конструктива выдаст тип Base, а не Derived
Не улавливаю. У нас есть MyClass*. Мы не должны делать предположений об фактическом типе за указателем, потому что там может быть все, что угодно. (Можно делать предположения о типе, но без проверки не стоит, имхо). Поэтому Derived* можно получить только через dynamic_cast и аналоги.

Kartonagnick

чем это

 Base*foo = new Derived;
 ( typeof(foo) ) newFoo;
 newFoo.test();

отличается от этого

 Base* foo = new Derived;
 Derived& newFoo = dinamic_cast<Derived&>(*foo);
 newFoo.test();

LuckyMan, в первом случае вызывающая сторона в рантайме вычисляет "истинный" тип foo.
Во втором случае - явно указывается программистом