Is it possible in modern C++ to pass a string literal as a parameter to a C++ template?

Question

Is it possible in "modern C++" (C++17 or greater) to pass a string literal as a parameter to a C++ template?

I realize you could do this with constructor argument; I just thought it would be more convenient to have it as a template argument, rather than buried deep in the cpp file. I was curious if maybe this was a new feature of modern C++. See Pseudo code below of what I'm trying to do:

Pseudo-code Example:

// Header File /////////////////////////
template<constexpr string Name>
class ModuleBase {
public:
    ModuleBase();
    string name;
};

class xyz : ModuleBase<"xyz"> {
public:
    xyz();
};

// Cpp File //////////////////////////
template<string_literal Name>
ModuleBase<Name>::ModuleBase() {
    name = Name;
}

xyz::xyz() : ModuleBase() {

}

Answer 1

Yes, in c++20.

The problem was that determining uniqueness of a template non-type argument was difficult.

c++20 adds in a <=> spaceship operator comparison. If it is non-user provided (and based only off non-user provided <=> in turn, repeat recursively) (and a few other requirements; see p0732), the type can be used as a non-type template argument.

Such types can be constructed from raw "strings" in constexpr constructors, including using c++17 deduction guides to make them auto-size themselves.

As the size of the data stored is probably going to be part of the type, you'll want to take the type as an auto typed non-type parameter or otherwise auto-deduced type.

---

Note that placing the implementation of your template in a cpp file is usually a bad idea. But that is another question.

Answer 2

Until you get c++20 and if you have boost, you may find the following macro usefull:

#define C_STR(str_) boost::mpl::c_str< BOOST_METAPARSE_STRING(str_) >::value

Then use as follows:

template<const char* str>
structe testit{
};
testit<C_STR("hello")> ti;

Answer 3

It's uglier than directly passing a string literal, but in C++20 it's also possible to get away with using a NTTP constexpr lambda returning the string:

#include <string_view>

template<auto getStrLambda>
struct MyType {
    static constexpr std::string_view myString{getStrLambda()};
};

int main() {
    using TypeWithString = MyType<[]{return "Hello world!";}>;
    return 0;
}

Compiler explorer example here.

Answer 4

It can be done in C++17 but you need static constexpr storage for the C string before you pass it as name: https://godbolt.org/z/ojnv8xPca

#include<cstddef>
#include<string> //std::size()

namespace util {
    template<std::size_t N>
    using c_str = char const [N];

    template<auto const & str, std::size_t iter = std::size(str), char const ... chars>
    struct c_str_to_arg_pack {
        using arg_pack_t = 
            typename c_str_to_arg_pack<str, iter-1, str[iter-1], chars ... >
                ::arg_pack_t;
    };

    template<auto const & str, char const ... chars>
    struct c_str_to_arg_pack<str, 0, chars ...> {
        using arg_pack_t = c_str_to_arg_pack<str, 0, chars...>;

        template <template <char ...> typename T>
        using apply = T<chars ...>;
    };
    template<auto const & str, char const ... chars>
    using c_str_to_arg_pack_t = typename c_str_to_arg_pack<str, chars ... >::arg_pack_t;

}//end util

#include<string_view>
#include<array>

template <char ... chars>
struct module_base {
    std::string const & get_name() {
        static std::string name = []()
            {
                std::string name;
                name.reserve(sizeof...(chars));
                (name += ... += chars); 
                return name;
            }();
        return name;
    };
    static constexpr std::array<char, sizeof ... (chars)> name_backing {chars ...};
    static constexpr std::string_view constexpr_name {name_backing.begin(), name_backing.size() };
    static int instance_count;
    module_base (){
        ++instance_count;
    }
    virtual ~module_base() = default;
};

template <char ... chars>
int module_base<chars ...>::instance_count {};

template <auto const & name>
struct xyz : util::c_str_to_arg_pack_t<name>::template apply<module_base> //edit, formerly missing 'template'
{};

template <auto const & name>
struct abc : util::c_str_to_arg_pack_t<name>::template apply<module_base> //edit, formerly missing 'template'
{};

#include<iostream>

int main(){
    static constexpr util::c_str<std::size("beans\n")> beans {"beans\n"};
    xyz<beans> test{};
    std::cout << test.get_name();
    
    static constexpr util::c_str<std::size("beans\n")> beans_two {"beans\n"};
    abc<beans_two> test_two{};
    std::cout << test_two.constexpr_name;
    
    std::cout << decltype(test)::instance_count << '\n';
    std::cout << decltype(test_two)::instance_count << '\n';
}