template <typename TExecuter>
class TCommand
{
public:
    typedef int (TExecuter::*Action)(void*);

    TCommand(TExecuter* pExecuter, Action pfnAction)
        : m_pExecuter(pExecuter)
        , m_pfnAction(pfnAction) { }

private:
    TExecuter*                m_pExecuter;
    Action                    m_pfnAction;

public:
    virtual int                Execute(void* pvParam)
    { return (m_pExecuter->*m_pfnAction)(pvParam); }
};

class CCommand
{
public:
    virtual int                Execute(void* pvParam) { return 0; }
};

class CReceiveFile : public CCommand
{
public:
    int                        Execute(void* pvParam)
    {
        char*    szParam = static_cast<char*> (pvParam);
        int        iLen = strlen(szParam);
        for(int i=0, j=iLen-1; i<iLen/2; i++, j--)
        {
            szParam[i] = szParam[i] ^ szParam[j];
            szParam[j] = szParam[j] ^ szParam[i];
            szParam[i] = szParam[i] ^ szParam[j];
        }
        return iLen;
    }

private:
    // На что повлияет введение этой переменной?
    HANDLE                    m_hFile;
};

class CProtocol
{
public:
    enum ECommads
    {
        Command = 1, 
        Server, 
        Client, 
        Request, 
        Answer, 
        File
    };

private:
    ECommads                m_eCommands;
    TCommand<CCommand>*        m_pCommand;

public:
    CProtocol() : m_eCommands(File), m_pCommand(NULL) { }
    ~CProtocol() {}

    int                        Process(void* pvBuffer)
    {
        switch(m_eCommands)
        {
        Server:
            break;
        Client:
            break;
        Request:
            break;
        Answer:
            break;
        File:
            // здесь траблы с типами, что я делаю не так?
            m_pCommand = reinterpret_cast<TCommand<CCommand>*>
                ((new CReceiveFile()), (&CReceiveFile::Execute));
            break;
        }
        // Безопасен ли этот вызов?
        return m_pCommand->Execute(pvBuffer);
    }
};

int _tmain(int argc, _TCHAR* argv[])
{
    char        szTest[] = "abcdefg";
    CProtocol*    pProtocol = new CProtocol();
    pProtocol->Process(szTest);
}

F>m_pCommand = reinterpret_cast<TCommand<CCommand>*>((new CReceiveFile()), (&CReceiveFile::Execute));

m_pCommand = new TCommand<CCommand>( new CReceiveFile(), &CReceiveFile::Execute );

F>>m_pCommand = reinterpret_cast<TCommand<CCommand>*>((new CReceiveFile()), (&CReceiveFile::Execute));
К>

К>m_pCommand = new TCommand<CCommand>( new CReceiveFile(), &CReceiveFile::Execute );
К>

error C2664: 'TCommand<TExecuter>::TCommand(TExecuter *,TCommand<TExecuter>::Action)' : cannot convert parameter 2 from 'int (__thiscall CReceiveFile::* )(void *)' to 'TCommand<TExecuter>::Action'
        with
        [
            TExecuter=CCommand
        ]
        and
        [
            TExecuter=CCommand
        ]
        Types pointed to are unrelated; conversion requires reinterpret_cast, C-style cast or function-style cast
d:\Faust\Projects\Win\MainCL\Main.cpp(211) : warning C4060: switch statement contains no 'case' or 'default' labels

m_pCommand = new TCommand<CCommand>(
               new CReceiveFile(),
               static_cast< TCommand<CCommand>::Action> >(&CReceiveFile::Execute)
             );

К>m_pCommand = new TCommand<CCommand>(
К>               new CReceiveFile(),
К>               static_cast< TCommand<CCommand>::Action> >(&CReceiveFile::Execute)
К>             );
К>

reinterpret_cast< TCommand<CCommand>::Action >(&CReceiveFile::Execute)

reinterpret_cast< TCommand<CCommand>::*Action >(&CReceiveFile::Execute)

class Base
{
public:
    bool                    m_bFlag;

    Base() : m_bFlag(false)

    virtual bool            Process0(void) = 0;
    virtual bool            Process1(void) { return m_bFlag; }
}

class DerivedLevel1 : public Base
{
public:
    int                        m_iParam;

    DerivedLevel1() : m_iParam(0)

    virtual bool            Process0(void) { m_bFlag = true; m_iParam++; }
    virtual bool            Process1(void) { return m_bFlag; }
}

int _tmain(int argc, _TCHAR* argv[])
{
    Base*        pBaseFirst = static_cast<Base*> (new DerivedLevel1());
    Base*        pBaseSecond = reinterpret_cast<Base*> (new DerivedLevel1());
}

class Base1
{
  char x[100];
};

class Base2
{
public:
  virtual void foo() {}
};

class Derived: public Base1, public Base2
{
public:
  virtual void foo() {}
};

main()
{
  Derived* p0 = new Derived();
  Base2* p1 = static_cast<Base2*>(p0);
  Base2* p2 = reinterpret_cast<Base2*>(p0);
}