Строковые выражения

Описание строковых выражений Подробнее...

Концепты
concept	simstr::StrExpr
	Концепт "Строковых выражений".
concept	simstr::StrExprForType
	Концепт строкового выражения заданного типа символов

Классы
struct	simstr::expr_replaced< K >
	Строковое выражение, генерирующее строку с заменой всех вхождений заданной подстроки. Подробнее...
struct	simstr::expr_replace_symbols< K, UseVectorForReplace >
	Тип для строкового выражения, генерирующее строку, в которой заданные символы заменяются на заданные строки. Подробнее...
struct	simstr::strexprjoin< A, B >
	Шаблонный класс для конкатенации двух строковых выражений в одно с помощью operator + Подробнее...
struct	simstr::strexprjoin_c< A, B, last >
	Конкатенация ссылки на строковое выражение и значения строкового выражения. Подробнее...
struct	simstr::empty_expr< K >
	"Пустое" строковое выражение. Подробнее...
struct	simstr::expr_spaces< K, N, S >
	Тип строкового выражения, возвращающего N заданных символов. Подробнее...
struct	simstr::expr_pad< K >
	Тип строкового выражения, возвращающего N заданных символов. Подробнее...
struct	simstr::expr_choice< A, B >
	Строковое выражение условного выбора. Подробнее...
struct	simstr::expr_if< A >
	Строковое выражение условного выбора. Подробнее...
struct	simstr::expr_choice_one_lit< A, N, Compare >
	Строковое выражение условного выбора. Подробнее...
struct	simstr::expr_choice_two_lit< K, N, M >
	Строковое выражение условного выбора. Подробнее...
struct	simstr::expr_stdstr< K, T >
	Тип для использования std::string и std::string_view как источников в строковых выражениях. Подробнее...

Функции
template<StrExpr A, FromIntNumber T>
constexpr strexprjoin_c< A, expr_num< typename A::symb_type, T > >	simstr::operator+ (const A &a, T s)
	Оператор конкатенации для строкового выражения и целого числа.
template<StrExpr A, FromIntNumber T>
constexpr strexprjoin_c< A, expr_num< typename A::symb_type, T >, false >	simstr::operator+ (T s, const A &a)
	Оператор конкатенации для целого числа и строкового выражения.
template<typename K, typename T>
constexpr expr_num< K, T >	simstr::e_num (T t)
	Преобразование целого числа в строковое выражение.
template<StrExpr A, typename R> requires (std::is_same_v<R, double> || std::is_same_v<R, float>)
constexpr auto	simstr::operator+ (const A &a, R s)
	Оператор конкатенации для строкового выражения и вещественного числа (float, double).
template<StrExpr A, typename R> requires (is_one_of_std_char_v<typename A::symb_type> && (std::is_same_v<R, double> || std::is_same_v<R, float>))
constexpr auto	simstr::operator+ (R s, const A &a)
	Оператор конкатенации для вещественного числа (float, double) и строкового выражения.
template<typename K> requires (is_one_of_std_char_v<K>)
constexpr auto	simstr::e_real (double t)
	Преобразование double числа в строковое выражение.
template<bool tail = false, bool skip_empty = false, typename L, typename K = typename const_lit<L>::symb_type, size_t I = const_lit<L>::Count, typename T>
constexpr auto	simstr::e_join (const T &s, L &&d)
	Получить строковое выражение, конкатенирующее строки в контейнере в одну строку с заданным разделителем.
template<typename K, typename T, size_t N = const_lit_for<K, T>::Count, typename X, size_t L = const_lit_for<K, X>::Count> requires (N > 1)
constexpr auto	simstr::e_repl (simple_str< K > w, T &&p, X &&r)
	Получить строковое выражение, генерирующее строку с заменой всех вхождений заданной подстроки.
