相关疑难解决方法(0)

如果条件为真,我想在非constexpr时引发编译时错误,例如:

if constexpr(condition1){
    ...
} else if constexpr (condition2) {
   ....
} else if constexpr (condition3) {
  ....
} else {
    // I want the else clause never taken. But I heard the code below is not allowed
    static_assert(false);
}

// I'd rather not repeat the conditions again like this:
static_assert(condition1 || condition2 || condition3);

static_assert在 的 false 分支中应丢弃以下内容if constexpr，但由于断言失败而导致编译失败：

#include <type_traits>                                                                                                                                                                              

template <class T>                                                                                                                                                                                  
constexpr bool f() {                                                                                                                                                                                
  if constexpr (std::is_same<T, int>::value) return true;                                                                                                                                                                                                                                                                    
  else static_assert(false, "message");                                                                                                                                                             
}                                                                                                                                                                                                   

int main () {                                                                                                                                                                                       
  if constexpr (f<int>()) return 1;                                                                                                                                                                 
  return 0;                                                                                                                                                                                         
} 

我希望丢弃的分支if constexpr不会被评估，因为它f是用 type 实例化的int。

用 Gcc 7.2 (-std=c++17) 编译

std::transform提供采用一元（一个参数）或二元（两个参数）可调用操作（通常为 lambda）的重载。

我想将我想要的可调用对象作为参数传递给父函数，并使用编译时（例如模板元编程）方法std::transform根据传递的可调用对象是否具有带有一个的函数签名来自动选择使用哪个重载或两个论点。

这是用（尚未工作）代码表达的所需方法：

#include <algorithm>

auto UnaryOp = [](const auto& src) { return src; };                                 // simple copy
auto BinaryOp = [](const auto& src1, const auto& src2) {return src1 + src2; };      // accumulate

auto GenericTransformer = [](auto src, auto dst, auto operation) {  // operation is unary OR binary

    /* unrelated code */

        // need to chose this one:
    std::transform(src.begin(), src.end(), dst.begin(), operation);
        // or this one:
    std::transform(src.begin(), src.end(), dst.begin(), dst.begin(), operation);
        // depending on …

我昨天读了几个关于在an 子句中使用的答案。我知道根据标准，它被认为是格式错误的（即使某些编译器，包括 MSVC2017，会接受它）。Qt 也会将此标记为错误。static_assert(false, "Some message")elseif constexpr

template <typename TypeOfValue>
static void PushValue(duk_context* ctx, TypeOfValue value) {
    // Push value onto duktape stack
    if constexpr (std::is_same<TypeOfValue, int>::value) {
        // Push int
        duk_push_int(ctx, value);
    } else if constexpr (std::is_same<TypeOfValue, uint32_t>::value) {
        // Push uint
        duk_push_uint(ctx, value);
    } else {
        // Unsupported type
        static_assert(bool_value<false, TypeOfValue>(), "Unsupported type");
    }    
}

template <bool value, typename T>
static constexpr bool bool_value() {return value;}