C ++ miembros virtuales estáticos?

¿Es posible en C ++ tener una función miembro que sea ambas staticy virtual? Aparentemente, no hay una forma directa de hacerlo ( static virtual member();es un error de compilación), pero ¿hay al menos una forma de lograr el mismo efecto?

ES DECIR:

struct Object
{
     struct TypeInformation;

     static virtual const TypeInformation &GetTypeInformation() const;
};

struct SomeObject : public Object
{
     static virtual const TypeInformation &GetTypeInformation() const;
};

Tiene sentido usar GetTypeInformation()tanto en una instancia ( object->GetTypeInformation()) como en una clase ( SomeObject::GetTypeInformation()), lo que puede ser útil para las comparaciones y vital para las plantillas.

Las únicas formas en que puedo pensar implica escribir dos funciones / una función y una constante, por clase, o usar macros.

¿Alguna otra solución?

No, no hay forma de hacerlo, ya que ¿qué pasaría cuando llamaras Object::GetTypeInformation()? No puede saber a qué versión de clase derivada llamar ya que no hay ningún objeto asociado con ella.

Tendrá que convertirlo en una función virtual no estática para que funcione correctamente; si también desea poder llamar a una versión de clase derivada específica de manera no virtual sin una instancia de objeto, también deberá proporcionar una segunda versión estática redundante no virtual.

Muchos dicen que no es posible, iría un paso más allá y diría que no tiene sentido.

Un miembro estático es algo que no se relaciona con ninguna instancia, solo con la clase.

Un miembro virtual es algo que no se relaciona directamente con ninguna clase, solo con una instancia.

Entonces, un miembro virtual estático sería algo que no se relaciona con ninguna instancia o clase.

Me encontré con este problema el otro día: tenía algunas clases llenas de métodos estáticos, pero quería usar la herencia y métodos virtuales y reducir la repetición de código. Mi solución fue:

En lugar de usar métodos estáticos, use un singleton con métodos virtuales.

En otras palabras, cada clase debe contener un método estático al que llame para obtener un puntero a una única instancia compartida de la clase. Puede hacer que los verdaderos constructores sean privados o protegidos para que el código externo no pueda usarlo incorrectamente creando instancias adicionales.

En la práctica, usar un singleton es muy parecido a usar métodos estáticos, excepto que puede aprovechar la herencia y los métodos virtuales.

¡Es posible!

Pero qué es exactamente posible, reduzcamos. La gente a menudo quiere algún tipo de "función virtual estática" debido a la duplicación del código necesario para poder llamar a la misma función a través de la llamada estática "SomeDerivedClass :: myfunction ()" y la llamada polimórfica "base_class_pointer-> myfunction ()". El método "legal" para permitir dicha funcionalidad es la duplicación de definiciones de funciones:

class Object
{
public:
    static string getTypeInformationStatic() { return "base class";}
    virtual string getTypeInformation() { return getTypeInformationStatic(); }
}; 
class Foo: public Object
{
public:
    static string getTypeInformationStatic() { return "derived class";}
    virtual string getTypeInformation() { return getTypeInformationStatic(); }
};

¿Qué pasa si la clase base tiene una gran cantidad de funciones estáticas y la clase derivada tiene que anular cada una de ellas y se olvidó de proporcionar una definición duplicada para la función virtual? Bien, obtendremos un extraño error durante el tiempo de ejecución que es difícil de rastrear. Porque la duplicación de código es algo malo. Lo siguiente intenta resolver este problema (y quiero decir de antemano que es completamente seguro y no contiene magia negra como typeid's o dynamic_cast's :)

Por lo tanto, queremos proporcionar solo una definición de getTypeInformation () por clase derivada y es obvio que debe ser una definición de estáticafuncionan porque no es posible llamar a "SomeDerivedClass :: getTypeInformation ()" si getTypeInformation () es virtual. ¿Cómo podemos llamar a la función estática de la clase derivada a través del puntero a la clase base? No es posible con vtable porque vtable almacena punteros solo para funciones virtuales y dado que decidimos no usar funciones virtuales, no podemos modificar vtable para nuestro beneficio. Luego, para poder acceder a la función estática de la clase derivada a través del puntero a la clase base, tenemos que almacenar de alguna manera el tipo de un objeto dentro de su clase base. Un enfoque es hacer que la clase base sea estandarizada usando un "patrón de plantilla curiosamente recurrente", pero no es apropiado aquí y usaremos una técnica llamada "borrado de tipo":

