C++ 这些if语句会在编译时解析吗？

嘿，伙计们，我有几个问题自己回答不了

void someFunc_1(some_known_type_1 bar);
void someFunc_2(some_known_type_2 bar);
void someFunc_3(some_known_type_3 bar);

template < class T, T success> 
void foo(T check) {

    // ...

    auto bar = check;

    if (std::is_same<T, some_known_type_1>::value) {
        someFunc_1((some_known_type_1) bar);
        // ... 
    }
    else if (std::is_same<T, some_known_type_2>::value) {
        someFunc_2((some_known_type_2) bar);
        // ... 
    }
    else if (std::is_same<T, some_known_type_3>::value) {
        someFunc_3((some_known_type_3) bar);
        // ... 
    }

    // ...
}

---

好的，如果你仔细观察，你会发现我没有为bool类型重载

someFunc

，因此每次我使用

ERRCHK_bool（***）我将调用非专用版本的
someFunc
模板，这基本上是对空函数的调用调用空函数是个好主意吗？
在C++17中，您可以使用
constexpr if
来确保

如果您没有访问C++17的权限，仍然有一些SFINAE技巧（例如，您可以在一些伪额外参数上重载函数）可以完成这项工作，但是您的
If
语句很有可能在编译时得到解析

至于
自动条码
部分，问题有点不清楚。在这里使用
auto
似乎是完全正常的，尽管它与
T-bar
完全相同

我不得不说，一个简单的模板专门化可以做同样的工作，也许更清楚一些：

void someFunc_1(some_known_type_1 bar);
void someFunc_2(some_known_type_2 bar);
void someFunc_3(some_known_type_3 bar);

template < class T, T success> 
    void foo(T check) {
        // ...
    }

template <some_known_type_1 success> 
    void foo<some_known_type_1, success>(some_known_type_1 check) {
         someFunc_1(check);
         // ... 
    }

void someFunc\u 1（一些已知的类型\u 1条）；
void someFunc_2（某些已知类型_2条）；
void someFunc_3（某些已知类型_3条）；
模板
无效foo（T检查）{
// ...
}
样板
void foo（某些已知类型检查）{
someFunc_1（检查）；
// ... 
}

代码中不清楚-
success
参数有点碍事，但可能即使是函数重载也足够了（如其他人所述）。
在C++17中，您可以使用
constepr if
来确保

如果您没有访问C++17的权限，仍然有一些SFINAE技巧（例如，您可以在一些伪额外参数上重载函数）可以完成这项工作，但是您的
If
语句很有可能在编译时得到解析

至于
自动条码
部分，问题有点不清楚。在这里使用
auto
似乎是完全正常的，尽管它与
T-bar
完全相同

我不得不说，一个简单的模板专门化可以做同样的工作，也许更清楚一些：

void someFunc_1(some_known_type_1 bar);
void someFunc_2(some_known_type_2 bar);
void someFunc_3(some_known_type_3 bar);

template < class T, T success> 
    void foo(T check) {
        // ...
    }

template <some_known_type_1 success> 
    void foo<some_known_type_1, success>(some_known_type_1 check) {
         someFunc_1(check);
         // ... 
    }

void someFunc\u 1（一些已知的类型\u 1条）；
void someFunc_2（某些已知类型_2条）；
void someFunc_3（某些已知类型_3条）；
模板
无效foo（T检查）{
// ...
}
样板
void foo（某些已知类型检查）{
someFunc_1（检查）；
// ... 
}

代码中不清楚-
success
参数有点碍事-但可能即使是函数重载也足够了（如其他人所述）。
您所做的看起来像是手动重新创建函数重载系统。让编译器承受压力：

void someFunc(some_known_type_1 bar);
void someFunc(some_known_type_2 bar);
void someFunc(some_known_type_3 bar);

template < class T, T success> 
void foo(T check) {

    someFunc(check);

    // ...
}

void someFunc（一些已知类型的条）；
void someFunc（某些已知类型的2条）；
void someFunc（某些已知类型的3条）；
模板
无效foo（T检查）{
someFunc（支票）；
// ...
}
您所做的看起来像是手动重新创建函数重载系统。让编译器承受压力：

void someFunc(some_known_type_1 bar);
void someFunc(some_known_type_2 bar);
void someFunc(some_known_type_3 bar);

template < class T, T success> 
void foo(T check) {

    someFunc(check);

    // ...
}

void someFunc（一些已知类型的条）；
void someFunc（某些已知类型的2条）；
void someFunc（某些已知类型的3条）；
模板
无效foo（T检查）{
someFunc（支票）；
// ...
}
auto
在这种情况下没有太大意义，因为您处理的是通用代码，请使用
t bar=check取而代之

您未使用的分支可能会得到优化（至少是clang/gcc do it-在线检查），正如其他人所指出的，在即将到来的C++17中，如果
constepr
将是您执行此类编译时任务的首选

最后一点注意：我不能完全理解您的代码，但从这段代码来看，您似乎正在重新发明类型重载或模板专门化。你应该退后一步，考虑更大的图片。
 <代码> Auto <代码>在这个上下文中不太有意义，因为你在处理泛型代码，使用<代码> T bar =检查；<代码>取而代之

您未使用的分支可能会得到优化（至少是clang/gcc do it-在线检查），正如其他人所指出的，在即将到来的C++17中，如果
constepr
将是您执行此类编译时任务的首选

最后一点注意：我不能完全理解您的代码，但从这段代码来看，您似乎正在重新发明类型重载或模板专门化。你应该退后一步，考虑更大的图片。
 
是的，因为在编译时已知代码> > t>代码>和代码>某个已知类型1<代码>，现代编译器将优化if语句。原因是：几十年来，它们被设计用来检测死代码分支并消除它们。如果您不启用任何编译器优化，那么出于同样的原因，答案将是否定的。
是的，因为
t
和
一些已知类型在编译时已知，现代编译器将优化If语句。原因是：几十年来，它们被设计用来检测死代码分支并消除它们。如果您不启用任何编译器优化，那么出于同样的原因，答案将是否定的。
只需检查生成的代码？考虑到您希望根据
t
的类型调用不同的函数，我确信使用重载函数而不是模板将是更好的解决方案“.I无法传递以void someFunc_1（some_known_type_1 bar）键入some_known_type_2变量作为参数。”看起来您缺少重载的概念。您不应该使用
someFunc_{123}”
而是一组重载函数，所有重载函数都命名为just
someFunc
。如果需要处理重载集未提供的类型，可以向重载集中添加一个catch-all-do-nothing
模板void-someFunc（const T&）{}
。“我会因为