template<bool UseVector = false, typename K, typename ... Repl> requires (sizeof...(Repl) % 2 == 0)
auto	simstr::e_repl_const_symbols (simple_str< K > src, Repl &&... other)
	Возвращает строковое выражение, генерирующее строку, в которой заданные символы заменены на заданные подстроки.
template<StrExpr A, StrExprForType< typename A::symb_type > B>
constexpr strexprjoin< A, B >	simstr::operator+ (const A &a, const B &b)
	Оператор сложения двух произвольных строковых выражения для одинакового типа символов.
template<typename K, StrExprForType< K > A>
constexpr strexprjoin_c< A, expr_char< K > >	simstr::operator+ (const A &a, K s)
	Оператор сложения строкового выражения и одного символа.
template<typename K>
constexpr expr_char< K >	simstr::e_char (K s)
	Генерирует строку из 1 заданного символа.
template<typename T, size_t N = const_lit<T>::Count>
constexpr expr_literal< typename const_lit< T >::symb_type, static_cast< size_t >(N - 1)>	simstr::e_t (T &&s)
	Преобразует строковый литерал в строковое выражение.
template<StrExpr A, typename K = typename A::symb_type, typename T, size_t N = const_lit_for<K, T>::Count>
constexpr expr_literal_join< false, K,(N - 1), A >	simstr::operator+ (const A &a, T &&s)
	Оператор сложения для строкового выражения и строкового литерала такого же типа символов.
template<StrExpr A, typename K = typename A::symb_type, typename T, size_t N = const_lit_for<K, T>::Count>
constexpr expr_literal_join< true, K,(N - 1), A >	simstr::operator+ (T &&s, const A &a)
	Оператор сложения для строкового литерала такого же типа символов и строкового выражения.
template<size_t N>
constexpr expr_spaces< u8s, N >	simstr::e_spca ()
	Генерирует строку из N char пробелов.
template<size_t N>
constexpr expr_spaces< uws, N >	simstr::e_spcw ()
	Генерирует строку из N wchar_t пробелов.
template<typename K>
constexpr expr_pad< K >	simstr::e_c (size_t l, K s)
	Генерирует строку из l символов s типа K.
template<typename T, typename K = const_lit<T>::symb_type, size_t M = const_lit<T>::Count> requires (M > 0)
constexpr expr_repeat_lit< K, M - 1 >	simstr::e_repeat (T &&s, size_t l)
	Генерирует строку из l строковых констант s типа K.
template<StrExpr A>
constexpr expr_repeat_expr< A >	simstr::e_repeat (const A &s, size_t l)
	Генерирует строку из l строковых выражений s типа K.
template<StrExpr A, StrExprForType< typename A::symb_type > B>
constexpr expr_choice< A, B >	simstr::e_choice (bool c, const A &a, const B &b)
	Создание условного строкового выражения expr_choice.
template<StrExpr A, typename T, size_t N = const_lit_for<typename A::symb_type, T>::Count>
constexpr expr_choice_one_lit< A, N - 1, true >	simstr::e_choice (bool c, const A &a, T &&str)
	Перегрузка e_choice, когда третий аргумент - строковый литерал.
template<StrExpr A, typename T, size_t N = const_lit_for<typename A::symb_type, T>::Count>
constexpr expr_choice_one_lit< A, N - 1, false >	simstr::e_choice (bool c, T &&str, const A &a)
	Перегрузка e_choice, когда второй аргумент - строковый литерал.
template<typename T, typename L, size_t N = const_lit<T>::Count, size_t M = const_lit_for<typename const_lit<T>::symb_type, L>::Count>
constexpr expr_choice_two_lit< typename const_lit< T >::symb_type, N -1, M - 1 >	simstr::e_choice (bool c, T &&str_a, L &&str_b)
	Перегрузка e_choice, когда второй и третий аргумент - строковые литералы.
template<StrExpr A>
constexpr expr_if< A >	simstr::e_if (bool c, const A &a)
	Создание условного строкового выражения expr_if.