class TypeKeeper
{
public:
    virtual string getTypeInformation() = 0;
};
template<class T>
class TypeKeeperImpl: public TypeKeeper
{
public:
    virtual string getTypeInformation() { return T::getTypeInformationStatic(); }
};

Ahora podemos almacenar el tipo de un objeto dentro de la clase base "Object" con una variable "keeper":

class Object
{
public:
    Object(){}
    boost::scoped_ptr<TypeKeeper> keeper;

    //not virtual
    string getTypeInformation() const 
    { return keeper? keeper->getTypeInformation(): string("base class"); }

};

En una clase derivada, el guardián debe inicializarse durante la construcción:

class Foo: public Object
{
public:
    Foo() { keeper.reset(new TypeKeeperImpl<Foo>()); }
    //note the name of the function
    static string getTypeInformationStatic() 
    { return "class for proving static virtual functions concept"; }
};

Agreguemos azúcar sintáctico:

template<class T>
void override_static_functions(T* t)
{ t->keeper.reset(new TypeKeeperImpl<T>()); }
#define OVERRIDE_STATIC_FUNCTIONS override_static_functions(this)

Ahora las declaraciones de descendientes se ven así:

class Foo: public Object
{
public:
    Foo() { OVERRIDE_STATIC_FUNCTIONS; }
    static string getTypeInformationStatic() 
    { return "class for proving static virtual functions concept"; }
};

class Bar: public Foo
{
public:
    Bar() { OVERRIDE_STATIC_FUNCTIONS; }
    static string getTypeInformationStatic() 
    { return "another class for the same reason"; }
};

uso:

Object* obj = new Foo();
cout << obj->getTypeInformation() << endl;  //calls Foo::getTypeInformationStatic()
obj = new Bar();
cout << obj->getTypeInformation() << endl;  //calls Bar::getTypeInformationStatic()
Foo* foo = new Bar();
cout << foo->getTypeInformation() << endl; //calls Bar::getTypeInformationStatic()
Foo::getTypeInformation(); //compile-time error
Foo::getTypeInformationStatic(); //calls Foo::getTypeInformationStatic()
Bar::getTypeInformationStatic(); //calls Bar::getTypeInformationStatic()

Ventajas:

1. menos duplicación de código (pero tenemos que llamar a OVERRIDE_STATIC_FUNCTIONS en cada constructor)

Desventajas

1. OVERRIDE_STATIC_FUNCTIONS en cada constructor
2. sobrecarga de memoria y rendimiento
3. mayor complejidad

Problemas abiertos:

1) hay diferentes nombres para funciones estáticas y virtuales ¿cómo resolver la ambigüedad aquí?

class Foo
{
public:
    static void f(bool f=true) { cout << "static";}
    virtual void f() { cout << "virtual";}
};
//somewhere
Foo::f(); //calls static f(), no ambiguity
ptr_to_foo->f(); //ambiguity

2) ¿cómo llamar implícitamente OVERRIDE_STATIC_FUNCTIONS dentro de cada constructor?

Si bien Alsk ya ha dado una respuesta bastante detallada, me gustaría agregar una alternativa, ya que creo que su implementación mejorada es demasiado complicada.

Comenzamos con una clase base abstracta, que proporciona la interfaz para todos los tipos de objetos:

class Object
{
public:
    virtual char* GetClassName() = 0;
};

Ahora necesitamos una implementación real. Pero para evitar tener que escribir tanto los métodos estáticos como los virtuales, nuestras clases de objetos reales heredarán los métodos virtuales. Obviamente, esto solo funciona si la clase base sabe cómo acceder a la función miembro estática. Entonces necesitamos usar una plantilla y pasarle el nombre de la clase de objetos reales:

template<class ObjectType>
class ObjectImpl : public Object
{
public:
    virtual char* GetClassName()
    {
        return ObjectType::GetClassNameStatic();
    }
};

Finalmente, necesitamos implementar nuestros objetos reales. Aquí solo necesitamos implementar la función miembro estática, las funciones miembro virtuales serán heredadas de la clase de plantilla ObjectImpl, instanciadas con el nombre de la clase derivada, para que acceda a sus miembros estáticos.

class MyObject : public ObjectImpl<MyObject>
{
public:
    static char* GetClassNameStatic()
    {
        return "MyObject";
    }
};

