override C++ virtual method

Question

Tengo una plantilla de clase donde algunos métodos se definen como virtuales para dar la posibilidad al usuario de mi clase de darles una implementación en su clase derivada. Tenga en cuenta que en mi clase de plantilla hay algunos métodos no virtuales que hacen uso del virtual (se llama a una clase virtual que debe devolver un valor en una clase no virtual).

¿Puede darme un ejemplo simple de un código correcto donde el método virtual de la clase padre debe devolver un valor (pero su implementación se proporciona en una clase hija) y el valor devuelto por el método virtual en la clase padre se usa en otros métodos de esa clase. Porque vi en alguna parte (por ejemplo aquí: Safely override C++ virtual functions) que esto puede causar algunos problemas y el método definido por el usuario anulará el método virtual de la clase padre.

Nota: programo con Code :: Blocks usando el compilador g ++.

EDIT: conforme a lo solicitado aquí un simple ejemplo de lo que quiero:

template<typename T> 
class parent { 
public: 
    // Public methods that user can call 
    int getSomething(T t); 
    void putSomething(T t, int x); 

    // public method that user should implement in his code 
    virtual float compute(T t) { } 

    // protected or private methods and attributes used internally by putSomething ... 
    float doComplexeThings(...); // this can call 
}; 

El cómputo método() debe ser aplicada por el usuario (la clase hija). Sin embargo, este método compute() es llamado por putSomething() y doComplexeThings() por ejemplo.

Answer 1

Sólo tiene que asegurarse de que los métodos tengan la misma firma (incluidos los modificadores const/mutable y los tipos de argumentos). Puede utilizar una definición virtual pura para provocar errores de compilación si no puede anular la función en una subclase.

class parent { 
public: 
    // pure virtual method must be provided in subclass 
    virtual void handle_event(int something) = 0; 
}; 

class child : public parent { 
public: 
    virtual void handle_event(int something) { 
    // new exciting code 
    } 
}; 

class incomplete_child : public parent { 
public: 
    virtual void handle_event(int something) const { 
    // does not override the pure virtual method 
    } 
}; 

int main() { 
    parent *p = new child(); 
    p->handle_event(1); // will call child::handle_event 
    parent *p = new incomplete_child(); // will not compile because handle_event 
             // was not correctly overridden 
} 

Answer 2

Si puede utilizar C++ 11 características en su compilador entonces anula puede ser etiquetado como así con el override identificador especial:

float compute() override; 

La línea anterior en una clase derivada causará un compilador error ya que la función no anula una función miembro en la base (firma incorrecta, argumento faltante). Pero tenga en cuenta que esto debe hacerse en cada clase derivada, no es una solución que pueda imponer desde la clase base.

Desde la clase base solo puede forzar anular haciendo que la función sea puramente virtual, pero eso cambia la semántica. No evita los problemas al anular, sino que fuerza anulando en todos los casos. Evitaría este enfoque, y si debe seguirlo y hay una implementación sensata para el tipo base, haga que la función virtual y proporcionen una definición para que la implementación de las clases derivadas pueda simplemente llamar a las funciones el tipo base (es decir, fuerza la implementación, pero en los casos más simples solo reenviará la llamada al padre)

Answer 3

Esta pregunta se hace en 2013. Es bastante antigua, pero encontré algo nuevo que no existe en las respuestas.

Tenemos que entender tres concepto es sobrecarga, sobrescribir, y ocultar.

Respuesta breve, desea sobrecargar la función de herencia de la clase base. Sin embargo, la sobrecarga es el mecanismo para agregar un comportamiento múltiple para la función que necesita todas estas funciones en la misma escala. Pero la función virtual está obviamente en la clase Base.

class A { 
public: 
    virtual void print() { 
    cout << id_ << std::endl; 
    } 
private: 
    string id_ = "A"; 
}; 

class B : A { 
public: 
    using A::print; 
    void print(string id) { 
    std::cout << id << std::endl; 
    } 
}; 

int main(int argc, char const *argv[]) { 
    /* code */ 
    A a; 
    a.print(); 
    B b; 
    b.print(); 
    b.print("B"); 
    return 0; 
} 

Añadir usando A :: impresión; en su clase de derivación hará el trabajo!

Aunque no me siento que es una buena idea ya que la filosofía detrás de la sobrecarga y herencia es diferente, puede que no es una buena idea para anidar juntos.