说我有

constexpr const std::uint8_t major = 1;
constexpr const std::uint8_t minor = 10;
constexpr const std::uint8_t bugfix = 0;

我要

constexpr const char* version_string(){ ... }

在此示例中要返回等效于 "1.10.0"，我该怎么做？

我假设我需要这两个，在 constexpr 中:

• 整数到字符串的转换
• 字符串连接

这个问题纯粹是学术性的，除了“这是可能的”之外，我认为实际上拥有它 constexpr 几乎没有用处。我只是看不出结果如何。我愿意接受适用于 GCC 4.9 和 Clang 3.4/3.5 的 C++1y 解决方案。

我相信我几乎已经找到了我在一些日本博客上寻找的东西:

• constexpr itoa
• constexpr strcat

我会看看我能用这些做些什么，当我对结果满意时，也许会自己回答这个自称有趣的问题。

最佳答案

这是一个 C++1y 的小解决方案 --- 我想我喜欢 C++1y。

#include <utility>

template<int N>
struct c_string
{
    int length;
    char str[N+1];

    constexpr explicit c_string(int p_length)
        : length(p_length), str{}
    {}
};

template<int M>
constexpr auto make_c_string(char const (&str)[M])
{
    c_string<M-1> ret{M-1};
    for(int i = 0; i < M; ++i)
    {
        ret.str[i] = str[i];
    }
    return ret;
}

template<int N, int M>
constexpr auto join(c_string<N> const& x, c_string<M> const& y)
{
    c_string<N+M> ret{x.length + y.length};

    for(int i = 0; i < x.length; ++i)
    {
        ret.str[i] = x.str[i];
    }
    for(int i = 0; i < y.length; ++i)
    {
        ret.str[i+x.length] = y.str[i];
    }

    ret.str[N+M] = '\0';

    return ret;
}

template<int N, int M>
constexpr auto operator+(c_string<N> const& x, c_string<M> const& y)
{
    return join(x, y);
}


template<class T>
constexpr void c_swap(T& x, T& y)
{
    T tmp( std::move(x) );
    x = std::move(y);
    y = std::move(tmp);
}

// from http://en.cppreference.com/w/cpp/algorithm/reverse
template<class I>
constexpr void reverse(I beg, I end)
{
    while(beg != end && beg != --end)
    {
        c_swap(*beg, *end);
        ++beg;
    }
}

现在 constexpr itoa:

#include <limits>

template<class T>
constexpr auto c_abs(T x)
{
    return x < T{0} ? -x : x;
}

template<class T>
constexpr auto ntoa(T n)
{
    c_string< std::numeric_limits<T>::digits10 + 1 > ret{0};
    int pos = 0;

    T cn = n;
    do
    {
        ret.str[pos] = '0' + c_abs(cn % 10);
        ++pos;
        cn /= 10;
    }while(cn != T{0});

    if(n < T{0})
    {
        ret.str[pos] = '-';
        ++pos;
    }

    ret.str[pos] = '\0';
    ret.length = pos;

    reverse(ret.str, ret.str+ret.length);
    return ret;
}

然后我们可以简化用法:

#include <type_traits>

// not supported by the libstdc++ at coliru
//template<class T, class = std::enable_if_t< std::is_arithmetic<T>{} >>
template<class T, class = typename std::enable_if<std::is_arithmetic<T>{}>::type>
constexpr auto to_c_string(T p)
{
    return ntoa(p);
}
template<int N>
constexpr auto to_c_string(char const (&str)[N])
{
    return make_c_string(str);
}

template<class T, class U, class... TT>
constexpr auto to_c_string(T&& p0, U&& p1, TT&&... params)
{
    return   to_c_string(std::forward<T>(p0))
           + to_c_string(std::forward<U>(p1), std::forward<TT>(params)...);
}

还有一个用法示例:

#include <iostream>

int main()
{
    constexpr auto res = to_c_string(42," is the solution, or is it ",-21,"?");

    std::cout << res.str;
}

Live example @ coliru's clang++3.4

关于c++ - 如何从三个整数(或者可能是一个 git/SVN commit/rev.string)生成一个 constexpr 版本字符串？，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/23444818/