“转换”函数参数

Question

我正在编写与库接口的 C++ 类。该库有一堆函数，如下所示：

图书馆.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

我可能会在 cpp 文件中选择一个 marco 作为最简单的解决方案（但严格在 cpp 文件中）

可变参数模板也可以在这里提供帮助。但是，听起来您正在做一些嵌入的事情，这可能是个问题。

另外，我不确定您的意思是每个 FunctionA 都被重载了，还是 FunctionA 只引用了一个函数。

无论如何，如果有多个 FunctionAs，我的模板解决方案会有所帮助

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

Answer 3

我把伪代码，用于C++类型结构。

类原型可能有以下形式。

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

Foo 类构造函数会将 deviceNumber 分配给私有成员变量。

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

Foo 类成员 FunctionA(...) 会喜欢这种形式。

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

这样怎么样？