Проектирование лучшего API для вариационной функции

Question

Я хотел бы обернуть переменную функцию C++ с помощью более современного API стиля C++ 11. Функция this one от Pin instrumentation tramework:

VOID LEVEL_PINCLIENT::INS_InsertCall(INS ins, 
            IPOINT action, 
            AFUNPTR funptr, 
            ...) 

Где AFUNPTR объявлен как:

typedef VOID (*AFUNPTR)(); 

и ... список аргументов для передачи funptr. Список состоит из дескрипторов аргументов (IARG_TYPE enum), необязательных значений аргументов и терминатора IARG_END, чтобы обозначить конец списка.

Вот пример использования для инструментирования функции до указанной инструкции (ins), которые будут печататься содержимым RAx регистра:

void print_rax_and_tid(long rax, THREADID tid) { 
    cout << rax << endl << tid << endl; 
} 

... 

INS_InsertCall(ins, IPOINT_BEFORE, (AFUNPTR)print_rax_and_tid, 
       IARG_REG_VALUE, REG_RAX, // the value of rAX register 
       IARG_THREAD_ID,   // the thread id 
       IARG_END) 

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

Обратите внимание, что каждая функция аргумента описывается одним или двумя дескрипторы аргументов:

• (IARG_REG_VALUE, REG_RAX) описывает (long rax)
• (IARG_THREAD_ID) описывает (THREADID tid)

Интерфейс Pin устанавливает дескрипторы, чтобы знать, что нужно передать пользовательской функции во время выполнения.

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

Я хотел бы создать этот API-интерфейс обложки со всем, что предлагает C++ 11, возможно, чтобы передать лямбда вместо указателя функции, добавив некоторую безопасность типов в список аргументов, используя вариативные шаблоны и т. Д. .

возможно использование может выглядеть следующим образом (но я открыт для предложений):

INS_InsertCall(ins, IPOINT_BEFORE, 
       [](long rax, THREADID tid) { cout << rax << endl << tid << endl; }, 
       IARG_REG_VALUE, REG_RAX, 
       IARG_THREAD_ID) 

Answer 1

вы можете использовать шаблон подход

#include <iostream> 

template <typename Runnable, typename... Types> 
auto execute(Runnable f, Types... ts) -> decltype(f(ts...)) 
{ 
    return f(ts...); 
} 

// Some methods to test with: 
void a() { std::cerr << __func__ << __LINE__ << "\n"; } 
void b(int) { std::cerr << __func__ << __LINE__ << "\n"; } 
void c(int, char) { std::cerr << __func__ << __LINE__ << "\n"; } 
int d() { std::cerr << __func__ << __LINE__ << "\n"; return 0; } 
int e(int) { std::cerr << __func__ << __LINE__ << "\n"; return 0; } 
int f(int, char) { std::cerr << __func__ << __LINE__ << "\n"; return 0; } 
int g() { std::cerr << __func__ << __LINE__ << "\n"; return 0; } 
void g(int) { std::cerr << __func__ << __LINE__ << "\n"; } 

int main() 
{ 
    int tmp = 1; 
    char tmp_2 = '0'; 
    execute(a); 
    execute(b, tmp); 
    execute(c, tmp, tmp_2); 
    execute(d); 
    execute(e, tmp); 
    execute(f, tmp, tmp_2); 
    execute([](int){ std::cerr << __func__ << __LINE__ << "\n"; }, 0); 
    execute(b); // This won't compile, as too few arguments provided. 
    execute<int()>(g); // Explicit template instantiation needed (typename Runnable only) 
    execute<void(int)>(g, 0); // Explicit template instantiation needed (typename Runnable only) 
} 

Если вы хотите отбросить возвращаемое значение вашей функции, шаблон становится еще проще

template <typename Runnable, typename... Types> 
void execute(Runnable f, Types... ts) 
{ 
    f(ts...); 
} 

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

Answer 2

Там не очень много я мог думать, чтобы делать с этим API: http://coliru.stacked-crooked.com/view?id=045edb71ffca8062a9e016506e4b51f7-4f34a5fd633ef9f45cb08f8e23efae0a

struct REG_VALUE { 
    IARG_TYPE arg = IARG_REG_VALUE; 
    REG_TYPE reg; 
    REG_VALUE(REG_TYPE r) :reg(r) {} 
}; 
template<REG_TYPE reg_v> 
struct REGISTER : REG_VALUE { 
    REGISTER() : REG_VALUE(reg_v) {} 
}; 

template<class func_type, class ...param_types> 
VOID InsertCall(INS ins, IPOINT action, func_type funptr, 
    param_types... param_values) 
{ INS_InsertCall(ins, action, (AFUNPTR)funptr, param_values..., IARG_END); } 

, а затем

InsertCall(ins, IPOINT_BEFORE, print_rax_and_tid, 
    REGISTER<REG_RAX>(), IARG_THREAD_ID); 

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