Statische virtuelle C++-Mitglieder?

Ist es in C++ möglich, eine Member-Funktion zu haben, die beides ist? static und virtual? Anscheinend gibt es keinen einfachen Weg, dies zu tun (static virtual member(); ist ein Kompilierungsfehler), aber gibt es zumindest eine Möglichkeit, den gleichen Effekt zu erzielen?

IE:

struct Object
{
     struct TypeInformation;

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

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

Es ist sinnvoll zu verwenden GetTypeInformation() beide auf einer Instanz (object->GetTypeInformation()) und in einer Klasse (SomeObject::GetTypeInformation()), was für Vergleiche nützlich und für Vorlagen von entscheidender Bedeutung sein kann.

Die einzige Möglichkeit, die mir einfällt, besteht darin, zwei Funktionen / eine Funktion und eine Konstante pro Klasse zu schreiben oder Makros zu verwenden.

Irgendwelche anderen Lösungen?

Nein, es gibt keine Möglichkeit, denn was würde passieren, wenn du anrufst Object::GetTypeInformation()? Sie kann nicht wissen, welche Version der abgeleiteten Klasse aufgerufen werden soll, da ihr kein Objekt zugeordnet ist.

Sie müssen es zu einer nicht statischen virtuellen Funktion machen, damit es richtig funktioniert; Wenn Sie auch die Version einer bestimmten abgeleiteten Klasse nicht virtuell ohne eine Objektinstanz aufrufen können möchten, müssen Sie auch eine zweite redundante statische nicht virtuelle Version bereitstellen.

Viele sagen es geht nicht, ich würde noch einen Schritt weiter gehen und sagen es ist nicht sinnvoll.

Ein statisches Mitglied ist etwas, das sich nicht auf eine Instanz bezieht, sondern nur auf die Klasse.

Ein virtuelles Element bezieht sich nicht direkt auf eine Klasse, sondern nur auf eine Instanz.

Ein statisches virtuelles Mitglied wäre also etwas, das sich nicht auf eine Instanz oder Klasse bezieht.

Ich bin neulich auf dieses Problem gestoßen: Ich hatte einige Klassen voller statischer Methoden, aber ich wollte Vererbung und virtuelle Methoden verwenden und die Codewiederholung reduzieren. Meine Lösung war:

Verwenden Sie statt statischer Methoden einen Singleton mit virtuellen Methoden.

Mit anderen Worten, jede Klasse sollte eine statische Methode enthalten, die Sie aufrufen, um einen Zeiger auf eine einzelne, gemeinsam genutzte Instanz der Klasse zu erhalten. Sie können die wahren Konstruktoren privat oder geschützt machen, damit externer Code sie nicht missbrauchen kann, indem Sie zusätzliche Instanzen erstellen.

In der Praxis ist die Verwendung eines Singletons der Verwendung statischer Methoden sehr ähnlich, außer dass Sie Vererbung und virtuelle Methoden nutzen können.

Während Alsk bereits eine ziemlich detaillierte Antwort gegeben hat, möchte ich eine Alternative hinzufügen, da ich denke, dass seine erweiterte Implementierung zu kompliziert ist.

Wir beginnen mit einer abstrakten Basisklasse, die die Schnittstelle für alle Objekttypen bereitstellt:

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

Jetzt brauchen wir eine tatsächliche Implementierung. Aber um zu vermeiden, dass wir sowohl die statischen als auch die virtuellen Methoden schreiben müssen, lassen wir unsere eigentlichen Objektklassen die virtuellen Methoden erben. Dies funktioniert natürlich nur, wenn die Basisklasse weiß, wie sie auf die statische Elementfunktion zugreifen kann. Wir müssen also eine Vorlage verwenden und ihr den tatsächlichen Klassennamen des Objekts übergeben:

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

Schließlich müssen wir unsere realen Objekte implementieren. Hier müssen wir nur die statische Elementfunktion implementieren, die virtuellen Elementfunktionen werden von der ObjectImpl-Vorlagenklasse geerbt, die mit dem Namen der abgeleiteten Klasse instanziiert wird, sodass sie auf ihre statischen Elemente zugreift.

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

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

Fügen wir zum Testen Code hinzu:

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;
}

Nachtrag (12. Januar 2019):

Anstatt die Funktion GetClassNameStatic() zu verwenden, können Sie den Klassennamen auch als statisches Element definieren, sogar “inline”, was IIRC seit C++11 funktioniert (keine Angst vor all den Modifikatoren :)):

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 ist möglich!

