在类模板中使用条件运算符初始化静态constexpr char数组成员

Question

Consider a minimal example

#include <iostream>

template<typename T>
struct foo
{
    // won't compile. how to change?
    static constexpr char sep[3] = std::is_integral<T>::value ? ". " : ", ";

    // many other things ...
};

int main()
{
    std::cout << foo<int>::sep << std::endl;     // prints .
    std::cout << foo<double>::sep << std::endl;  // prints ,
}

What I want to achieve is:

• if T has an integral type, then sep is initialized to .
• otherwise, sep is initialized to ,

However, the compiler won't allow this, saying

error: array must be initialized with a brace-enclosed initializer

It looks like something must be done in compile time. But I am not sure how to do it.

My question is: is there anything I can do to achieve this end?

Note: Minimal change is most welcome. There ought to be many other things in foo . Another consideration is that I want to keep everything about foo in header and to leave nothing in source file, if possible.

Thank you very much.

Answer 1

C-arrays are not copyable, so you have to work-around that

• Do the check for each character:

   constexpr char sep[3] = { std::is_integral<T>::value ? '.' : ',', ' ', '\\0' }; 

• Don't use array but pointer (so you loose size):

   constexpr const char* sep = std::is_integral<T>::value ? ". " : ", "; 

• Use std::array :

   constexpr std::array<char, 3> sep = std::is_integral<T>::value ? std::array<char, 3>{{'.', ' ', 0}} : std::array<char, 3>{{',', ' ', 0}}; 

• Use reference to array:

   constexpr char dot_sep[3] = std::is_integral<T>::value ? ". " : ", "; constexpr char comma_sep[3] = std::is_integral<T>::value ? ". " : ", "; constexpr const char (&sep)[3] = std::is_integral<T>::value ? dot_sep : comma_sep; 

  and provide definition of dot_sep / comma_sep which are ODR-used.

Answer 2

The best way is to use base class with specialization, and put sep in the base class:

template <bool IsIntegral>
struct foo_base;

template<>
struct foo_base<true>
{
    static constexpr char sep[3] = ". ";
};

template<>
struct foo_base<false>
{
    static constexpr char sep[4] = ",  ";
};


template<typename T>
struct foo : foo_base<std::is_integral_v<T>>
{
    // many other things ...
};

But if you don't want others to access the base, you can use private inheritance:

template<typename T>
struct foo : private foo_base<std::is_integral_v<T>>
{
    using foo_base<std::is_integral_v<T>>::sep;
    // many other things ...
};

Edit

The advantage of this solution over using a std::array<char, 3> , is that this solution plays nicely with functions that accept a reference to C arrays of char. Neither storing const char* nor std::array<char, 3> have this capability.

For example, if you have functions like:

template <std::size_t I>
constexpr int count_nuls(const char (&x)[I])
{
    // Can't use std::count, since it is not constexpr
    unsigned count = 0;
    for (auto ch: x)
        if (ch == '\0')
            ++count;
    return count;
}

This function can't be used with std::array , or with a const char * . If there are many functions like that, one may not want to upgrade all of them to std::array . For example, this function works perfectly in:

static constexpr unsigned nuls = count_nuls(foo<double>::sep);

But won't work (without further modification) with std::array<char, 3> .