问题 C ++ concat两个`const char`字符串文字

一点儿 constexpr，撒上一些TMP和指数的顶部给我这个：

#include <array>

template<unsigned... Is> struct seq{};
template<unsigned N, unsigned... Is>
struct gen_seq : gen_seq<N-1, N-1, Is...>{};
template<unsigned... Is>
struct gen_seq<0, Is...> : seq<Is...>{};

template<unsigned N1, unsigned... I1, unsigned N2, unsigned... I2>
constexpr std::array<char const, N1+N2-1> concat(char const (&a1)[N1], char const (&a2)[N2], seq<I1...>, seq<I2...>){
  return {{ a1[I1]..., a2[I2]... }};
}

template<unsigned N1, unsigned N2>
constexpr std::array<char const, N1+N2-1> concat(char const (&a1)[N1], char const (&a2)[N2]){
  return concat(a1, a2, gen_seq<N1-1>{}, gen_seq<N2>{});
}

实例。

我会更多地将它充实，但我必须开始并想在此之前放弃它。你应该可以从中工作。

乍一看，C ++ 11用户定义的字符串文字似乎是一种更简单的方法。 （例如，如果您正在寻找一种在编译时全局启用和禁用换行注入的方法）

• 您无法从函数返回（普通）数组。
• 你不能创建一个新的 const char[n] 在constexpr中（§7.1.5/ 3 dcl.constexpr）。
• 一个 地址常量表达式 必须引用静态存储持续时间的对象（§5.19/ 3 expr.const） - 这不允许使用类型对象的一些技巧，这些对象具有组装数组以进行连接的constexpr ctor，并且你的constexpr fct只是将它转换为ptr。
• 传递给constexpr的参数不被认为是编译时常量，所以你也可以在运行时使用fct - 这不允许使用模板元编程的一些技巧。
• 你不能将传递给函数的字符串文字的单个字符作为模板参数 - 这不允许其他一些模板元编程技巧。

所以（据我所知），你不能得到一个返回的constexpr char const* 一个新构造的字符串或一个 char const[n]。请注意，大多数这些限制不适用于 std::array 正如Xeo所指出的那样。

即使你可以归还一些 char const*，返回值不是文字，只连接相邻的字符串文字。这发生在翻译阶段6（§2.2），我仍称之为预处理阶段。 Constexpr稍后进行评估（参考？）。 （f(x) f(y) 哪里 f 是一个函数是语法错误afaik）

但是你可以从constexpr fct返回一个其他类型的对象（带有constexpr ctor或者是一个聚合），它包含两个字符串，可以插入/打印成一个 basic_ostream。

编辑：这是一个例子。这是相当长的o.O. 请注意，您可以简化此操作，以获得额外的“\ n”添加字符串的结尾。 （这更像是我刚从内存中写下的通用方法。）

编辑2：实际上，你无法真正简化它。创造 arr 数据成员作为“const char_type数组”包含'\ n'（而不是字符串文字数组）使用一些花哨的可变参数模板代码实际上有点长（但它的工作原理，请参阅Xeo的答案）。

注意：as ct_string_vector （名称不好）存储指针，它应该只用于静态存储持续时间的字符串（例如文字或全局变量）。优点是不必通过模板机制复制和扩展字符串。如果使用constexpr来存储结果（如示例中所示） main），如果传递的参数不是静态存储持续时间，编译器应该抱怨。

#include <cstddef>
#include <iostream>
#include <iterator>

template < typename T_Char, std::size_t t_len >
struct ct_string_vector
{
    using char_type = T_Char;
    using stringl_type = char_type const*;

private:
    stringl_type arr[t_len];

public:
    template < typename... TP >
    constexpr ct_string_vector(TP... pp)
        : arr{pp...}
    {}

    constexpr std::size_t length()
    {  return t_len;  }

    template < typename T_Traits >
    friend
    std::basic_ostream < char_type, T_Traits >&
    operator <<(std::basic_ostream < char_type, T_Traits >& o,
        ct_string_vector const& p)
    {
        std::copy( std::begin(p.arr), std::end(p.arr),
            std::ostream_iterator<stringl_type>(o) );
        return o;
    }
};

template < typename T_String >
using get_char_type =
    typename std::remove_const < 
    typename std::remove_pointer <
    typename std::remove_reference <
    typename std::remove_extent <
        T_String
    > :: type > :: type > :: type > :: type;

template < typename T_String, typename... TP >
constexpr
ct_string_vector < get_char_type<T_String>, 1+sizeof...(TP) >
make_ct_string_vector( T_String p, TP... pp )
{
    // can add an "\n" at the end of the {...}
    // but then have to change to 2+sizeof above
    return {p, pp...};
}

// better version of adding an '\n':
template < typename T_String, typename... TP >
constexpr auto
add_newline( T_String p, TP... pp )
-> decltype( make_ct_string_vector(p, pp..., "\n") )
{
    return make_ct_string_vector(p, pp..., "\n");
}

int main()
{
    // ??? (still confused about requirements of constant init, sry)
    static constexpr auto assembled = make_ct_string_vector("hello ", "world");
    enum{ dummy = assembled.length() }; // enforce compile-time evaluation
    std::cout << assembled << std::endl;
    std::cout << add_newline("first line") << "second line" << std::endl;
}

不，为 constexpr 你首先需要一个合法的函数，函数不能粘贴字符串文字参数。

如果你考虑常规函数中的等价表达式，它将分配内存并连接字符串 - 绝对不适合 constexpr。