4

是否可以在 constexpr 上下文中使用“if constexpr”比较 std::string_view？为什么 is_hello_2 和 is_hello_4 无法编译显示错误：“'s' is not a constant expression”

static constexpr bool is_hello_1(auto s) {
  return s == "hello";
}

static constexpr bool is_hello_2(auto s) {
    if constexpr (s == "hello") {
        return true;
    }
    return false;
}

static constexpr auto is_hello_3 = [](auto s) {
    return s == "hello";
};

static constexpr auto is_hello_4 = [](auto s) {
    if constexpr (s == "hello") {
        return true;
    }
    return false;
};

考虑到主要功能（https://godbolt.org/z/zEcnb8）：

int main(int argc, char **argv) {
    static constexpr const std::string_view s1 ("hello");
    if constexpr (s1 == "hello"){}
    if constexpr (is_hello_1(s1)){}
    // if constexpr (is_hello_2(s1)){} // <- doesn't compile
    if constexpr (is_hello_3(s1)){}
    // if constexpr (is_hello_4(s1)){} // <- doesn't compile
    return 0;
}

有没有办法修复“is_hello_2”和“is_hello_4”？

4

3 回答 3

8

有没有办法修复“is_hello_2”和“is_hello_4”？

constexpr从ifsis_hello_2或中删除is_hello_4。

如何在 constexpr 上下文中使用 if-constexpt 比较 string_view

通常，就像其他任何地方一样。

static constexpr bool is_hello_5() {
    constexpr const std::string_view s1 ("hello");
    if constexpr (s1 == "hello") {
        return true;
    }
    return false;
}

函数参数值不是常量表达式，您不能在if constexpr.

于 2020-10-19T12:28:38.497 回答
3

我不会使用正式的标准措辞，而是解释问题。

if constexpr要求它的所有参数总是constexpr.

函数的参数constexpr有时是constexpr.

您可以调用不constexpr带constexpr参数的函数。

试试consteval。

#include <string_view>

using namespace std::literals;

consteval bool is_hello_1(auto s) {
  return s == "hello";
}

consteval bool is_hello_2(auto s) {
    if (s == "hello") {
        return true;
    }
    return false;
}


int main(int argc, char **argv) {

    static constexpr std::string_view s1 ("hello");
    static_assert(s1 == "hello");
    static_assert(is_hello_1(s1));
    static_assert(is_hello_2("hello"sv));
    return 0;
}

活生生的例子

您可以consteval在通常放置 mutable 的地方放入一个 lambda（我不记得这个副手，所以我没有在上面的示例代码中包含 lambda）。

最后，我建议static对 C++ 文件的本地函数使用匿名命名空间，并且在标头中都不使用。

这可能无法满足您的所有需求；的优点if constexpr是您可以根据分支执行类型无效的事情。而且 C++ 不允许你根据函数参数的值做类型无效的事情。如果是这样，编译器无法在没有提供参数值的情况下编译函数体。

为了解决这个问题，您可以执行创建编译时字符串之类的操作。

template<auto s>
consteval bool is_hello_2() {
  if constexpr (s == "hello") {
    return true;
  }
  return false;
}

并调用它

template<std::size_t N>
struct compile_time_string : std::array<char, N+1> {
    constexpr std::array<char, N+1>& buffer() { return *this; }
    constexpr std::array<char, N+1> const& buffer() const { return *this; }
    constexpr std::string_view view() const { return {this->data(), this->data()+this->size()}; }
    
private:
    template<std::size_t...Is>
    constexpr compile_time_string( char const* str, std::index_sequence<Is...> ):
        std::array<char, N+1>{{ str[Is]..., char(0) }}
    {}
public:
    explicit constexpr compile_time_string( char const* str ):
        compile_time_string( str, std::make_index_sequence<N>{} )
    {}
    explicit constexpr compile_time_string( std::array<char, N+1> buff ) :
        std::array<char, N+1>(buff)
    {}

    constexpr compile_time_string( compile_time_string const& ) = default;
    compile_time_string() = delete;
    
        
    constexpr auto operator<=>( compile_time_string const& o ) const = default;
    constexpr bool operator==( compile_time_string const& o ) const = default;
    
    template<std::size_t N_arg>
    friend constexpr auto operator==( char const(&lhs)[N_arg], compile_time_string const& rhs )
    {
        return std::string_view{ lhs, lhs+N_arg } == rhs.view();
    }
    template<std::size_t N_arg>
    friend constexpr auto operator==( compile_time_string const& lhs, char const(&rhs)[N_arg] )
    {
        return lhs.view() == std::string_view{ rhs, rhs+N_arg };
    }
};
template<std::size_t N>
compile_time_string( char const(&)[N] )->compile_time_string<N-1>;


template<auto s>
consteval bool is_hello_3() {
    if (s == "hello") {
        return true;
    }
    return false;
}


static_assert(is_hello_3<compile_time_string("hello")>());

活生生的例子。

我减少了一堆编译时间字符串。对于更多类型，您会想要更好的 <=> 和 == 等。

另外，我认为在 C++20 中，您可以制作“更强”的编译时字符串，其中字符串实际上存在于 auto 参数中。但我不确定。

于 2020-10-19T13:48:50.603 回答
1

从函数的角度思考（好像你在函数范围内）：如果函数参数未知，它如何在编译时解析你的代码？这与您在 main 函数中标记s1的原因相同。constexpr如果你不这样做 - 代码将无法编译。

所以你要做的就是constexpr从is_hello2and中删除is_hello4。这并不妨碍在 constexpr 中使用该函数。

#include <string_view>

static constexpr bool is_hello_1(auto s) {
  return s == "hello";
}

static constexpr bool is_hello_2(auto s) {
    if (s == "hello") {
        return true;
    }
    return false;
}

static constexpr auto is_hello_3 = [](auto s) {
    return s == "hello";
};

static constexpr auto is_hello_4 = [](auto s) {
    if (s == "hello") {
        return true;
    }
    return false;
};

int main(int argc, char **argv) {

    static constexpr std::string_view s1 ("hello");
    static_assert(s1 == "hello");
    static_assert(is_hello_1(s1));
    static_assert(is_hello_2("hello"));
    static_assert(is_hello_3(s1));
    static_assert(is_hello_4(s1));
    return 0;
}

但是在类型和非类型模板参数上使用 if constexpr 是完全可以的：

template<int s>
static constexpr auto is_5 = []() {
    if constexpr (s == 5) {
        return true;
    }
    return false;
};

static_assert(is_5<5>());

不幸的是，您现在不能将 std::string_view 作为非类型模板参数。

于 2020-10-19T12:33:26.800 回答