template<typename T, size_t N = const_lit<T>::Count>
constexpr auto	simstr::e_if (bool c, T &&str)
	Перегрузка e_if, когда второй аргумент - строковый литерал.
template<StrExprForType< u8s > A>
constexpr strexprjoin_c< A, expr_stdstr< u8s, std::string >, true >	simstr::operator+ (const A &a, const std::string &s)
	Оператор сложения для char строкового выражения и std::string.
template<StrExprForType< u8s > A>
constexpr strexprjoin_c< A, expr_stdstr< u8s, std::string >, false >	simstr::operator+ (const std::string &s, const A &a)
	Оператор сложения для std::string и char строкового выражения.
template<StrExprForType< u8s > A>
constexpr strexprjoin_c< A, expr_stdstr< u8s, std::string_view >, true >	simstr::operator+ (const A &a, const std::string_view &s)
	Оператор сложения для char строкового выражения и std::string_view.
template<StrExprForType< u8s > A>
constexpr strexprjoin_c< A, expr_stdstr< u8s, std::string_view >, false >	simstr::operator+ (const std::string_view &s, const A &a)
	Оператор сложения для std::string_view и char строкового выражения.
template<StrExprForType< uws > A>
constexpr strexprjoin_c< A, expr_stdstr< uws, std::wstring >, true >	simstr::operator+ (const A &a, const std::wstring &s)
	Оператор сложения для wchar_t строкового выражения и std::wstring.
template<StrExprForType< uws > A>
constexpr strexprjoin_c< A, expr_stdstr< uws, std::wstring >, false >	simstr::operator+ (const std::wstring &s, const A &a)
	Оператор сложения для std::wstring и wchar_t строкового выражения.
template<StrExprForType< uws > A>
constexpr strexprjoin_c< A, expr_stdstr< uws, std::wstring_view >, true >	simstr::operator+ (const A &a, const std::wstring_view &s)
	Оператор сложения для wchar_t строкового выражения и std::wstring_view.
template<StrExprForType< uws > A>
constexpr strexprjoin_c< A, expr_stdstr< uws, std::wstring_view >, false >	simstr::operator+ (const std::wstring_view &s, const A &a)
	Оператор сложения для std::wstring_view и wchar_t строкового выражения.

Переменные
constexpr empty_expr< u8s >	simstr::eea {}
	Пустое строковое выражение типа char.
constexpr empty_expr< uws >	simstr::eew {}
	Пустое строковое выражение типа wchar_t.
constexpr empty_expr< u16s >	simstr::eeu {}
	Пустое строковое выражение типа char16_t.
constexpr empty_expr< u32s >	simstr::eeuu {}
	Пустое строковое выражение типа char32_t.

Подробное описание

Описание строковых выражений

