Alternatywa dla statycznych metod wirtualnych c++

Myślę, że wystarczy użyć zwykłej funkcji wirtualnej. Statyczna funkcja wirtualna nie ma sensu, ponieważ funkcja wirtualna jest rozwiązywana w czasie wykonywania. Co jest do rozwiązania, gdy kompilator wie dokładnie, czym jest funkcja statyczna?

W każdym razie sugerowałbym pozostawienie istniejącego rozwiązania wskaźnika funkcji na miejscu, jeśli to możliwe. Pomijając to, rozważ użycie normalnej funkcji wirtualnej.

Nadal widzę zastosowanie statycznych metod wirtualnych, oto przykład:

class File
{
    static virtual std::string extension()  {return "";}
}

class ExecutableFile : public File
{
    // static because every executable has same extension
    static virtual std::string extension()  {return ".exe";}
}


std::string extension = "";

// needing static
extension = ExecutableFile::extension();

// not needing static nor virtual
ExecutableFile exeFile;
extension = exeFile.extension();

// needing virtual
File* pFile = &exeFile;
extension = pFile->extension();

Wspólny wzorzec podczas przekazywania wskaźnika funkcji (wywołania zwrotnego) do zestawu SDK C wykorzystuje fakt, że wiele takich funkcji pozwala na parametr void*, który jest "danymi użytkownika". Możesz zdefiniować swoje wywołania zwrotne jako proste funkcje globalne lub statyczne funkcje członka klasy. Następnie każde wywołanie zwrotne może rzucić parametr "dane użytkownika" do wskaźnika klasy bazowej, dzięki czemu można wywołać funkcję członka, która wykonuje pracę wywołania zwrotnego.

Możesz po prostu przekazać funkcje bezpośrednio do konstruktora klasy bazowej:

class Base
{
    Base()(int (*myFunA)(...), int (*myFunB)(...)) 
    { myStruct.funA = funA; myStruct.funB = myFunB; ...}
private:
    CStruct myStruct;
};

class Derived1 : public Base
{
    Derived1() : Base (myFunA, myFunB) {}
    static myFunA(...) {...};
    static myFunB(...) {...};
};

class Derived2 : public Base
{
    Derived2() : Base (myFunA, myFunB) {}
    static myFunA(...) {...};
    static myFunB(...) {...};
};

int main()
{
    Derived1 d1;
    Derived2 d2;
    // Now I have two objects with different functionality
}

Jeśli można określić Pochodny typ obiektu w czasie kompilacji, można użyć "Curiously Recurring Template Pattern" do osiągnięcia statycznego polimorfizmu. Dzięki temu podejściu nie ograniczasz się tylko do nadpisywania wirtualnych niestatycznych funkcji Członkowskich. Członkowie statyczni i niefunkcyjni są uczciwi. Można nawet nadpisać typy (ale podstawowy rozmiar obiektu nie może być funkcją tych typów).

#include <iostream>
#include <stdint.h>

struct VirtualBase {
    static const char* staticConst;
    static char* staticVar;
    static char* staticFun() { return "original static function"; }
    const char* objectConst;
    char* objectVar;
    virtual char* objectFun() { return "original object function"; }
    typedef int8_t Number;
    VirtualBase():
        objectConst("original object const"),
        objectVar("original object var")
    {}
    void virtual_dump(std::ostream& out=std::cout) {
        out << this->staticConst << std::endl;
        out << this->staticVar << std::endl;
        out << this->staticFun() << std::endl;
        out << this->objectConst << std::endl;
        out << this->objectVar << std::endl;
        out << this->objectFun() << std::endl;
        out << "sizeof(Number): " << sizeof(Number) << std::endl;
    }
};
const char* VirtualBase::staticConst = "original static const";
char* VirtualBase::staticVar = "original static var";

