Ich möchte eine abstrakte Basisklasse erstellen, die dann andere Klassen, die davon erben, dazu zwingen soll bestimmte Methoden zu implementieren.

Jetzt kommt's: Ich will die erbenden Klassen irgendwie dazu zwingen eine bestimmte static Methode zu implementieren. Ich weiß aber nicht wie die Syntax dafür aussieht? static und virtual beisst sich laut Compiler.

Geht das überhaupt?

Nope geht nicht, da Du beim aufrufen statischer Funktionen kein polymorphes Objekt haben musst sondern die gewünschte Klasse direkt adressieren kannst. Welchen Pfad in der Hierarchie sollte der Compiler dann verfolgen, wenn du AbstractClass::StaticMethod() aufrufst.

aber die ist ja virtual, also sowas wie

AbstractClass::VirtualStaticMethod()

Sprich die abstrakte basisklasse hat diese static methode nicht, aber die davon erbenden müssen sie implementieren

Edit: virtual und static in der Kombo bringt's echt nicht.

MfG

GPC

aber die ist ja virtual, also sowas wie

AbstractClass::VirtualStaticMethod()

Sprich die abstrakte basisklasse hat diese static methode nicht, aber die davon erbenden müssen sie implementieren

Damit widersprichst Du Dir selbst - Du addressierst direkt die Klasse AbstractClass und erwartest vom Compiler eine der Ableitungen (BTW, welche bitte?) zu suchen.

#include <iostream>

struct A {
    static void F() { std::cout << "A" << std::endl; }
};

struct B : public A {
    static void F() { std::cout << "B" << std::endl; }
};

int main() {
    A a;
    a.F();
    B b;
    b.F();
    A* p = new A;
    p->F();
    delete p;
    p = new B;
    p->F();
    delete p;
}

Würde static und virtual gehen, dann käme B beim letzten Aufruf herraus, doch überleg dir was der Kompiler machen muss: Er muss schauen welcher Typ sich hinter dem Zeiger versteckt, wenn die virtuelle Funktion aufgerufen wird, und wenn er das macht, ist der Vorteil von static schon fast weg, allerdings auch nur fast.

Also eigentlich müsste es doch möglich sein static und virtual zusammen zu benutzen, und es würde doch auch Sinn ergeben, oder? Ich meine jetzt: Sind static-Methoden nicht nen kleinen Tick schneller, da sie keinen Zeiger auf ihre Instanz erhalten? Oder ist das egal?

mfg.

Wäre o.a. möglich, würde nicht nur der Compiler mehr zu tun haben, er müsste hier (und nur hier!) auch protestieren wenn A::F() direkt angesprochen wird, denn wo sucht er jetzt die Virtualität? Implizit garnicht würde mir nicht wirklich sonderlich gut gefallen

Also eigentlich müsste es doch möglich sein static und virtual zusammen zu benutzen, und es würde doch auch Sinn ergeben, oder? Ich meine jetzt: Sind static-Methoden nicht nen kleinen Tick schneller, da sie keinen Zeiger auf ihre Instanz erhalten? Oder ist das egal?

mfg.

das geschwindigkeits-'problem' bei virtuellen funktionen besteht primär in dem indirektenaufruf, der die sprungvorhersage heutiger prozessoren verhindert (mittels profiling informationen hat der compiler hier allerdings verschiedene möglichkeiten, das zu umgehen, gleichfalls bei JIT compilern oder selbstmodifizierendem code). evtl. ist etwas pseudo-virtuelles in der art gesucht:

#include <iostream>

struct A {
    A() : f(&A::f_) {}
    void (*f)();
private:
    static void f_() { std::cout << "A" << std::endl; }
};

struct B : public A {
    B() { f = &B::f_; }
private:
    static void f_() { std::cout << "B" << std::endl; }
};

int main() {
    A a;
    a.F();
    B b;
    b.F();
    A* p = new A;
    p->f();
    delete p;
    p = new B;
    p->f();
    delete p;
}

alternativ könnte man einen container benutzen, der die zuordnung zwischen typeinfo und zeiger bewirkt und so den zusätzlichen zeiger in jeder instanz vermeiden. im prinzip aber trotzdem sinnlos, eine virtuelle const memberfunktion ist genauso nützlich.