Аргументы функции «Преобразование»

Question

Я пишу класс C++, который взаимодействует с библиотекой. Библиотека имеет кучу функций, которые выглядят следующим образом:

Library.h

int FunctionA(int deviceNumber, ...); 
int FunctionB(int deviceNumber, ...); 
int FunctionC(int deviceNumber, ...); 
int FunctionD(int deviceNumber, ...); 
int FunctionE(int deviceNumber, ...); 

Каждый экземпляр моего C++ класс имеет ассоциированный deviceNumber, который никогда не меняется, так что я deviceNumber хранится как член переменной, и каждый раз, когда я вызываю библиотечную функцию, я передаю член в качестве первого аргумента функции.

Это прекрасно, и нет никакой реальной причины для меня изменить то, как оно есть. Но из любопытства мне было интересно, есть ли у C++ какой-либо механизм для «преобразования» аргументов, который позволил бы мне избежать передачи одного и того же аргумента в каждом вызове. Очевидный способ добиться этого - перегрузить все. Скажем, мой класс называется Foo:

foo.cpp

int Foo::FunctionA(...) { 
    // deviceNumber_ is a const member 
    return ::FunctionA(deviceNumber_, ...); 
} 

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

Есть ли какой-либо общий способ обеспечить перегрузку без фактической перегрузки функций? Есть ли механизм в C++ для «расширения» аргумента в несколько аргументов? Я воображая это будет выглядеть так:

// These two calls are equivalent 
FunctionA(deviceNumber, ...); 
FunctionA(Magic(...)); 
// Magic() expands the arguments, adding deviceNumber 

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

Answer 1

Вы могли бы быть счастливы с общей функцией реле:

Live On Coliru

#include <iostream> 

int foo1(int device_number, const char*) { std::cout << __PRETTY_FUNCTION__ << "\n"; return device_number*42; } 
double foo2(int device_number)    { std::cout << __PRETTY_FUNCTION__ << "\n"; return device_number*3.14159; } 

struct facade { 
    facade(int dn) : device_number(dn) {} 

    template <typename F, typename... A> 
     auto call(F&& f, A&&... args) const { 
      return std::forward<F>(f)(device_number, std::forward<A>(args)...); 
     } 

    private: 
    int device_number; 
}; 

int main() { 

    facade dev(2); 

    std::cout << dev.call(foo1, "yes ma'am") << "\n"; 
    std::cout << dev.call(foo2) << "\n"; 

} 

Answer 2

Я установил псевдокод, для структуры типа C++.

Прототип класса может иметь следующие формы.

class Foo { 
    private private_member_of_deviceNumber; 
    .... 
    int FunctionA(...); 
    .... 
} 

Конструктор класса Foo присваивает номер устройства переменной частному члену.

class Foo::Foo(int deviceNumber) { 
    int private_member_of_deviceNumber = deviceNumber; 
} 

Foo Класс участник FunctionA (...) понравится эта форма.

int Foo::FunctionA(...) { 
    return ::FunctionA(private_member_of_deviceNumber , ...); 
} 

Как насчет этого способа?

Answer 3

я бы, вероятно, выбрать Марка в файле CPP, как простое решение (строго в файле CPP, хотя)

шаблоны VARIADIC могли бы помочь здесь. Однако похоже, что вы делаете что-то встроенное, и это может быть проблемой.

Кроме того, я не уверен, что вы имеете в виду, что каждая функция A перегружена или FunctionA относится к одной функции.

Во всяком случае, мой шаблон решение поможет, если есть несколько FunctionAs

template<typename... Args> 
int Foo::FunctionA(Args&& ...args) { 
    return ::FunctionA(deviceNumber_, std::forward<Args>(args)...); 
}