class YourObject : public ObjectImpl<YourObject>
{
public:
    static char* GetClassNameStatic()
    {
        return "YourObject";
    }
};

Agreguemos un código para probar:

char* GetObjectClassName(Object* object)
{
    return object->GetClassName();
}

int main()
{
    MyObject myObject;
    YourObject yourObject;

    printf("%s\n", MyObject::GetClassNameStatic());
    printf("%s\n", myObject.GetClassName());
    printf("%s\n", GetObjectClassName(&myObject));
    printf("%s\n", YourObject::GetClassNameStatic());
    printf("%s\n", yourObject.GetClassName());
    printf("%s\n", GetObjectClassName(&yourObject));

    return 0;
}

Anexo (12 de enero de 2019):

En lugar de utilizar la función GetClassNameStatic (), también puede definir el nombre de la clase como un miembro estático, incluso "en línea", que IIRC funciona desde C ++ 11 (no se asuste por todos los modificadores :)):

class MyObject : public ObjectImpl<MyObject>
{
public:
    // Access this from the template class as `ObjectType::s_ClassName` 
    static inline const char* const s_ClassName = "MyObject";

    // ...
};

Es posible. Realiza dos funciones: estática y virtual

struct Object{     
  struct TypeInformation;
  static  const TypeInformation &GetTypeInformationStatic() const 
  { 
      return GetTypeInformationMain1();
  }
  virtual const TypeInformation &GetTypeInformation() const
  { 
      return GetTypeInformationMain1();
  }
protected:
  static const TypeInformation &GetTypeInformationMain1(); // Main function
};

struct SomeObject : public Object {     
  static  const TypeInformation &GetTypeInformationStatic() const 
  { 
      return GetTypeInformationMain2();
  }
  virtual const TypeInformation &GetTypeInformation() const
  { 
      return GetTypeInformationMain2();
  }
protected:
  static const TypeInformation &GetTypeInformationMain2(); // Main function
};

No, esto no es posible, porque las funciones miembro estáticas carecen de un thispuntero. Y los miembros estáticos (tanto funciones como variables) no son realmente miembros de clase per-se. Simplemente son invocados por ClassName::membery se adhieren a los especificadores de acceso de clase. Su almacenamiento se define en algún lugar fuera de la clase; el almacenamiento no se crea cada vez que crea una instancia de un objeto de la clase. Los punteros a los miembros de la clase son especiales en semántica y sintaxis. Un puntero a un miembro estático es un puntero normal en todos los aspectos.

Las funciones virtuales en una clase necesitan el thispuntero y están muy acopladas a la clase, por lo tanto, no pueden ser estáticas.

Bueno, una respuesta bastante tardía, pero es posible usando el patrón de plantilla curiosamente recurrente. Este artículo de Wikipedia tiene la información que necesita y también el ejemplo bajo polimorfismo estático es lo que se le solicita.

Creo que lo que intentas hacer se puede hacer a través de plantillas. Estoy tratando de leer entre líneas aquí. Lo que está tratando de hacer es llamar a un método desde algún código, donde llama a una versión derivada pero la persona que llama no especifica qué clase. Ejemplo:

class Foo {
public:
    void M() {...}
};

class Bar : public Foo {
public:
    void M() {...}
};

void Try()
{
    xxx::M();
}

int main()
{
    Try();
}

Desea que Try () llame a la versión Bar de M sin especificar Bar. La forma de hacerlo para las estadísticas es usar una plantilla. Así que cámbialo así:

class Foo {
public:
    void M() {...}
};

class Bar : public Foo {
public:
    void M() {...}
};

template <class T>
void Try()
{
    T::M();
}

int main()
{
    Try<Bar>();
}

No, la función miembro estática no puede ser virtual, ya que el concepto virtual se resuelve en tiempo de ejecución con la ayuda de vptr, y vptr es miembro no estático de una clase. No seas virtual.

No es posible, pero eso es solo por una omisión. No es algo que "no tenga sentido" como mucha gente parece reclamar. Para ser claros, estoy hablando de algo como esto:

struct Base {
  static virtual void sayMyName() {
    cout << "Base\n";
  }
};

struct Derived : public Base {
  static void sayMyName() override {
    cout << "Derived\n";
  }
};

void foo(Base *b) {
  b->sayMyName();
  Derived::sayMyName(); // Also would work.
}

