Здравствуйте, можно ли, сделать так:
создать абстрактный класс (назовём его BaseA)

class BaseA{
  class Dummy {};
public:
  virtual void Init (Dummy *pThis) = 0;
};

а в его потомках переопределять Init шаблоном:

class A: public BaseA {
  class Dummy {};
  Dummy      *m_ptr;
public:
  template <class T>
     void Init (T *pThis);
};

судя по моим попыткам — нельзя, как можно такой сделать?
хочется чтобы мжно было обращаться к методам классов потомкам BaseA через BaseA->Init ();

Здравствуйте, butcher, Вы писали:

B>Здравствуйте, можно ли, сделать так:
B>создать абстрактный класс (назовём его BaseA)
B>

B>class BaseA{
B>  class Dummy {};
B>public:
B>  virtual void Init (Dummy *pThis) = 0;
B>};
B>

B>а в его потомках переопределять Init шаблоном:
B>

B>class A: public BaseA {
B>  class Dummy {};
B>  Dummy      *m_ptr;
B>public:
B>  template <class T>
B>     void Init (T *pThis);
B>};
B>

B>судя по моим попыткам — нельзя, как можно такой сделать?
B>хочется чтобы мжно было обращаться к методам классов потомкам BaseA через BaseA->Init ();

Ну так и пиши внутри функции из А
BaseA::Init();

You will always get what you always got
  If you always do  what you always did

J>Ну так и пиши внутри функции из А
J>BaseA::Init();

А Init предка не скроется? Using не надо?

Здравствуйте, Vamp, Вы писали:

J>>Ну так и пиши внутри функции из А
J>>BaseA::Init();

V>А Init предка не скроется? Using не надо?

Когда используешь явную квалификацию BaseA::Init(); компилятору начхать, что там где скрывается

You will always get what you always got
  If you always do  what you always did

Здравствуйте, jazzer, Вы писали:

J>Здравствуйте, butcher, Вы писали:

J>Ну так и пиши внутри функции из А
J>BaseA::Init();
нее, Вы меня не поняли.. попробую изъясниться ещё раз:
пример:

#pragma warning (disable:4786)

#include    <conio.h>
#include    <iostream>
#include    <string>
#include    <vector>

class BaseA {
public:
    virtual void    Method (void) = 0;
};

class A: public BaseA {
    std::string    m_str;
public:
                A (std::string str): m_str(str) {};
                void    Method (void){std::cout<<m_str<<"\n";}
};
class B: public BaseA {
    double        m_dig;
public:
                B (double dig): m_dig(dig) {};
                void    Method (void){std::cout<<m_dig<<"\n";}
};

void main (void)
{
    std::vector<BaseA*> v;
    std::vector<BaseA*>::iterator i;
    A    a1("Line 1"),
        a2("Line 2"),
        a3("Line 3");
    B    b1(1234.12);
    v.push_back(&a1);
    v.push_back(&a2);
    v.push_back(&a3);
    v.push_back(&b1);
    for (i=v.begin();i!=v.end();++i)
        static_cast<BaseA*>(*i)->Method();
    getch();
}

вот, хочется чтобы в потомке от BaseA Init стала шаблонной, но к ней можно было бы обратится через родительский Init

B>вот, хочется чтобы в потомке от BaseA Init стала шаблонной, но к ней можно было бы обратится через родительский Init
Что-то не видно этой самой "Init" и зачем она нужна...

Здравствуйте, konst, Вы писали:

B>>вот, хочется чтобы в потомке от BaseA Init стала шаблонной, но к ней можно было бы обратится через родительский Init
K>Что-то не видно этой самой "Init" и зачем она нужна...

Здесь другой пример, тут вместо Init используется Method

Здравствуйте, butcher, Вы писали:

B>Здравствуйте, можно ли, сделать так:
B>создать абстрактный класс (назовём его BaseA)
B>

B>class BaseA{
B>  class Dummy {};
B>public:
B>  virtual void Init (Dummy *pThis) = 0;
B>};
B>

B>а в его потомках переопределять Init шаблоном:
B>

B>class A: public BaseA {
B>  class Dummy {};
B>  Dummy      *m_ptr;
B>public:
B>  template <class T>
B>     void Init (T *pThis);
     // только BaseA::Dummy должен быть видимым, а у тебя он private, сделай хотя бы protected
     void Init (BaseA::Dummy *pThis) { Init<>(pThis); }
B>};
B>

B>судя по моим попыткам — нельзя, как можно такой сделать?
B>хочется чтобы мжно было обращаться к методам классов потомкам BaseA через BaseA->Init ();

Да, теперь понял

надо так:
объявляешь свою шаблонную Init и обычную функцию, удовлетворяющую перекрывающую твою виртуальную функцию, и из не зовешь шаблонную

You will always get what you always got
  If you always do  what you always did

Здравствуйте, butcher, Вы писали:

B>Здесь другой пример, тут вместо Init используется Method
Тогда не понятно, почему его надо делать шаблонным. Схитрить хочешь? Чтоб автоматически типы приводились? Скорее всего автоматически не получица

Здравствуйте, butcher, Вы писали:

B>Здравствуйте, можно ли, сделать так:
B>создать абстрактный класс (назовём его BaseA)
B>

B>class BaseA{
B>  class Dummy {};
B>public:
B>  virtual void Init (Dummy *pThis) = 0;
B>};
B>

B>а в его потомках переопределять Init шаблоном:
B>

B>class A: public BaseA {
B>  class Dummy {};
B>  Dummy      *m_ptr;
B>public:
B>  template <class T>
B>     void Init (T *pThis);
B>};
B>

B>судя по моим попыткам — нельзя, как можно такой сделать?
B>хочется чтобы мжно было обращаться к методам классов потомкам BaseA через BaseA->Init ();

Думаю нельзя, поскольку реализация чисто абстрактного метода будет определяться компиляторам по его сигнатуре в купе с именем, но шаблон не даст такой возможности.