如果设置了可选函数参数，如何启用模板参数？

Question

我有一个解析功能，我想根据设置长度选项是否设置。如果设置了长度选项，则该函数应始终检查缩短长度是否等于0。如果没有，则仅检查终止终止。 Based on this little detail I don't want to rewrite my whole function, so here's what I came up with:

#include <iostream>

const char* str = "some random string";

template <bool LengthOpt = false>
void parse(const char* ch, size_t len = 0)
{
    while ( 1 ) {
        if constexpr(LengthOpt) {
            if ( len == 0 ) {
                std::cout << std::endl;
                return ;
            } else {
                len--;
            }
        } else {
            if ( !(*ch) ) {
                std::cout << std::endl;
                return ;
            }
        }
        std::cout << *ch;
        ++ch;

        /* big part starts here */
    }
}

int main()
{
    parse<true>(str, 5);
    parse(str);
}

godbolt

让我困扰的是，我总是必须指定长度和模板参数才能使用长度选项。因此，我想知道：

• 是否有一种方法可以根据设置可选参数来进行constexpr分支？
• 我可以从设置可选参数中推断模板参数吗？

注意：这是一个人为的示例，只是显示细节。我在代码中添加了实际解析的评论。

Answer 1

我认为您可以在此处使用功能过载：

#include <iostream>

const char* str = "some random string";

void parse(const char* ch, size_t len)
{
    while ( 1 ) {
        if ( len == 0 ) {
            std::cout << std::endl;
            return ;
        } else {
                len--;
        }

        std::cout << *ch;
        ++ch;

        /* the big part can be moved into separate function */
       bigPart(ch);
    }
}

void parse(const char* ch)
{
    while ( 1 ) {
        if ( !(*ch) ) {
            std::cout << std::endl;
            return ;
        }

        std::cout << *ch;
        ++ch;

        /* the big part can be moved into separate function */
       bigPart(ch);

    }
}

int main()
{
    parse(str, 5);
    parse(str);
}

Answer 2

您可以使用一对过载来执行此操作，该过载将其委派给模板版本以避免复制代码：

template <bool LengthOpt>
void do_parse(const char* ch, std::size_t len) {
    // ...
}

void parse(const char* ch) {
    do_parse<true>(ch, 0);
}

void parse(const char* ch, std::size_t len) {
    do_parse<false>(ch, len);
}

或者您可以切换到基于迭代的方法：

template<typename Iterator, typename Sentinel>
void do_parse(Iterator it, Sentinel end) {
    for (; it != end; ++it) {
        char c = *it;
        // ...
    }
}

struct null_sentinel_t {};
inline constexpr null_sentinel_t null_sentinel{};

inline constexpr bool operator==(null_sentinel_t, const char* p) noexcept { return *p == 0; }
// The next 3 overloads are not necessary in C++20
inline constexpr bool operator==(const char* p, null_sentinel_t) noexcept { return *p == 0; }
inline constexpr bool operator!=(null_sentinel_t, const char* p) noexcept { return *p != 0; }
inline constexpr bool operator!=(const char* p, null_sentinel_t) noexcept { return *p != 0; }

void parse(const char* ch) {
    do_parse(ch, null_sentinel);
}
void parse(const char* ch, std::size_t len) {
    do_parse(ch, ch + len);
}