更改c+中参数类型的最佳实践+； 我想编写一个C++函数，它根据第一个函数调整第二个参数的类型。所以我有这样的想法： enum FtnType { FTN_A, FTN_B, FTN_C }; void bar( FtnType foo, const int arg = 0) { switch(foo) { case 0: { void ftnA(arg); break; } case 1: { void ftnB(); break; } case 2: { void ftnC(arg); break; } } }

现在对于

case 0

我希望arg是一个整数，对于

case 1

我不想使用任何参数，对于

case 3

我希望arg类型是float。我知道我可以在case中转换类型，但这似乎是一个糟糕的编程实践。解决这个问题的最佳方法应该是什么？

在我看来，根据第一个参数，您希望第二个参数采用不同的类型。C++是一种强类型语言，它意味着需要在编译时知道第一个参数的值。这给我们带来了模板领域（我很高兴）。另一个问题是，如果希望修改第二个参数，则需要通过引用传递它

enum class FtnType { ftn_a, ftn_b, ftn_c };

template <FtnType type> struct Modify;

template <> struct Modify<FtnType::ftn_a>
{
    static auto modify(int& a)
    {
        ftnA(a);
    }
}

template <> struct Modify<FtnType::ftn_b>
{
    static auto modify()
    {
        ftnB();
    }
}

template <> struct Modify<FtnType::ftn_c>
{
    static auto modify(float& a)
    {
        ftnC(a);
    }
}

enum类FtnType{ftn_a，ftn_b，ftn_c}；
模板结构修改；
模板结构修改
{
静态自动修改（int&a）
{
ftnA（a）；
}
}
模板结构修改
{
静态自动修改（）
{
ftnB（）；
}
}
模板结构修改
{
静态自动修改（浮动和a）
{
ftnC（a）；
}
}

使用方法：

int main()
{
    int a = 24;
    float f = 42.f;

    Modify<FtnType::ftn_a>::modify(a);
    Modify<FtnType::ftn_b>::modify();
    Modify<FtnType::ftn_c>::modify(f);
}

intmain（）
{
INTA=24；
浮点数f=42.f；
修改：：修改（a）；
Modify:：Modify（）；
Modify：：Modify（f）；
}

---

这是通过将结构以

FtnType

为模板来实现的，

FtnType

的每个专门化都有一个不同的签名静态

modify

函数。

我不确定我是否正确理解了您的问题，但是重载会像这样工作吗

void bar (int arg)
{
   ftnA(arg);
}

void bar (float arg)
{
   ftnC(arg);
}

void bar ()
{
   ftnB();
}

---

您不需要所有这些函数和

enum

。只需使用重载函数：

void ftn(int arg)
{
   std::cout << "I've got an int!" << std::endl;
   // Do stuff which is in ftnA
}

void ftn(float arg)
{
   std::cout << "I've got an float!" << std::endl;
   // Do stuff which is in ftnC
}

void ftn()
{
   std::cout << "I've got nothing! :(" << std::endl;
   // Do stuff which is in ftnB
}

enum类FtnType{FTN_A，FTN_B，FTN_C}；
空栏（FtnType foo，const int arg=0）{
[&] {
开关（foo）{
案例FtnType:：FTN_A:
返回ftnA（arg）；
案例FtnType:：FTN_B：
返回ftnB（）；
案例FtnType:：FTN_C:
返回ftnC（静态_转换（arg））；
}
}();
}

---

您正在尝试将编译时逻辑和运行时逻辑进行有趣的组合。虽然通过使用模板，通过将参数1指定为编译时已知值，您可能可以实现一些功能，但我不完全确定这是否可取

你要求一个最佳实践，老实说，我觉得最好的实践是退一步，重新思考你的设计。为什么需要函数根据参数1以如此不同的方式工作

如果要更改参数2的值，例如在经典的

printf

类函数中使用的情况，则会出现编译时难以检测的错误源，运行时更难检测

您可以考虑使用可变模板的更为编译时友好的方法（尽管我仍然建议重新思考您的设计）：

此测试代码可以在以下位置找到：和输出：

test1(1, 2.1, c)
test2()

---

演员阵容<如果可以的话，code>static\u cast。调用

bar（）

的人如何知道它将决定它想要什么类型？我想如果你想

arg

成为

int

或

float

，当你调用

bar

@Snps时，你需要一个模板或重载。对不起，那是一个输入错误。在我看来，调用者应该有足够的信息来直接调用

ftnA（）

ftnB（）

或

ftnC（）

？

enum class FtnType {FTN_A, FTN_B, FTN_C};

void bar(FtnType foo, const int arg = 0) {
    [&] {
        switch(foo) {
            case FtnType::FTN_A:
                return ftnA(arg);
            case FtnType::FTN_B:
                return ftnB();
            case FtnType::FTN_C:
                return ftnC(static_cast<double>(arg));
        }
    }();
}

template <typename F, typename... T>
void bar(F func, T... params) {
    func(params...);
}

void test1(int a, double b, char c) {
    std::cout << "test1(" << a << ", " << b << ", " << c << ")\n";
}

void test2() {
    std::cout << "test2()\n";
}

int main() {
    bar(test1, 1, 2.1, 'c');
    bar(test2);
    return 0;
}

test1(1, 2.1, c)
test2()