Aber was genau möglich ist, grenzen wir ein. Die Leute wollen oft eine Art “statische virtuelle Funktion”, weil der Code dupliziert wird, um dieselbe Funktion über den statischen Aufruf “SomeDerivedClass::myfunction()” und den polymorphen Aufruf “base_class_pointer->myfunction()” aufrufen zu können. Eine “legale” Methode, um eine solche Funktionalität zuzulassen, ist die Vervielfältigung von Funktionsdefinitionen:

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(); }
};

Was ist, wenn die Basisklasse eine große Anzahl statischer Funktionen hat und die abgeleitete Klasse jede von ihnen überschreiben muss und man vergessen hat, eine duplizierende Definition für die virtuelle Funktion bereitzustellen? Richtig, wir werden währenddessen einen seltsamen Fehler bekommen Laufzeit was schwer nachzuvollziehen ist. Ursache Duplizierung von Code ist eine schlechte Sache. Das Folgende versucht, dieses Problem zu lösen (und ich möchte vorher sagen, dass es vollständig typsicher ist und keine schwarze Magie wie die von typeid oder dynamic_cast enthält 🙂

Wir wollen also nur eine Definition von getTypeInformation() pro abgeleiteter Klasse bereitstellen, und es ist offensichtlich, dass es eine Definition von sein muss statisch Funktion, da es nicht möglich ist, “SomeDerivedClass::getTypeInformation()” aufzurufen, wenn getTypeInformation() virtuell ist. Wie können wir die statische Funktion einer abgeleiteten Klasse über einen Zeiger auf die Basisklasse aufrufen? Mit vtable ist dies nicht möglich, da vtable nur Zeiger auf virtuelle Funktionen speichert und wir uns entschieden haben, keine virtuellen Funktionen zu verwenden, können wir vtable nicht zu unserem Vorteil ändern. Um dann über einen Zeiger auf die Basisklasse auf die statische Funktion für die abgeleitete Klasse zugreifen zu können, müssen wir irgendwie den Typ eines Objekts in seiner Basisklasse speichern. Ein Ansatz besteht darin, die Basisklasse mithilfe von “seltsam wiederkehrenden Vorlagenmustern” zu erstellen, aber dies ist hier nicht angemessen, und wir verwenden eine Technik namens “Typlöschung”:

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

Jetzt können wir den Typ eines Objekts in der Basisklasse “Object” mit einer Variablen “Keeper” speichern:

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

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

};

In einer abgeleiteten Klasse muss Keeper während der Konstruktion initialisiert werden:

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"; }
};

Lassen Sie uns syntaktischen Zucker hinzufügen:

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

Jetzt sehen die Erklärungen der Nachkommen so aus:

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"; }
};

Verwendungszweck:

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()

Vorteile:

1. weniger Duplizierung von Code (aber wir müssen OVERRIDE_STATIC_FUNCTIONS in jedem Konstruktor aufrufen)

Nachteile:

1. OVERRIDE_STATIC_FUNCTIONS in jedem Konstruktor
2. Speicher- und Performance-Overhead
3. erhöhte Komplexität

Offene Punkte:

1) Es gibt unterschiedliche Namen für statische und virtuelle Funktionen, wie kann man hier Mehrdeutigkeiten lösen?

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) Wie kann man OVERRIDE_STATIC_FUNCTIONS implizit in jedem Konstruktor aufrufen?

Es ist möglich. Machen Sie zwei Funktionen: statisch und virtuell

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
};

Nein, das ist nicht möglich, da statischen Elementfunktionen a fehlt this Zeiger. Und statische Mitglieder (sowohl Funktionen als auch Variablen) sind per se nicht wirklich Klassenmitglieder. Sie werden einfach von aufgerufen ClassName::member, und halten Sie sich an die Klassenzugriffsbezeichner. Ihre Speicherung wird irgendwo außerhalb der Klasse definiert; Der Speicher wird nicht jedes Mal erstellt, wenn Sie ein Objekt der Klasse instanziieren. Zeiger auf Klassenmitglieder sind speziell in Semantik und Syntax. Ein Zeiger auf ein statisches Element ist in jeder Hinsicht ein normaler Zeiger.

virtuelle Funktionen in einer Klasse benötigt die this Zeiger und ist stark an die Klasse gekoppelt, daher können sie nicht statisch sein.