Esto es 100% algo que podría implementarse (simplemente no lo ha hecho), y diría que es algo útil.

Considere cómo funcionan las funciones virtuales normales. Elimine el staticsy agregue algunas otras cosas y tenemos:

struct Base {
  virtual void sayMyName() {
    cout << "Base\n";
  }
  virtual void foo() {
  }
  int somedata;
};

struct Derived : public Base {
  void sayMyName() override {
    cout << "Derived\n";
  }
};

void foo(Base *b) {
  b->sayMyName();
}

Esto funciona bien y, básicamente, lo que sucede es que el compilador crea dos tablas, llamadas VTables, y asigna índices a las funciones virtuales como esta

enum Base_Virtual_Functions {
  sayMyName = 0;
  foo = 1;
};

using VTable = void*[];

const VTable Base_VTable = {
  &Base::sayMyName,
  &Base::foo
};

const VTable Derived_VTable = {
  &Derived::sayMyName,
  &Base::foo
};

A continuación, cada clase con funciones virtuales se aumenta con otro campo que apunta a su VTable, por lo que el compilador básicamente las cambia para que sean así:

struct Base {
  VTable* vtable;
  virtual void sayMyName() {
    cout << "Base\n";
  }
  virtual void foo() {
  }
  int somedata;
};

struct Derived : public Base {
  VTable* vtable;
  void sayMyName() override {
    cout << "Derived\n";
  }
};

Entonces, ¿qué sucede realmente cuando llamas b->sayMyName()? Básicamente esto:

b->vtable[Base_Virtual_Functions::sayMyName](b);

(El primer parámetro se convierte this).

Bien, ¿cómo funcionaría con funciones virtuales estáticas? ¿Cuál es la diferencia entre las funciones miembro estáticas y no estáticas? La única diferencia es que este último obtiene un thispuntero.

Podemos hacer exactamente lo mismo con funciones virtuales estáticas: simplemente quite el thispuntero.

b->vtable[Base_Virtual_Functions::sayMyName]();

Esto podría admitir ambas sintaxis:

b->sayMyName(); // Prints "Base" or "Derived"...
Base::sayMyName(); // Always prints "Base".

Así que ignora a todos los detractores. Se hace tiene sentido. ¿Por qué no es compatible entonces? Creo que es porque tiene muy pocos beneficios e incluso podría ser un poco confuso.

La única ventaja técnica sobre una función virtual normal es que no necesita pasar thisa la función, pero no creo que eso suponga una diferencia apreciable en el rendimiento.

Significa que no tiene una función estática y no estática separada para los casos en que tiene una instancia y cuando no tiene una instancia, pero también puede ser confuso que solo sea realmente "virtual" cuando usa la llamada de instancia

No, no es posible, ya que los miembros estáticos están vinculados en tiempo de compilación, mientras que los miembros virtuales están vinculados en tiempo de ejecución.

Primero, las respuestas son correctas de que lo que solicita el OP es una contradicción de términos: los métodos virtuales dependen del tipo de tiempo de ejecución de una instancia; Las funciones estáticas específicamente no dependen de una instancia, solo de un tipo. Dicho esto, tiene sentido que las funciones estáticas devuelvan algo específico a un tipo. Por ejemplo, tenía una familia de clases MouseTool para el patrón State y comencé a hacer que cada una tuviera una función estática que devolvía el modificador de teclado que lo acompañaba; Usé esas funciones estáticas en la función de fábrica que hicieron la instancia correcta de MouseTool. Esa función verificó el estado del mouse contra MouseToolA :: keyboardModifier (), MouseToolB :: keyboardModifier (), etc. y luego instancia el apropiado. Por supuesto, más tarde quería comprobar si el estado era correcto, así que quería escribir algo como "

Entonces, si te encuentras con ganas de esto, es posible que desees volver a buscar tu solución. Aún así, entiendo el deseo de tener métodos estáticos y luego llamarlos dinámicamente en función del tipo dinámico de una instancia. Creo que el Patrón de visitante puede darte lo que quieres. Te da lo que quieres. Es un poco de código extra, pero podría ser útil para otros visitantes.

Ver: http://en.wikipedia.org/wiki/Visitor_pattern para antecedentes.

struct ObjectVisitor;

struct Object
{
     struct TypeInformation;

     static TypeInformation GetTypeInformation();
     virtual void accept(ObjectVisitor& v);
};

