Why Cant I Substitute a String into a NTTP

Question

Take the following example:

template<const auto& A>
class B {};

int main() {
    B<"abc"> b;
    return 0;
}

I have tried several variants of this, I dont understand why it does not work, it works for this library, it supports the following

constexpr auto match(std::string_view sv) noexcept {
    return ctre::match<"h.*">(sv);
}

and it is receiving a const auto& specific context type alias, place where the type is forwarded where it ends up

It also does not really work if I do the following

template<const auto& StringParameterConstant, size_t IndexParameterConstant = 0>
consteval size_t string_length()
{
    if constexpr(StringParameterConstant[IndexParameterConstant] != '\0')
        return string_length<StringParameterConstant, IndexParameterConstant + 1>();
    else
        return IndexParameterConstant;
}

template<char... CharacterParameterConstants>
struct TemplateString {
    constexpr static const size_t length = sizeof...(CharacterParameterConstants);
    constexpr static const char array[length] = { CharacterParameterConstants... };
};

template<
        const auto& StringParameterConstant, 
        size_t IndexParameterConstant, 
        size_t LengthParameterConstant, 
        char... CharacterParameterConstants
    >
consteval auto to_template_string()
{
//...
}
template<const auto& StringParameterConstant>
    using TemplateStringType = decltype(to_template_string //...

    template<
            const auto& PatternParameterConstant,
            const auto& NameParameterConstant, //...
        >
    struct RegexTerm
    {
        using PatternType = TemplateStringType<PatternParameterConstant>;
        using NameType = TemplateStringType<NameParameterConstant>;
        constexpr static ctpg::regex_term<PatternType::string> term( // OK
                NameType::string, // OK
                //...
            );
    };
//...
/*tried with constexpr static and in a consteval/constexpr function*/
RegexTerm<"[1-9][0-9]*", "Numerical">::term; // Error

Answer 1

You will need some kind of string wrapper.

A char const* won't really template over the value of the string, but it will template over the pointer to that character array. This is not what you want.

The solution is to implement some kind of fixed_string class:

template<std::size_t n>
struct fixed_string {
    constexpr fixed_string() = default;
    constexpr fixed_string(const char(&str)[n + 1]) noexcept {
        auto i = std::size_t{0};
        for (char const c : str) {
            _data[i++] = c;
        }
        _data[n] = static_cast<Char>(0);
    }
    
    friend constexpr auto operator<=>(fixed_string const&, fixed_string const&) = default;
    friend constexpr auto operator==(fixed_string const&, fixed_string const&) -> bool = default;
    
    [[nodiscard]]
    static constexpr auto size() noexcept -> std::size_t {
        return n;
    }

    [[nodiscard]]
    static constexpr auto empty() noexcept -> bool {
        return n == 0;
    }
    
    constexpr auto data() const& noexcept -> char const* {
        return _data;
    }
    
    constexpr auto data() & noexcept -> char* {
        return _data;
    }
    
    constexpr auto begin() const& noexcept -> char const* {
        return _data;
    }
    
    constexpr auto end() const& noexcept -> char const* {
        return _data + n;
    }
    
    constexpr auto begin() & noexcept -> char* {
        return _data;
    }
    
    constexpr auto end() & noexcept -> char* {
        return _data + n;
    }
    
    constexpr auto operator[](std::size_t index) noexcept {
        return _data[index];
    }
    
    char _data[n + 1];
};

// template argument deduction
template<std::size_t n>
fixed_string(char const(&)[n]) -> fixed_string<n - 1>;

Then, you can then use that fixed string inside template arguments:

template<fixed_string str> // use class template argument deduction
class B {};

int main() {
    B<"abc"> b; // actually works!
    return 0;
}

Note that you will need C++20 enabled to use that feature.