Передача функции обратного вызова с параметром функции

Question

Я хочу вызвать следующую функцию и передать ей функцию с параметром. Целью этого является то, что он должен вызывать функцию с моим указанным параметром, чтобы я знал, что вызвало функцию (в этом случае булавку gpio на малиновой Pi).

int wiringPiISR(int pin, int edgeType, void (*function)(void)); 

В настоящее время у меня есть:

for (int i = 0; i < myValues.size(); ++i) 
{ 
    int myValue = myValues[ i ]; 
    wiringPiISR(myValue, INT_EDGE_RISING, &myCallback(myValue)); 
} 

Хотя это дает мне следующую ошибку:

error: lvalue required as unary ‘&’ operand

который я не могу понять, как к моему пониманию, MyValue является именующим или нет?

Это то, что я хочу сделать даже возможно? Если да, то как? Функция wiringPiISR из библиотеки под названием wiringPi, и я хотел бы избежать ее модификации как можно больше.

Answer 1

Вы можете комбинировать ответы от imreal и Ryan Haining примерно так.

std::function<void()> cbfunc; 

void myCallback() 
{ 
    cbfunc(); 
} 
void myWiringPiISR(int val, int mask, std::function<void()> callback) 
{ 
    cbfunc = callback; 
    wiringPiISR(val, mask, &myCallback); 
} 

... а затем использовать его ...

void myActualCallback(int v) 
{ 
    ... do something... 
} 

myWiringPiISR(myValue, INT_EDGE_RISING, std::bind(myActualCallback, myValue)); 

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

Как это работает? Просто «std :: bind» связывает функцию и ее параметры в один объект std: function, который затем может быть «вызван» из функции myCallback, которая действует как прокладка вокруг обратного вызова, который вы передаете. Я раньше задавал функцию обратного вызова, но это редактирование, надеюсь, исправлено.

Answer 2

Если у вас есть C++ 11, я предлагаю использовать std::function - это немного чище.

Если нет, ваша подпись функции неверна. Вам нужна обратная связь с типом void(int), но ваша функция принимает void()

Answer 3

Вам необходимо использовать std::function и std::bind.

Изменение подписи функции

int wiringPiISR (int pin, int edgeType, std::function<void()> func); 

Внутри вы можете вызвать функцию обратного вызова, просто используя func()

И ваш вызов:

int myValue = 3; 
wiringPiISR(myValue, INT_EDGE_RISING, std::bind(myCallback, myValue)); 

Что это делает создать std::function объект (т.е. вызываемый), который обертывает вашу функцию и сохраняет желаемое значение в своем состоянии.

Это будет работать только с C++11 и новее.

Answer 4

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

void myCallbackHelper() { 
    static constexpr int myValue = 3; 
    myCallback(myValue); 
} 

wiringPiISR(myValue, INT_EDGE_RISING, &myCallbackHelper); 

Если вам нужно определить myValue во время выполнения, вы можете по-прежнему выполнять это, но не очень безопасно.

int& getMyValue() { 
    static int myValue; 
    return myValue; 
} 

void setMyValue(int i) { 
    getMyValue() = i; 
} 

void myCallbackHelper() { 
    myCallback(getMyValue()); 
} 

Затем установите его и вызовите

setMyValue(3); 
wiringPiISR(myValue, INT_EDGE_RISING, &myCallbackHelper); 

Answer 5

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

Сказав, что, есть причина, большинство API-вызовов с функцией-указатель обратного вызова выглядеть вроде этого

void setCallback(void (*function)(void* data), void* userdata); 

Это позволяет людям бросить их struct {blabla} data; добавить некоторые UserData, и когда функция вызывается, она передается вдоль.

Так что, в основном, помимо взлома со статическими переменными, вы не можете передавать какие-либо аргументы.

Answer 6

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

myWiringPiISRWrapper(Value value, int edge, std::function<void()> func) { 
    try { 
     throw &func; 
    } catch(...) { 
     myWiringPiISR(value, edge, [] { 
      try { 
       throw; 
      } catch(std::function<void()>* func) { 
       (*func)(); 
      } 
     }); 
    } 
} 

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