struct SomeObject : public Object
{
     static TypeInformation GetTypeInformation();
     virtual void accept(ObjectVisitor& v) const;
};

struct AnotherObject : public Object
{
     static TypeInformation GetTypeInformation();
     virtual void accept(ObjectVisitor& v) const;
};

Luego para cada objeto concreto:

void SomeObject::accept(ObjectVisitor& v) const {
    v.visit(*this); // The compiler statically picks the visit method based on *this being a const SomeObject&.
}
void AnotherObject::accept(ObjectVisitor& v) const {
    v.visit(*this); // Here *this is a const AnotherObject& at compile time.
}

y luego defina el visitante base:

struct ObjectVisitor {
    virtual ~ObjectVisitor() {}
    virtual void visit(const SomeObject& o) {} // Or = 0, depending what you feel like.
    virtual void visit(const AnotherObject& o) {} // Or = 0, depending what you feel like.
    // More virtual void visit() methods for each Object class.
};

Luego, el visitante concreto que selecciona la función estática adecuada:

struct ObjectVisitorGetTypeInfo {
    Object::TypeInformation result;
    virtual void visit(const SomeObject& o) {
        result = SomeObject::GetTypeInformation();
    }
    virtual void visit(const AnotherObject& o) {
        result = AnotherObject::GetTypeInformation();
    }
    // Again, an implementation for each concrete Object.
};

finalmente, úsalo:

void printInfo(Object& o) {
    ObjectVisitorGetTypeInfo getTypeInfo;
    Object::TypeInformation info = o.accept(getTypeInfo).result;
    std::cout << info << std::endl;
}

Notas:

• La constidad se fue como ejercicio.
• Has devuelto una referencia de una estática. A menos que tenga un singleton, eso es cuestionable.

Si desea evitar errores de copiar y pegar donde uno de sus métodos de visita llama a la función estática incorrecta, puede usar una función auxiliar con plantilla (que no puede ser virtual) a su visitante con una plantilla como esta:

struct ObjectVisitorGetTypeInfo {
    Object::TypeInformation result;
    virtual void visit(const SomeObject& o) { doVisit(o); }
    virtual void visit(const AnotherObject& o) { doVisit(o); }
    // Again, an implementation for each concrete Object.

  private:
    template <typename T>
    void doVisit(const T& o) {
        result = T::GetTypeInformation();
    }
};

Con c ++ puede usar herencia estática con el método crt. Por ejemplo, se usa ampliamente en la plantilla de ventana atl & wtl.

Ver https://en.wikipedia.org/wiki/Curiously_recurring_template_pattern

Para ser simple, tiene una clase que se crea en sí misma como class myclass: public myancestor. Desde este punto, la clase myancestor ahora puede llamar a su función T :: YourImpl estática.

Quizás puedas probar mi solución a continuación:

class Base {
public:
    Base(void);
    virtual ~Base(void);

public:
    virtual void MyVirtualFun(void) = 0;
    static void  MyStaticFun(void) { assert( mSelf != NULL); mSelf->MyVirtualFun(); }
private:
    static Base* mSelf;
};

Base::mSelf = NULL;

Base::Base(void) {
    mSelf = this;
}

Base::~Base(void) {
    // please never delete mSelf or reset the Value of mSelf in any deconstructors
}

class DerivedClass : public Base {
public:
    DerivedClass(void) : Base() {}
    ~DerivedClass(void){}

public:
    virtual void MyVirtualFun(void) { cout<<"Hello, it is DerivedClass!"<<endl; }
};

int main() {
    DerivedClass testCls;
    testCls.MyStaticFun(); //correct way to invoke this kind of static fun
    DerivedClass::MyStaticFun(); //wrong way
    return 0;
}

Como otros han dicho, hay 2 piezas importantes de información:

1. no hay thispuntero al hacer una llamada de función estática y
2. el thispuntero apunta a la estructura donde se usa la tabla virtual, o thunk, para buscar qué método de tiempo de ejecución llamar.

Una función estática se determina en tiempo de compilación.

Mostré este ejemplo de código en miembros estáticos de C ++ en clase ; muestra que puede llamar a un método estático dado un puntero nulo:

struct Foo
{
    static int boo() { return 2; }
};

int _tmain(int argc, _TCHAR* argv[])
{
    Foo* pFoo = NULL;
    int b = pFoo->boo(); // b will now have the value 2
    return 0;
}