Создать C-строку constexpr из конкатенации некоторого строкового литерала и параметра шаблона int

У меня есть класс с параметром шаблона int. При некоторых обстоятельствах я хочу вывести сообщение об ошибке. Это сообщение должно быть объединенной строкой из некоторого фиксированного текста и параметров шаблона. По соображениям производительности я бы хотел избежать создания этой строки во время выполнения каждый раз, когда возникает ошибка, и теоретически и строковый литерал, и параметр шаблона известны во время компиляции. Поэтому я ищу возможность объявить это как constexpr.

Пример кода:

template<int size>
class MyClass
{
    void onError()
    {
        // obviously won't work but expressing the concatenation like
        // it would be done with a std::string for clarification 
        constexpr char errMsg[] = "Error in MyClass of size " + std::to_string (size) + ": Detailed error description\n";

        outputErrorMessage (errMsg);
    }
}

ОТВЕТЫ

Ответ 1

Использование static const позволит вычислить его только один раз (но во время выполнения):

template<int size>
class MyClass
{
    void onError()
    {
        static const std::string = "Error in MyClass of size "
                                  + std::to_string(size)
                                  + ": Detailed error description\n";

        outputErrorMessage(errMsg);
    }
};

Если вы действительно хотите иметь эту строку во время компиляции, вы можете использовать std::array, что-то вроде:

template <std::size_t N>
constexpr std::size_t count_digit() {
    if (N == 0) {
        return 1;   
    }
    std::size_t res = 0;
    for (int i = N; i; i /= 10) {
        ++res;
    }
    return res;
}

template <std::size_t N>
constexpr auto to_char_array()
{
    constexpr auto digit_count = count_digit<N>();
    std::array<char, digit_count> res{};

    auto n = N;
    for (std::size_t i = 0; i != digit_count; ++i) {
        res[digit_count - 1 - i] = static_cast<char>('0' + n % 10);
        n /= 10;
    }
    return res;
}

template <std::size_t N>
constexpr std::array<char, N - 1> to_array(const char (&a)[N])
{
    std::array<char, N - 1> res{};

    for (std::size_t i = 0; i != N - 1; ++i) {
        res[i] = a[i];
    }
    return res;
}

template <std::size_t ...Ns>
constexpr std::array<char, (Ns + ...)> concat(const std::array<char, Ns>&... as)
{
    std::array<char, (Ns + ...)> res{};
    std::size_t i = 0;
    auto l = [&](const auto& a) { for (auto c : a) {res[i++] = c;} };

    (l(as), ...);
    return res;
}

И наконец:

template<int size>
class MyClass
{
public:
    void onError()
    {
        constexpr auto errMsg = concat(to_array("Error in MyClass of size "),
                                  to_char_array<size>(),
                                  to_array(": Detailed error description\n"),
                                  std::array<char, 1>{{0}});

        std::cout << errMsg.data();
    }
};

демонстрация

Ответ 2

Здесь мое решение. Проверено на Годболте:

#include <string_view>
#include <array>
#include <algorithm>

void outputErrorMessage(std::string_view s);

template<int N> struct cint
{
    constexpr int value() const { return N; }
};

struct concat_op {};

template<std::size_t N>
struct fixed_string
{
    constexpr static std::size_t length() { return N; }
    constexpr static std::size_t capacity() { return N + 1; }

    template<std::size_t L, std::size_t R>
    constexpr fixed_string(concat_op, fixed_string<L> l, fixed_string<R> r)
    : fixed_string()
    {
        static_assert(L + R == N);   
        overwrite(0, l.data(), L);
        overwrite(L, r.data(), R);     
    }

    constexpr fixed_string()
    : buffer_ { 0 }
    {
    }

    constexpr fixed_string(const char (&source)[N + 1])
    : fixed_string()
    {
        do_copy(source, buffer_.data());
    }

    static constexpr void do_copy(const char (&source)[N + 1], char* dest)
    {
        for(std::size_t i = 0 ; i < capacity() ; ++i)
            dest[i] = source[i];
    }

    constexpr const char* data() const
    {
        return buffer_.data();
    }

    constexpr const char* data()
    {
        return buffer_.data();
    }

    constexpr void overwrite(std::size_t where, const char* source, std::size_t len)
    {
        auto dest = buffer_.data() + where;
        while(len--)
            *dest++ = *source++;
    }

    operator std::string_view() const
    {
        return { buffer_.data(), N };
    }

    std::array<char, capacity()> buffer_;
};

template<std::size_t N> fixed_string(const char (&)[N]) -> fixed_string<N - 1>;

template<std::size_t L, std::size_t R>
constexpr auto operator+(fixed_string<L> l, fixed_string<R> r) -> fixed_string<L + R>
{
    auto result = fixed_string<L + R>(concat_op(), l , r);
    return result;
};

template<int N> 
constexpr auto to_string()
{
    auto log10 = []
    {
        if constexpr (N < 10)
            return 1;
        else if constexpr(N < 100)
            return 2;
        else if constexpr(N < 1000)
            return 3;
        else 
            return 4; 
            // etc
    };

    constexpr auto len = log10();

    auto result = fixed_string<len>();

    auto pow10 = [](int n, int x)
    {
        if (x == 0)
            return 1;
        else while(x--)
            n *= 10;
        return n;
    };

    auto to_char = [](int n)
    {
        return '0' + char(n);
    };

    int n = N;
    for (int i = 0 ; i < len ; ++i)
    {
        auto pow = pow10(10, i);
        auto digit = to_char(n % 10);
        if (n == 0 && i != 0) digit = ' ';
        result.buffer_[len - i - 1] = digit;
        n /= 10;
    }

    return result;
}

template<int size>
struct MyClass
{
    void onError()
    {
        // obviously won't work but expressing the concatenation like
        // it would be done with a std::string for clarification 
        static const auto errMsg = fixed_string("Error in MyClass of size ") + to_string<size>() + fixed_string(": Detailed error description\n");


        outputErrorMessage (errMsg);
    }
};

int main()
{
    auto x = MyClass<10>();
    x.onError();
}

Результаты в следующем коде:

main:
  sub rsp, 8
  mov edi, 56
  mov esi, OFFSET FLAT:MyClass<10>::onError()::errMsg
  call outputErrorMessage(std::basic_string_view<char, std::char_traits<char> >)
  xor eax, eax
  add rsp, 8
  ret

https://godbolt.org/z/LTgn4F

Обновить:

Звонок на pow10 не нужен. Это мертвый код, который можно удалить.

Ответ 3

К сожалению, ваши возможности ограничены. C++ не разрешает использовать строковые литералы для аргументов шаблона, и, даже если это так, конкатенация букв происходит в препроцессоре до того, как в него войдут шаблоны. Вам понадобится какое-то ужасное посимвольное определение массива и некоторое ручное преобразование int-to-char. Достаточно ужасно, что я не могу заставить себя сделать попытку, и достаточно ужасно, чтобы быть честным, я бы рекомендовал не беспокоить. Я бы сгенерировал его во время выполнения, хотя бы один раз (вы можете сделать errMsg как минимум function- static std::string).