Concat-zwei `const char` string-Literale

Ein wenig constexpr, bestreut mit etwas TMP und ein topping von Indizes gibt mir diese:

#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>{});
}

Live-Beispiel.

Ich würde das Fleisch einige mehr, aber ich muss Los und wollte zu fallen bevor. Sie sollten in der Lage sein zu arbeiten.

InformationsquelleAutor Xeo

• Können Sie nicht zurück die ein (einfaches) array aus einer Funktion.
• Sie können nicht erstellen Sie ein neues const char[n] innerhalb eines constexpr (§7.1.5/3 dcl.constexpr).
• Eine Adresse konstanter Ausdruck muss sich auf ein Objekt der statische Speicher Dauer (§5.19/3 expr.const) - dies verbietet einige tricks mit Objekten der Typen mit ein constexpr ctor Montage der array-Verkettung und Ihre constexpr fct nur die Konvertierung in ein ptr.
• Die Argumente, die übergeben werden, constexpr sind nicht als compile-time Konstanten sein, so können Sie das fct zur Laufzeit zu - dieser verbietet einige tricks mit template-metaprogramming.
• Man kann nicht den einzigen char von einem string-literal übergeben, um eine Funktion als template-Argumente - dies verbietet einige andere template metaprogramming tricks.

So (soweit ich weiß), können Sie nicht bekommen eine constexpr, das ist wieder ein char const* einer neu errichteten string oder ein char const[n]. Hinweis: die meisten dieser Einschränkungen nicht, halten Sie für eine std::array wie bereits von Xeo.

Und selbst wenn Sie zurückkehren konnten einige char const* ein Rückgabewert ist nicht wörtlich, und nur von benachbarten string-Literale sind verkettet. Dies geschieht in der übersetzung phase 6 (§2.2), die würde ich noch nennen einem preprocessing-phase. Constexpr werden später ausgewertet (ref?). (f(x) f(y) wo f ist eine Funktion, die einen syntax-Fehler afaik)

Aber können Sie sich wieder von Ihrem constexpr fct ein Objekt der etwas anderen Art (mit constexpr ctor oder ein Aggregat) enthält Zeichenfolgen eingesetzt werden können/printed in ein basic_ostream.

Edit: hier ist das Beispiel. Es ist schon ein bisschen lange o.O
Hinweis: Sie optimieren können, damit nur um eine zusätzliche "\n" hinzufügen " am Ende einer Zeichenfolge. (Dies ist mehr ein generischer Ansatz, den ich nur aus dem Gedächtnis niedergeschrieben.)

Edit2: Eigentlich kann man nicht wirklich optimieren. Erstellen der arr Daten Mitglied als ein "array of const char_type" mit dem '\n' (anstatt ein array von string-Literale) verwendet einige ausgefallene variadic template-code, dass ist eigentlich ein bisschen länger (aber es funktioniert, siehe Xeo ' s Antwort).

Hinweis: ct_string_vector (der name ist nicht gut) speichert Zeiger, es sollte verwendet werden, nur mit Streichern der statische Speicher Dauer (wie Literale oder globalen Variablen). Der Vorteil ist, dass ein string nicht kopiert werden & erweitert durch template-Mechanismen. Wenn Sie eine constexpr zum speichern des Ergebnisses (wie im Beispiel main), Sie compiler sollte sich beschweren, wenn die übergebenen Parameter sind nicht der statische Speicher Dauer.

#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;
}

InformationsquelleAutor