template <typename Derived>
struct RecurringBase: public VirtualBase {
    void recurring_dump(std::ostream& out=std::cout) {
        out << Derived::staticConst << std::endl;
        out << Derived::staticVar << std::endl;
        out << Derived::staticFun() << std::endl;
        out << static_cast<Derived*>(this)->staticConst << std::endl;
        out << static_cast<Derived*>(this)->staticVar << std::endl;
        out << static_cast<Derived*>(this)->staticFun() << std::endl;
        out << static_cast<Derived*>(this)->objectConst << std::endl;
        out << static_cast<Derived*>(this)->objectVar << std::endl;
        out << static_cast<Derived*>(this)->objectFun() << std::endl;
        out << "sizeof(Number): " << sizeof(typename Derived::Number) << std::endl;
    }
};

struct Defaults : public RecurringBase<Defaults> {
};

struct Overridden : public RecurringBase<Overridden> {
    static const char* staticConst;
    static char* staticVar;
    static char* staticFun() { return "overridden static function"; }
    const char* objectConst;
    char* objectVar;
    char* objectFun() { return "overridden object function"; }
    typedef int64_t Number;
    Overridden():
        objectConst("overridden object const"),
        objectVar("overridden object var")
    {}
};
const char* Overridden::staticConst = "overridden static const";
char* Overridden::staticVar = "overridden static var";

int main()
{
    Defaults defaults;
    Overridden overridden;
    defaults.virtual_dump(std::cout << "defaults.virtual_dump:\n");
    overridden.virtual_dump(std::cout << "overridden.virtual_dump:\n");
    defaults.recurring_dump(std::cout << "defaults.recurring_dump:\n");
    overridden.recurring_dump(std::cout << "overridden.recurring_dump:\n");
}

Oto Wyjście:

defaults.virtual_dump:
original static const
original static var
original static function
original object const
original object var
original object function
sizeof(Number): 1
overridden.virtual_dump:
original static const
original static var
original static function
original object const
original object var
overridden object function
sizeof(Number): 1
defaults.recurring_dump:
original static const
original static var
original static function
original static const
original static var
original static function
original object const
original object var
original object function
sizeof(Number): 1
overridden.recurring_dump:
overridden static const
overridden static var
overridden static function
overridden static const
overridden static var
overridden static function
overridden object const
overridden object var
overridden object function
sizeof(Number): 8

Jeśli nie można określić typu pochodnego do czasu uruchomienia, wystarczy użyć wirtualnej niestatycznej funkcji członka, aby zebrać statyczne lub niefunkcyjne informacje o klasie lub obiekcie.

Te rzeczy z pewnością by się przydały-mianowicie zmuszenie wszystkich obiektów w hierarchii klas do ujawnienia metody fabrycznej zamiast zwykłego konstruktora. Fabryki są bardzo przydatne, aby zapewnić, że nigdy nie budujesz nieprawidłowych obiektów, gwarancja projektu, której nie możesz wymusić prawie tak dobrze ze zwykłymi konstruktorami.

Aby zbudować "wirtualną statykę", należy ręcznie zbudować własny "statyczny stół v" we wszystkich obiektach, które tego potrzebują. Zwykłe funkcje Wirtualnego członka działają, ponieważ kompilator buduje tajną tabelę wskaźników funkcji zwanych VTABLE do wszystkich instancji klasy. Gdy budujesz obiekt "T", Wskaźniki funkcji w tej tabeli są przypisywane do adresów pierwszego przodka dostarczającego ten interfejs API. Nadpisanie funkcji staje się po prostu zastąpieniem oryginalnego wskaźnika w obiekcie otrzymanym z " new " nowym dostarczonym w klasie pochodnej. Oczywiście kompilator i runtime obsługują to wszystko za nas.

template<typename T>
class VirtualStaticVtable {
private:
   typedef T (*StaticFactory)(KnownInputParameters params);

   StaticFactory factoryAPI;  // The 1 and only entry in my static v-table

protected:
   VirtualStaticVtable(StaticFactory factoryApi) : factoryAPI(factoryApi) {}
   virtual ~VirtualStaticVtable() {}
};

