Доступ к данным из обратного вызова

Question

У меня есть некоторый код и данные, оба в настоящее время инкапсулированы в структуру, которая, в свою очередь, находится в пространстве имен. Я пытаюсь интегрировать внешнюю библиотеку, которая использует старомодные обратные вызовы. Мне нужен доступ к моим данным в контексте обратного вызова, но API обратного вызова не предоставляет средств для добавления персонализированных параметров.

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

Итак, я спорю о том, следует ли полностью отказаться от структуры и преобразовать ее в автономный код и данные. По сути, данные станут глобальными (или, скорее всего, обернутыми в глобальную структуру), но будут находиться в пределах своего пространства имен.

Обоснование для того, чтобы сделать данные "глобальными":

• Код имеет единственную цель в программе и всегда использует один и тот же набор данных для жизни программы. Данные никогда не выделяются и не освобождаются.
• Этот код и данные никогда не создаются. Никогда не бывает и никогда не будет нескольких копий.
• Я не люблю ООП (я использую C ++, потому что это лучший инструмент для работы), поэтому я не чувствую необходимости держать его в инкапсуляции по принципу в одиночку.

Однако есть один недостаток, которого я бы хотел избежать:

• Несмотря на то, что данные находятся в отдельном пространстве имен (и игнорируя тот факт, что я единственный, кто пишет эту программу), ничто не мешает другим частям программы получить доступ к этим данным. И если это произойдет, у меня не будет простого способа отследить это.

Единственная идея, которая у меня была до сих пор, - заключить глобальные данные в безымянное пространство имен. Это должно, во всех смыслах и целях, сделать его невидимым для остальной части кода и устранить наиболее распространенную причину неиспользования глобальных переменных. Однако это также означает, что код, который требует для доступа к нему, должен содержаться в одном файле, что может затруднить работу, если этот файл станет большим.

Есть ли другой вариант, о котором я не думаю, или это так хорошо, как есть?

Answer 1

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

#include <iostream>
using namespace std;

template <class Data, int ID>
struct ext_library_context
{
    static Data data;
    static void callback()
    {
        // callback code, using data
        cout << data << endl;
    }
};

template <class Data, int ID>
Data ext_library_context<Data, ID>::data;

void ext_library_call(void callback())
{
    callback();
}

int main()
{
    int d1 = 1;
    ext_library_context<int, 1>::data = d1;

    int d2 = 2;
    ext_library_context<int, 2>::data = d2;

    ext_library_call(ext_library_context<int, 1>::callback);
    ext_library_call(ext_library_context<int, 2>::callback);
}

Пока вы используете уникальную комбинацию параметров шаблона данных / идентификатора шаблонадля каждого звонка у вас не должно быть проблем.

Answer 2

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

Answer 3

Поместите ваши данные в класс и создайте экземпляр этого класса static -ally:

class MyClass {
  private:
    Data data;  // variables which you avoid declaring globally
  public:
    void real_callback() {
       do_something(data);
    }
};

void callback() {
    static MyClass my_class;  // here is the trick. 
    my_class.real_callback();
    // Or you can instantiate it on heap
    // static auto my_class = new MyClass;
    // my_class->real_callback();
}

int main() {
    old_function_wanting_a_callback(callback);
}