constructores/destructores de la clase base abstracta de C++: corrección general

Question

Recientemente he actuado como un desarrollador, así que me lancé, obtuve un libro en C++ y aprendí a hacer las cosas correctamente. En mi cabeza, sé lo que me gustaría hacer. De hecho, quiero un Interface que cuando se hereda, debe ser anulado (si esto es posible?). Hasta el momento, tengo el siguiente:

class ICommand{ 

public: 
    // Virtual constructor. Needs to take a name as parameter 
    //virtual ICommand(char*) =0; 
    // Virtual destructor, prevents memory leaks by forcing clean up on derived classes? 
    //virtual ~ICommand() =0; 
    virtual void CallMe() =0; 
    virtual void CallMe2() =0; 
}; 

class MyCommand : public ICommand 
{ 
public: 
    // Is this correct? 
    MyCommand(char* Name) { /* do stuff */ } 
    virtual void CallMe() {} 
    virtual void CallMe2() {} 
}; 

propósito que me queda como creo que debería implementarse el constructor/de destructor en ICommand. Sé que si elimino los comentarios, no compilarán. Por favor, puede alguien:

1. Enséñame a declarar el constructor/destructor de en ICommand y la forma en que están destinados a ser utilizados en MyCommand
2. eso puse las cosas correctamente en ICommand modo que MyCommand debe invalidar CallMe y CallMe2 .

espero no haber perdido algo muy simple ...

Answer 1

C++ no permite constructores virtuales. Una aplicación sencilla (sin el constructor virtual) sería algo como esto:

class ICommand { 
public: 
    virtual ~ICommand() = 0; 
    virtual void callMe() = 0; 
    virtual void callMe2() = 0; 
}; 

ICommand::~ICommand() { } // all destructors must exist 

Tenga en cuenta que incluso un destructor virtual puro must definirse.

Una aplicación concreta se vería exactamente como su ejemplo:

class MyCommand : public ICommand { 
public: 
    virtual void callMe() { } 
    virtual void callMe2() { } 
}; 

Usted tiene un par de options para el constructor. Una opción es desactivar el constructor por defecto para ICommand, de manera que las subclases se tener para implementar un constructor que llama a su constructor ICommand:

#include <string> 

class ICommand { 
private: 
    const std::string name; 
    ICommand(); 
public: 
    ICommand(const std::string& name) : name(name) { } 
    virtual ~ICommand() = 0; 
    virtual void callMe() = 0; 
    virtual void callMe2() = 0; 
}; 

ICommand::~ICommand() { } // all destructors must exist 

Una aplicación concreta podría ahora ser algo como esto:

class MyCommand : public ICommand { 
public: 
    MyCommand(const std::string& name) : ICommand(name) { } 
    virtual void callMe() { } 
    virtual void callMe2() { } 
};