Cómo definir las funciones miembro 'final' para una clase

Question

¿Es posible hacer que mis funciones miembro final estén en Java, para que las clases derivadas no puedan anularlas?

Answer 1

Es muy posible que sea, de hecho, el comportamiento predeterminado. Es decir. si no declara los métodos de instancia de clase explícitamente como virtual, no pueden ser overridden en subclases (solo hidden, que es un caso diferente, y casi siempre erróneo).

Eficaz C++ tercera edición, el artículo 36 se ocupa de esto en detalle. Considere

class B { 
public: 
    virtual void vf(); 
    void mf(); 
    virtual void mf(int); 
    ... 
}; 

class D: public B { 
public: 
    virtual void vf();    // overrides B::vf 
    void mf();      // hides B::mf; see Item33 
    ... 
}; 

D x;        // x is an object of type D 
B *pB = &x;      // get pointer to x 
D *pD = &x;      // get pointer to x 

pD->vf();       // calls D::mf, as expected 
pB->vf();       // calls D::mf, as expected 
pD->mf();       // calls D::mf, as expected 
pB->mf();       // calls B::mf - surprise! 
pD->mf(1);      // error - D::mf() hides B::mf(int)! 
pB->mf(1);      // calls B::mf(int) 

Así que esto no es exactamente cómo se comporta final en Java, pero sólo se puede obtener esta estrecha con C++. Una alternativa podría ser evitar la subclasificación por completo. La solución técnica - de trabajo, pero no agradable - es declarar todos sus constructores private (y proporcionar un método de fábrica estático si desea permitir la creación de instancias de su clase, por supuesto).

Answer 2

Comprobar this de Bjarne (¿Puedo detener personas que deriva de mi clase?)

Answer 3

En realidad es posible si está utilizando MSVC. Hay una palabra clave sealed. Aquí hay un example from msdn.

Answer 4

C++ 11 añade una palabra clave contextual final para apoyar esta:

class B 
{ 
    public: 
    virtual void foo() final; 
}; 
class D : B 
{ 
    public: 
    virtual void foo(); // error: declaration of 'foo' overrides a 'final' function 
}; 

final se admite en GCC 4.7 y 3.0 Clang. Y como señala Sergio en su respuesta, MSVC++ lo admite (con la ortografía sealed), desde MSVC++ 2005. Entonces, si encapsula en una minimacro macro y lo configura dependiendo de su compilador, puede estar en camino con esto. Solo asegúrese de que en realidad es usando tal compilador al menos cada cierto tiempo, por lo que detectará cualquier error con anticipación.

Answer 5

¡El nuevo estándar C++ 11 ahora admite anulaciones explícitas y final de las funciones de miembro!