Teraz każdy obiekt, który powinna wspierać statyczne metody fabryczne mogą być wyprowadzone z tej klasy. Po cichu przechodzą we własnej fabryce do konstruktora, a to dodaje tylko 1 Wskaźnik do rozmiarów wynikowych obiektów (tak jak zwykły wpis VTable).

Zakładając, że C SDK pozwala Ci przekazać void * do Twoich danych (i powinieneś przekazać go to wskaźnik dla klasy pochodnej:)

class Base {

  public:

    void Initialize() { /* Pass /this/ and a pointer to myFuncAGate to your C SDK */ }

    virtual myFuncA()=0;

    // This is the method you pass to the C SDK:
    static myFuncAGate(void *user_data) {
        ((Base*)user_data)->myFuncA();
    }
};


class Derived1: public Base {
  public:
    virtual myFuncA() { ... } // This gets called by myFuncAGate()
};

Jeśli C SDK nie pozwala na przekazanie wskaźnika do danych, które są następnie przekazywane z powrotem do ciebie przez wywołania zwrotne, wtedy będziesz miał naprawdę trudny czas, aby to zrobić. Ponieważ w jednym ze swoich komentarzy wskazałeś, że tak rzeczywiście jest, masz raczej pecha. Sugerowałbym używanie prostych funkcji jako wywołań zwrotnych lub przeciążenie konstruktora i zdefiniowanie wielu metod statycznych. Nadal będziesz miał trudności z określeniem, jaki jest właściwy obiekt, z którym powinny pracować Twoje metody, gdy wywołania zwrotne są wywoływane przez kod C.

Jeśli opublikujesz więcej szczegółów na temat SDK, możesz dać ci bardziej odpowiednie sugestie, ale w ogólnym przypadku, nawet w przypadku metod statycznych, potrzebujesz jakiegoś sposobu uzyskania tego wskaźnika do pracy.

Funkcje wirtualne są zasadniczo wskaźnikami funkcji pod maską. Po prostu wskazują na różne funkcje dla różnych klas. Aby symulować zachowanie funkcji wirtualnej, należy mieć gdzieś przechowywany wskaźnik funkcji, a następnie "nadpisać" , po prostu przypisać go do innej funkcji.

Alternatywnie, możesz chcieć to przetestować, ale myślę, że interfejsy mają całkiem dobrą kompatybilność binarną. Może ujdzie ci to na sucho odsłaniając interfejs C++ składający się w całości z czystych funkcji wirtualnych, tak długo, jak wszystkie parametry i typy zwrotów mają spójny format binarny (np. Typu C). Nie jest standardem, ale może być wystarczająco przenośny.

Oczywisty sposób jest taki, z FillPointers zaimplementowanym w każdej klasie pochodnej.

class Base
{
private:
    CStruct myStruct;
};

class Derived1 : public Base
{
 private:
    static FillPointers() { myStruct.funA = myFunA; myStruct.funB = myFunB; ...}
    Derived1() {  FillPointers();  }
    static myFunA(...) {...};
    static myFunB(...) {...};
};

Jednak prawdopodobnie można tego uniknąć używając magii szablonów...

Jeśli C SDK chce, abyś wykonywał operacje bez podawania danych użytkownika, orientacja obiektu jest prawdopodobnie niepotrzebna i powinieneś po prostu napisać kilka funkcji. W przeciwnym razie, czas znaleźć nowe SDK.

class Base
{
    template<class T>
    FillPointers(T* dummy) { myStruct.funA = T::myFunA; myStruct.funB = T::myFunB; ...}
private:
    CStruct myStruct;
};

class Derived1 : public Base
{
    Derived1() {  FillPointers(this);  }
    static myFunA(...) {...};
    static myFunB(...) {...};
};

class Derived2 : public Base
{
    Derived2() {  FillPointers(this);  }
    static myFunA(...) {...};
    static myFunB(...) {...};
};

int main()
{
    Derived1 d1;
    Derived2 d2;
    // Now I have two objects with different functionality
}

Zobacz także C++ statyczne członkowie wirtualni?