Все типы владеющих строк могут инициализироваться с помощью "строковых выражений" (по сути это вариант https://en.wikipedia.org/wiki/Expression_templates для строк). Строковое выражение - это объект произвольного типа, у которого имеются методы:

• size_t length() const: выдает длину строки
• K* place(K*) const: скопировать символы строки в предназначенный буфер и вернуть указатель за последним символом
• typename symb_type: показывает, с каким типом символов он работает.

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

Все строковые объекты библиотеки сами являются строковыми выражениями, которые просто копирует исходную строку. В-основном строковые выражения используются для конкатенации или конвертации строк.

Для всех строковых выражений определен operator +, который из двух операндов создает новое строковое выражение simstr::strexprjoin, объединяющее два строковых выражения, и которое в методе length возвращает сумму length исходных операндов, а в методе place - размещает в буфер результата сначала первый операнд, потом второй. И так как этот оператор сам возвращает строковое выражение, то к нему снова можно применить operator +, формируя цепочку из нескольких строковых выражений, и в итоге "материализовать" последний получившийся объект, который сначала посчитает размер всей общей памяти для конечного результата, а затем разместит вложенные подвыражения в один буфер.

Также operator + определён для строковых выражений и строковых литералов, строковых выражений и чисел (числа конвертируются в десятичное представление), а также вы можете сами добавить желаемые типы строковых выражений. Пример:

stringa text = header + ", count = " + count + ", done";

Существует несколько типов строковых выражений "из коробки", для выполнения различных операций со строками

• expr_spaces< ТипСимвола, КоличествоСимволов, Символ>{}: выдает строку длиной КоличествоСимволов, заполненную заданным символом. Количество символов и символ - константы времени компиляции. Для некоторых случаев есть сокращенная запись:
  • e_spca< КоличествоСимволов>(): строка char пробелов
  • e_spcw< КоличествоСимволов>(): строка w_char пробелов
• expr_pad< ТипСимвола>{КоличествоСимволов, Символ}: выдает строку длинной КоличествоСимволов, заполненную заданным символом. Количество символов и символ могут задаваться в рантайме. Сокращенная запись: e_c (КоличествоСимволов, Символ)
• e_choice (bool Condition, StrExpr1, StrExpr2): если Condition == true, результат будет равен StrExpr1, иначе StrExpr2
• e_num< ТипСимвола>(ЦелоеЧисло): конвертирует число в десятичное представление. Редко используется, так как для строковых выражений и чисел переопределен оператор "+", и число можно просто написать как text + number;
• e_real< ТипСимвола>(ВещественноеЧисло): конвертирует число в десятичное представление. Редко используется, так как для строковых выражений и чисел переопределен оператор "+", и число можно просто написать как text + number;
• e_join< bool ПослеПоследнего = false, bool ПропускатьПустые = false>(контейнер, "Разделитель"): конкатенирует все строки в контейнере, используя разделитель. Если ПослеПоследнего == true, то разделитель добавляется и после последнего элемента контейнера, иначе только между элементами. Если ПропускатьПустые == true, то пустые строки не добавляют разделитель, иначе для каждой пустой строки тоже вставляется разделитель
• e_repl(ИсходнаяСтрока, "Искать", "Заменять"): заменяет в исходной строке вхождения "Искать" на "Заменять". Шаблоны поиска и замены - строковые литералы времени компиляции.
• expr_replaced< ТипСимвола>{ИсходнаяСтрока, Искать, Заменять}: заменяет в исходной строке вхождения Искать на Заменять. Шаблоны поиска и замены - могут быть любыми строковыми объектами в рантайме. и т.д. и т.п.

Функции

e_c()

template<typename K>

expr_pad< K > simstr::e_c ( size_t l, K s )

constexpr

Генерирует строку из l символов s типа K.

Параметры шаблона

K	- тип символа.

Аргументы

l	- количество символов.
s	- символ.

Возвращает

строковое выражение, генерирующее строку из l символов k.

e_char()

template<typename K>

expr_char< K > simstr::e_char ( K s )

constexpr

Генерирует строку из 1 заданного символа.

Аргументы

s

- символ.

Возвращает

строковое выражение для строки из одного символа.

e_choice()

template<StrExpr A, StrExprForType< typename A::symb_type > B>

expr_choice< A, B > simstr::e_choice ( bool c, const A & a, const B & b )

constexpr

Создание условного строкового выражения expr_choice.

Параметры шаблона

A	- Тип выражение при истинности условия, выводится из аргумента.
B	- Тип выражения при ложности условия, выводится из аргумента.

Аргументы

c	- булево условие.
a	- строковое выражение, выполняющееся при c == true.
b	- строковое выражение, выполняющееся при c == false.

Служит для возможности в одном выражении выбирать разные варианты в зависимости от условия. Примеры:

columns_metadata.emplace_back(e_choice(name.is_empty(), "?column?", name) + "::" + metadata_column.type.to_string());

lstringa<512> str = e_choice(!ret_type_resolver_, sql_value::type_name(ret_type_), "any") + " " + name_ + "(";

Иначе такие операции приходилось бы разбивать на несколько модификаций строки или применению временных строк, что не оптимально и снизит производительность. (Это проверяется в бенчмарке "Build Full Func Name")

e_if()

template<StrExpr A>

expr_if< A > simstr::e_if ( bool c, const A & a )

constexpr

Создание условного строкового выражения expr_if.

Параметры шаблона

A	- Тип выражение при истинности условия, выводится из аргумента

Аргументы

c	- булево условие
a	- строковое выражение, выполняющееся при c == true

Служит для возможности в одном выражении генерировать в зависимости от условия либо указанный вариант, либо пустую строку. Примеры:

void sql_func_info::build_full_name() {
    // Временный буфер для результата, возьмём с запасом
    // Temporary buffer for the result, take it with reserve
    lstringa<512> str = e_choice(!ret_type_resolver_, sql_value::type_name(ret_type_), "any") + " " + name_ + "(";
 
    bool add_comma = false;
 
    for (const auto& param : params_) {
        str += e_if(add_comma, ", ") + e_if(param.optional_, "[");
        // Добавляет к str названия допустимых типов
        // Adds the names of valid types to str
        param.allowed_types.to_string(str);
        if (param.optional_) {
            str += "]";
        }
        add_comma = true;
    }
    // Сохраним в stringa
    // Save it in stringa
    full_name_ = str + e_if(unlim_params_, e_if(add_comma, ", ") + "...") + ")";
}

Иначе такие операции приходилось бы разбивать на несколько модификаций строки или применению временных строк, что не оптимально и снизит производительность. (Этот пример проверяется в бенчмарке "Build Full Func Name")

e_join()

template<bool tail = false, bool skip_empty = false, typename L, typename K = typename const_lit<L>::symb_type, size_t I = const_lit<L>::Count, typename T>

auto simstr::e_join ( const T & s, L && d )

inlineconstexpr

Получить строковое выражение, конкатенирующее строки в контейнере в одну строку с заданным разделителем.

Параметры шаблона

tail	- добавлять ли разделитель после последней строки.
skip_empty	- пропускать пустые строки без добавления разделителя.

Аргументы

s	- контейнер со строками, должен поддерживать range for.
d	- разделитель, строковый литерал.

e_num()

template<typename K, typename T>

expr_num< K, T > simstr::e_num ( T t )

constexpr

Преобразование целого числа в строковое выражение.

Параметры шаблона

K	- тип символов.
T	- тип числа, выводится из аргумента.

Аргументы

t

- число.

Возвращает строковое выражение, которое генерирует десятичное представление заданного числа. Может использоваться, когда надо конкатенировть число и строковый литерал.

e_real()

template<typename K>
requires (is_one_of_std_char_v<K>)

auto simstr::e_real ( double t )

inlineconstexpr

Преобразование double числа в строковое выражение.

Аргументы

t

- число.

Возвращает строковое выражение, которое генерирует десятичное представление заданного числа. с помощью sprintf("%.16g"). Может использоваться, когда надо конкатенировть число и строковый литерал.

e_repeat() [1/2]

template<StrExpr A>

expr_repeat_expr< A > simstr::e_repeat ( const A & s, size_t l )

constexpr

Генерирует строку из l строковых выражений s типа K.

Параметры шаблона

K	- тип символа

Аргументы

l	- количество повторов
s	- строковое выражение

Возвращает

строковое выражение, генерирующее строку из l строковых выражений s

e_repeat() [2/2]

template<typename T, typename K = const_lit<T>::symb_type, size_t M = const_lit<T>::Count>
requires (M > 0)

expr_repeat_lit< K, M - 1 > simstr::e_repeat ( T && s, size_t l )

constexpr

Генерирует строку из l строковых констант s типа K.

Параметры шаблона

K	- тип символа

Аргументы

l	- количество повторов
s	- строковый литерал

Возвращает

строковое выражение, генерирующее строку из l строк s

e_repl()

template<typename K, typename T, size_t N = const_lit_for<K, T>::Count, typename X, size_t L = const_lit_for<K, X>::Count>
requires (N > 1)

auto simstr::e_repl ( simple_str< K > w, T && p, X && r )

inlineconstexpr

Получить строковое выражение, генерирующее строку с заменой всех вхождений заданной подстроки.

Параметры шаблона

K	- тип символа, выводится из первого аргумента.

Аргументы

w	- начальная строка.
p	- строковый литерал, искомая подстрока.
r	- строковый литерал, на что заменять.

e_repl_const_symbols()

template<bool UseVector = false, typename K, typename ... Repl>
requires (sizeof...(Repl) % 2 == 0)

auto simstr::e_repl_const_symbols	(	simple_str< K >	src,
		Repl &&...	other )

Возвращает строковое выражение, генерирующее строку, в которой заданные символы заменены на заданные подстроки.

Параметры шаблона

UseVector

- использовать вектор для сохранения результатов поиска символов. Более подробно описано в expr_replace_symbols.

Аргументы

src	- исходная строка.
symbol	- константный символ, который надо заменять.
repl	- строковый литерал, на который заменять символ.
...	symbol, repl - другие символы и строки.

Применяется для генерации замены символов на строки, в случае если все они известны в compile time. Пример:

out += "<div>" + e_repl_const_symbols(text, '\"', "&quot;", '<', "&lt;", '\'', "&#39;", '&', "&amp;") + "</div>";

В принипе, e_repl_const_symbols вполне безопасно возвращать из функции, если исходная строка внешняя по отношению к функции.

auto repl_html_symbols(ssa text) {
    return e_repl_const_symbols(text, '\"', "&quot;", '<', "&lt;", '\'', "&#39;", '&', "&amp;");
}
....
out += "<div>" + repl_html_symbols(content) + "</div>";

e_spca()

template<size_t N>

expr_spaces< u8s, N > simstr::e_spca ( )

constexpr

Генерирует строку из N char пробелов.

Параметры шаблона

N	- Количество пробелов.

Возвращает

строковое выражение для N char пробелов. Пример:

stringa text = e_spca<10>() + text + e_spca<10>();

e_spcw()

template<size_t N>

expr_spaces< uws, N > simstr::e_spcw ( )

constexpr

Генерирует строку из N wchar_t пробелов.

Параметры шаблона

N	- Количество пробелов.

Возвращает

строковое выражение для N wchar_t пробелов.

Пример:

stringw text = e_spcw<10>() + text + e_spcw<10>();

e_t()

template<typename T, size_t N = const_lit<T>::Count>

expr_literal< typename const_lit< T >::symb_type, static_cast< size_t >(N - 1)> simstr::e_t ( T && s )

constexpr

Преобразует строковый литерал в строковое выражение.

Строковые литералы сами по себе не являются строковыми выражениями. Обычно в операциях конкатенации это не вызывает проблем, так как второй операнд уже является строковым выражением, и для него срабатывает сложение с литералом. Но есть ситуации, когда второй операнд тоже не является строковым выражением. Например:

int intVar = calculate();
...
res = "text" + intVar;
...
res = intVar + "text";

В этом случае можно преобразовать литерал в строковое выражение двумя способами:

• дописать _ss: "text"_ss, что преобразует литерал в simple_str_nt: res = "text"_ss + intVar
• применить e_t: e_t("text"), что преобразует литерал в expr_literal: res = e_t("text") + intVar

Во втором способе компилятор может более агрессивно применить оптимизации, связанные с известным при компиляции размером литерала.

Хотя строго говоря, в этих ситуации можно пользоваться и другими способами:

• Добавить операнд - пустое строковое выражение: result = eea + "text" + intVar, result = "text" + eea + intVar
• Преобразовать другой операнд в строковое выражение: result = "text" + e_num<u8s>(intVar).

Все эти способы работают и выдают одинаковый результат. Каким пользоваться - дело вкуса.

operator+() [1/8]

template<StrExpr A, StrExprForType< typename A::symb_type > B>

strexprjoin< A, B > simstr::operator+ ( const A & a, const B & b )

constexpr

Оператор сложения двух произвольных строковых выражения для одинакового типа символов.

Аргументы

a	- первое строковое выражение.
b	- второе строковое выражение.

Возвращает

strexprjoin<A, B>, строковое выражение, генерирующее объединение переданных выражений.

Когда складываются два объекта - строковых выражения, один типа A, другой типа B, мы возвращаем объект типа strexprjoin<A, B>, который содержит ссылки на два этих операнда. А сам объект strexprjoin<A, B> тоже в свою очередь является строковым выражением, и может участвовать в следующих операциях сложения. Таким образом формируется "дерево" из исходных строковых выражений, которое потом за один вызов "материализуется" в конечный результат.

operator+() [2/8]

template<typename K, StrExprForType< K > A>

strexprjoin_c< A, expr_char< K > > simstr::operator+ ( const A & a, K s )

constexpr

Оператор сложения строкового выражения и одного символа.

Возвращает

строковое выражение, объединяющее переданное выражение и символ. Пример:

reply = prompt + '>' + result;

operator+() [3/8]

template<StrExpr A, typename R>
requires (std::is_same_v<R, double> || std::is_same_v<R, float>)

auto simstr::operator+ ( const A & a, R s )

inlineconstexpr

Оператор конкатенации для строкового выражения и вещественного числа (float, double).

Аргументы

a	- строковое выражение.
s	- число.

Число конвертируется в строковое представление через sprintf("%.16g").

operator+() [4/8]

template<StrExpr A, typename K = typename A::symb_type, typename T, size_t N = const_lit_for<K, T>::Count>

expr_literal_join< false, K,(N - 1), A > simstr::operator+ ( const A & a, T && s )

constexpr

Оператор сложения для строкового выражения и строкового литерала такого же типа символов.

Возвращает

Строковое выражение, объединяющее операнды.

operator+() [5/8]

template<StrExpr A, FromIntNumber T>

strexprjoin_c< A, expr_num< typename A::symb_type, T > > simstr::operator+ ( const A & a, T s )

constexpr

Оператор конкатенации для строкового выражения и целого числа.

Аргументы

a	- строковое выражение.
s	- число.

Число конвертируется в десятичное строковое представление.

operator+() [6/8]

template<StrExpr A, typename R>
requires (is_one_of_std_char_v<typename A::symb_type> && (std::is_same_v<R, double> || std::is_same_v<R, float>))

auto simstr::operator+ ( R s, const A & a )

inlineconstexpr

Оператор конкатенации для вещественного числа (float, double) и строкового выражения.

Аргументы

s	- число.
a	- строковое выражение.

Число конвертируется в строковое представление через sprintf("%.16g").

operator+() [7/8]

template<StrExpr A, typename K = typename A::symb_type, typename T, size_t N = const_lit_for<K, T>::Count>

expr_literal_join< true, K,(N - 1), A > simstr::operator+ ( T && s, const A & a )

constexpr

Оператор сложения для строкового литерала такого же типа символов и строкового выражения.

Возвращает

Строковое выражение, объединяющее операнды.

operator+() [8/8]

template<StrExpr A, FromIntNumber T>

strexprjoin_c< A, expr_num< typename A::symb_type, T >, false > simstr::operator+ ( T s, const A & a )

constexpr

Оператор конкатенации для целого числа и строкового выражения.

Аргументы

s	- число.
a	- строковое выражение.

Число конвертируется в десятичное строковое представление.