在通过模板元编程评估C风格字符串的长度时，必须指定上限

Question

I recently starting playing around with template metaprogramming in C++, and been trying to evaluate the length of a C-style string.

I've had some success with this bit of code

template <const char *str, std::size_t index>
class str_length {
public:
    static inline std::size_t val() {
        return (str[index] != '\0') ? (1 + str_length<str, index + 1>::val()) :             0;
    }
};

template <const char *str>
class str_length <str, 500> {
public:
    static inline std::size_t val() {
        return 0;
    }
};

extern const char bitarr[] { "0000000000000000000" };

int main() {
    std::cout << str_length<bitarr, 0>::val() << std::endl;

    getchar();
    return 0;
}

However, I had to set a "upper limit" of 500 by creating a specialization of str_length. Omitting that would cause my compiler to run indefinitely (presumably creating infinite specializations of str_length).

Is there anything I could do to not specify the index = 500 limit? I'm using VC++2015 if that helps.

Oh, and I'm not using constexpr because VC++ doesn't quite support the C++14 extended constexpr features yet. ( https://msdn.microsoft.com/en-us/library/hh567368.aspx#cpp14table )

Answer 1

The usual way to stop infinite template instantiation, in these situation, is by using specialization; which is orthogonal to constexpr -ness of anything. Reviewing the list of additional stuff that extended constexpr allows in C++14, I see nothing in the following example that needs extended constexpr support. gcc 6.1.1 compiles this in -std=c++11 compliance mode, FWIW:

#include <iostream>

template<const char *str, size_t index, char c> class str_length_helper;

template <const char *str>
class str_length {
public:

    static constexpr std::size_t val()
    {
        return str_length_helper<str, 0, str[0]>::val();
    }
};

template<const char *str, std::size_t index, char c>
class str_length_helper {

public:

    static constexpr std::size_t val()
    {
        return 1+str_length_helper<str, index+1, str[index+1]>::val();
    }
};

template<const char *str, std::size_t index>
class str_length_helper<str, index, 0> {
public:

    static constexpr std::size_t val()
    {
        return 0;
    }
};

static constexpr char bitarr[] { "0000000000000000000" };

int main() {
    std::cout << str_length<bitarr>::val() << std::endl;

    getchar();
    return 0;
}

Note, however, that the character string itself must be constexpr . As the comments noted, this is of dubious practical use; but there's nothing wrong with messing around in this manner in order to get the hang of metaprogramming.

The key point is the use of specialization, and the fact that in order to be able to use str[index] as a template parameter, str must be constexpr .