Альтернатива C++ статические виртуальные методы

Предполагая, что C SDK позволяет вам передать ему void * в ваши данные (и вы должны передать ему свой this указатель для производный класс :)

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

Если C SDK не позволяет вам передавать указатель на ваши данные, который затем возвращается вам через обратные вызовы, тогда вам будет очень сложно это сделать. Поскольку вы указали в одном из своих комментариев, что это действительно так, вам в значительной степени не повезло. Я бы предложил использовать простые функции в качестве обратных вызовов или перегрузить конструктор и определить несколько статических методов. Вам все равно будет сложно определить, с каким именно объектом должны работать ваши методы, когда ваши обратные вызовы вызываются кодом C.

Если вы опубликуете более подробную информацию о SDK, возможно, вы сможете дать вам более подходящие предложения, но в общем случае, даже со статическими методами, вам понадобится какой-то способ получения указателя this для работы с участием.

Если C SDK хочет, чтобы вы выполняли операции без предоставления пользовательских данных, то объектная ориентация, скорее всего, не нужна, и вам следует просто написать несколько функций. В противном случае пора найти новый SDK.

Очевидный способ выглядит так: FillPointers реализованы в каждом производном классе.

class Base
{
private:
    CStruct myStruct;
};

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

Однако вы, вероятно, можете избежать этого, используя магию шаблонов ...

Вы можете просто передать функции прямо в конструктор базового класса:

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
}

Распространенный шаблон при передаче указателя функции (обратного вызова) в C SDK использует тот факт, что многие такие функции допускают параметр void *, который это «пользовательские данные». Вы можете определить свои обратные вызовы как простые глобальные функции или статические функции-члены класса. Затем каждый обратный вызов может привести параметр «пользовательские данные» к указателю базового класса, чтобы вы могли вызвать функцию-член, которая выполняет работу обратного вызова.

Виртуальные функции по сути являются внутренними указателями функций. Они просто указывают на разные функции для разных классов. Чтобы смоделировать поведение виртуальной функции, храните где-нибудь указатель на функцию, а затем, чтобы «переопределить» его, просто переназначьте его какой-либо другой функции.

В качестве альтернативы вы можете захотеть проверить это, но я думаю, что интерфейсы имеют довольно хорошую двоичную совместимость. Вы можете обойтись без демонстрации интерфейса C ++, полностью состоящего из чистых виртуальных функций, при условии, что все параметры и возвращаемые типы имеют согласованный двоичный формат (например, типы C). Это не стандарт, но может быть достаточно портативным.

Я думаю, вам просто нужно использовать обычную виртуальную функцию. Статическая виртуальная функция не имеет смысла, потому что виртуальная функция разрешается во время выполнения. Что там нужно решать, когда компилятор точно знает, что такое статическая функция?

В любом случае, я бы предложил оставить существующее решение с указателями функций на месте, если это возможно. В противном случае, рассмотрите возможность использования обычной виртуальной функции.

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
}

см. также Статические виртуальные члены C++?