Форум 'C/C++' на RSDN

Назначение кода времени компиляции и альтернативы

Sat, 30 May 2026 21:12:58 GMT

Такой вопрос.

Начиналось вроде безобидно — просто шаблоны с ограничениями. Вроде разумно.

Далее, оказалось что с помощью SFINAE и прочих трюков имеем тьюринг-полный ЯП времени компиляции, пусть и не удобный. Оно вроде не задумывалось, но люди юзали.

Далее добавили еще больше ништяков для времени компиляции — и концепты и даже память теперь возможно выделять динамически (с оговорками). Но при этом доступа к системе нет и все выглядит немного как костыль.

И кажется что какой-то архитектурный просчет произошел.

Вот в Rust — сразу макрос имеет доступ к коду, а proc_macro — даже может создавать файлы на диске. Т.е. вообще нет ограничений на удобную кодогенерацию. Можно сделать что угодно, хоть любой сериализатор — по JSON генерить структуры хоть что хочешь.

В C++ как-то не очень ясно, вроде изначально задумывалось как шабоны и проверки времени компиляции. Но сейчас уже нет, уже полноценный ЯП, но без досупа к системе, без доступа даже к коду исходному. И как бы ни в тын ни в ворота.

Кто может объяснить философию и назначение компилтайма именно C++ -версии.

выделение памяти в constexpr

Sat, 30 May 2026 20:50:30 GMT

Я чего-то не понимаю, почему такие разные ошибки для constexpr std::string и constexpr std::vector.

constexpr std::string sabcd = "abc"; // строка может быть труъ constexpr
static_assert(sabcd == "abc");

constexpr auto sabc = []{
    std::string s;
    s.push_back('a');
    s.push_back('b');
    s.push_back('c');
    return s;
};
static_assert(sabc() == "abc"); // лямбда со строкой наружу - тоже может быть труъ
constexpr auto sabcv = sabc(); // а вот её результат уже не труъ
static_assert(sabcv == "abc"); // ОШИБКА

test.cpp:607:21: error: non-constant condition for static assertion
  607 | static_assert(sabcv == "abc");
      |               ~~~~~~^~~~~~~~
test.cpp:607:21:   in ‘constexpr’ expansion of ‘std::operator==<char, char_traits<char>, allocator<char> >(sabcv, ((const char*)"abc"))’
/usr/include/c++/13/bits/basic_string.h:3730:24:   in ‘constexpr’ expansion of ‘(& __lhs)->std::__cxx11::basic_string<char>::size()’
test.cpp:607:21: error: the value of ‘sabcv’ is not usable in a constant expression
test.cpp:606:16: note: ‘sabcv’ used in its own initializer
  606 | constexpr auto sabcv = sabc();
      |                ^~~~~

constexpr auto vabc = []{
    std::vector<char> v;
    v.push_back('a');
    v.push_back('b');
    v.push_back('c');
    return v;
};
static_assert(vabc().size() == 3); // лямбда с вектором - труъ

constexpr auto vabcv = vabc(); // а тут прямо сразу ОШИБКА

/usr/include/c++/13/bits/allocator.h:195:52: error: ‘<lambda()>()’ is not a constant expression because it refers to a result of ‘operator new’
  195 |             return static_cast<_Tp*>(::operator new(__n));
      |                                      ~~~~~~~~~~~~~~^~~~~

Композиции, третий подход к снаряду!

Thu, 28 May 2026 01:44:31 GMT

Когда я внедрил идею с резолвером к себе в ненормальное, то столкнулся с неприятным явлением.
В ненормальном у меня есть списки альтернатив порядка 100 штук, и опрашиваются они порядка 500 раз.
Это приводит к тому, что получается шлемюэлева туча типов

class resolver<A1, typelist<>, F1, ..., F100> : public
class resolver<A1, typelist<F1>, F2, ..., F100> : public
.....
resolver<A1, typelist<F1,...,F50>, F51, F52,..., F100> // допустим, F51 подошла
{
A2 operator()(A1 a, F1,...,F50, F51 f, F52,...,F100) const { return f(a); }
};

class resolver<A2, typelist<>, F1, ..., F100> : // и так далее
.....
class resolver<A500, typelist<>, F1, ..., F100> : // и так далее

Для каждого типа аргумента у нас этажерка из O(Nfuns) пустых, слава богу, структур — но у каждой из них O(Nfuns) параметров!

Компиляция улетает в небеса. (При том, что я переписал резолвер под конкретику ненормального).

Поэтому я вернулся обратно к старым добрым fold expressions.

В обобщённом коде это выглядит так.

// концепт, проверяющий критерий
template<class T, CRITERIA C>
concept fits_criteria = C<T>::value;

template<class F, CRITERIA C, class A>
concept appropriate_alternative = Callable<F> && fits_criteria<std::invoke_result_t<F, A>, C>;
// 1) можно вызвать
// 2) и результат подходит под критерий остановки


// успешный результат поиска функции - это обёртка-ссылка на эту функцию
template<Callable F> struct solution {
    static constexpr bool value = true;
    F f; // ссылка

    // отбрасываем хвост свёртки
    constexpr auto operator || (auto&& g) const { return *this; }

    // вызов аргумента (который априори уже подошёл)
    constexpr decltype(auto) operator()(auto&& a) const {
        return FFWD(f, a);
    }
};

// затравка поиска подходящей функции
// (такой, что C< decltype(f(a)) >)
template<CRITERIA C, class A> struct seed {
    static constexpr bool value = false;

    constexpr auto operator || (auto&& f) const {
        using F = decltype(f);
        if constexpr (appropriate_alternative<F, C, A>)
            return solution<F>{FWD(f)};
        else
            return *this;
    }
};

template<CRITERIA C> struct run_alternatives {
    constexpr auto get_alternative(auto&& a, Callable auto&&... fs) const {
        return ( seed<C, decltype(a)>{} || ... || FWD(fs) );
    }
    constexpr decltype(auto) operator()(auto&& a, Callable auto&&... fs) const
    RETURN_IF_RESOLVED(
        get_alternative(FWD(a), FWD(fs)...) (FWD(a))
    )
};

Тут у нас для каждого аргумента 1 seed, 1 solution и O(Nfuns) операторов ||
— <C,A,F>(seed<C,A>, F) — для всех F, которые ещё не подошли
— <F,G>(solution<F>, G) — где F,G — пара смежных функций, а не все со всеми

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

Композиции, reloaded

Mon, 25 May 2026 15:55:40 GMT

Ветка "как посокращать конструкторы" шибко выросла
https://rsdn.ru/forum/cpp/9091851.flat#9091851

Поэтому хочу предложить вот такое резюме.

Как совсем-совсем идеально передавать аргументы и возвращать результаты двух видов композиций
— список альтернатив (выполнить первую подходящую по совместимости аргумента и критерию результата)
— цепочка (выполнить до отсечки по несовместимости аргумента или критерию результата)

Творчески переработал идеи, выдвинутые товарищем rg45
и сделал такой код.
Он длинный, поэтому см. гитхаб.
Хедер https://github.com/nickolaym/cpp-fun/blob/main/single-files/compose.h
и юниттесты https://github.com/nickolaym/cpp-fun/blob/main/single-files/compose.cpp

Альтернативы ассоциативны,
то есть, допустим, у нас есть функции f, g, h, i, j, k,
и f и g не подошли, а h подошла (и по аргументу, и по результату),
в этом случае мы с любого уровня вложенности вернём h(x) и не станем рассматривать альтернативы позади неё.

seq(f, g,     h, i, j,  k )(x) = h(x)
seq(f, g, seq(h, i, j,  k))(x) = h(x)
seq(f, g, seq(h, i, j), k )(x) = h(x)

Цепочка по-прежнему не обладает свойством ассоциативности,
то есть, допустим, у нас есть функции f, g, h, i, j, k
и мы прерываемся на h из-за того, что тип, возвращаемый из h, не влезает в i.
в этом случае мы вылезем на внешний уровень, а там окажется следующий шаг k, в который может влезть результат.

seq(f, g,     h, i, j,  k )(x) =   h(g(f(x)))
seq(f, g, seq(h, i, j,  k))(x) =   h(g(f(x)))
seq(f, g, seq(h, i, j), k )(x) = k(h(g(f(x))))

Но если ограничить предметную область условием, что критерий "не влезает в следующую функцию" совпадает с предметным "это искомый результат"
(безотносительно того, какую роль в этом играет явный критерий остановки — параметр шаблона),
то ассоциативность выполнится.
То есть, если h(g(f(x))) не влезло в i, то оно не должно влезть и в k.
Либо же, если оно не влезло, то оно же подпало под критерий остановки, — в таком случае оно и этажом выше подпадёт под критерий остановки.

(Договорившись об этом, я вполне могу делать циклы for и while в своих ненормальных алгорифмах! Ура...)

как посокращать конструкторы?

Fri, 22 May 2026 17:02:00 GMT

Продолжаю пилить свои ненормальные алгорифмы https://github.com/nickolaym/nenormal
и захотел минимизировать количество move-конструкторов рантаймовых типов.

Для того, чтобы скрестить рантайм с компайл-таймом, ну, не буду сейчас тут расписывать подробности,
я завёл несколько обёрток с семантикой функции.

Если упрощать, то это выглядит вот так

template<class T, class A> struct augmented_text {
  T text; // чистый компайл-тайм
  A aux; // потенциально рантайм
};
template<class X> concept AugmentedText = ..... remove_cvref_t<X> = augmented_text<T,A> .....;

AugmentedText auto long_recursive_operation(AugmentedText auto&& arg) {
  .....
  return yet_another_long_recursion_operation(
    augmented_text{
      .text = new_text,
      .aux = arg.aux(.....), // вычисляет своё следующее значение
    }
  )
  .....
};

Одна из обёрток — это функция с внешним аккумулятором

template<class F, class A>
struct cumulative_effect {
  F f;
  A a;
  cumulative_effect operator()() const { return cumulative_effect{f, f(a)}; }
  // дополнительные аргументы сейчас не буду подвёрстывать, чтоб не захламлять
  // равно как и изменчивость типа A
};

И вот тут у меня начались проблемки.
Для начала, нужно сделать две версии оператора() — const& и &&.

  cumulative_effect operator()() && {
    A a1 = f(std::move(a)); // сперва вычислили новый аккумулятор
    return cumulative_effect{
      std::move(f), // затем в конструкторе F(F&&) перенесли содержимое f (инвалидировали this->f)
      std::move(a1) // и в конструкторе A(A&&) перенесли содержимое a1
    };
  }

Если просто написать

  return cumulative_effect{std::move(f), f /* инвалидированное */ (std::move(a)) };

получим неопределённое поведение.

Ок. Можно сделать промежуточную функцию

  cumulative_effect rewrite(A&& a1) && { return cumulative_effect{std::move(f), std::move(a)}; }
  cumulative_effect operator()() && { return rewrite(f(std::move(a))); }

но это — размен шила на мыло.

Можно пойти чуть дальше — отложить вызов в конструктор

  cumulative_effect(do_it_tag, cumulative_effect&& old)
    : f(std::move(old.f))
    , a(this->f(std::move(old.a))
  {}
  cumulative_effect operator()() && { return cumulative_effect(do_it_tag{}, std::move(*this));  }

Но добавление конструктора уничтожает возможность агрегатной инициализации.
Это значит, что будет ещё и конструктор

  cumulative_effect(F&& f, A&& a)
    : f(std::move(f))
    , a(std::move(a))
  {}

и значит, в точке создания стартового значения мы получим +1 перемещение функции и +1 перемещение аккумулятора.

Как эту проблему я сейчас решил (ещё не закоммитил).

Просто поменял местами поля в структуре.

template<class A, class F> struct cumulative_effect {
  A a;
  F f;
  // инициализация - агрегатная, 0 промежуточных конструкторов

  cumulative_effect operator()()&& {
    return cumulative_effect{
      f(std::move(a)), // передача a по ссылке, и пусть там f делает что хочет
      std::move(f), // F(F&&)
    };
  }
};

Из оператора, естественно, происходит copy elision, поэтому поля создаются в клиентском объекте.
Итого ровно 1 перемещение f и 0 перемещений нового аккумулятора.

Но это потребовало поставить телегу впереди лошади.
Некрасивенько... Хотя, если так подумать, у меня там весь код в конвеерном стиле arg >> handler >> handler ....

Но может быть, есть и другие способы? Какое-нибудь колдунство C++23, о котором я не подозреваю?

Проверить все поля структуры

Sun, 17 May 2026 15:19:54 GMT

Есть ли в современном C++ способ сделать что-то со всеми полями произвольной структуры (предполагается, что они одного типа), например, проверить на равенство 0?

ненормальные нормальные алгорифмы

Fri, 01 May 2026 20:23:33 GMT

Вот давеча LaptevVV спрашивал про constexpr, так у меня есть кое-чего.
Хочу показать свою заготовку.
Пилю библиотеку Нормальных Алгорифмов Маркова во время компиляции.
https://github.com/nickolaym/nenormal

Понятное дело, что это извращения с кодом, и вообще, когда допилю, (надеюсь, к Дню Программиста), сделаю статью на хабре.
Но сейчас мне просто нужна обратная связь по коду.

Из TODO
— обмазать всё пространствами имён
— унифицировать имена и даже их стиль (там у меня и кемелКейс местами есть)
— переписать доки, нормально осмыслить базис теории категорий, который там просвечивает, но вполсилы
— сделать так, чтобы код одинаково хорошо работал и во время компиляции на уникальных типах, и во время исполнения на однородных
— сделать аугментацию более универсальной (сейчас сигнатура колбеков зафиксирована, и вызываются они строго в определённых местах)
— выкинуть неудачные подходы к снаряду, добавить удачные
— сделать инструменты статического и динамического анализа машины (возможное зацикливание, ошибки, отчёты...)

Пока всего этого нет, — статьи тоже нет )))
Но я обещаю, будет!

Что это и зачем

1) НАМ — абстрактная машина, представляющая последовательность правил поиска-и-замены подстрок. Состояние машины — это строка.
Машина ищет первое подходящее правило и меняет первое вхождение искомой строки на заменную. Если правило не помечено, как финальное, то машина повторяет эту процедуру.
Если ничего не подошло, то состояние не изменилось и, очевидно, не изменится. Такое диагностируемое зацикливание также является финальным состоянием.
Можно сказать, что в конце НАМ-программы неявно стоит правило (""/"",стоп).

2) Во время компиляции использовать динамические контейнеры можно ОЧЕНЬ ограниченно, поэтому сделал всё на чистых константах времени компиляции, для этого нужны зависимые типы.

3) Циклы на полиморфных типах невозможны, поэтому сделано всё на рекурсии. Но рекурсия — ограниченный ресурс компилятора (да и рантайма), поэтому применил лайфхаки по развёртыванию циклов.

Сейчас машина допускает программы неограниченной длины (300 правил как нефиг делать), работающие не более 9000 итераций (глубина 900 помножить на развёртывание цикла на 10 шагов).
Увеличить время работы можно экспоненциально!!! (сделать цикл саморасширяемым), но это в конечном счёте убьёт компилятор.

Пример программы

constexpr auto executor = machine_fun<
  rule_loop<
    rules<
      rule<str{"hello"}, str{"privet"}, regular_state>{},
      rule<str{"world"}, str{"mir"}, regular_state>{}
    >{}
  >{}
>{};
// правила внесены как аргументы шаблона, а не как члены кортежа. всё равно типы зависимые, поэтому члены-данные - избыточны

constexpr auto input_value = str{"hello world!"}; // строка времени компиляции - здесь это константный массив (длина выведена из литерала)
constexpr auto input = ct<input_value>{};         // константа времени компиляции с уникальным типом

constexpr auto result = executor(input); // в constexpr-функцию (operator()) передали истинную константу и получили на выходе истинную константу
constexpr auto result_value = result.value; // сама строка лежит в статической константе

static_assert(result_value == str{"privet mir!"});

В порядке безумия я там даже умножение и деление на марковских алгорифмах забабахал. Последовательность Коллаца.
Работает! Только компилируется около полутора минут.

iota_view::iterator не двунаправленный

Thu, 19 Mar 2026 15:35:31 GMT

всем привет. Такая проблема.

const auto fpsRange = std::ranges::iota_view(1, 32);
auto it = fpsRange.begin();
std::advance(it, 100); // Ok
std::advance(it, -10); // UB

что за фигня? Там же внутри итератора простое число хранится. Почему не разрешить обратный проход?
Или может кто знает, как сделать с минимумом телодвижений двунаправленный. Идея в том, чтобы заработал такой код

const auto testFps = [](int fps) { return fps < 15; };
auto it = std::ranges::lower_bound(fpsRange, true, std::ranges::less{}, [&](int fps){ return !testFps(fps); });

Сейчас он уверенно виснет.

Операции сравнения

Thu, 26 Feb 2026 08:47:46 GMT

Вот завели в С++20 операцию трехстороннего сравнения.
Компилятор при ее реализации в классе генерит на ее основе правильные логические выражения с обычными операция сравнения.

А если трехстороннее сравнение не определено в классе, чего тогда делается ?
Понятно, что равенство и неравенство можно сгенерить (но и тут есть нюансы).
А операция МЕНЬШЕ — генерится ?
И какой из трех вариантов порядка соблюдается ?

Уроки по написанию компилятора на C++

Tue, 24 Feb 2026 10:54:56 GMT

Шесть часов видео для интересующихся основами создания компиляторов.

Юрий Минаев, архитектор компании PVS-Studio, записал 10 практических видеоуроков по написанию компилятора на языке С++. Это компилятор для выдуманного языка, который, впрочем, сильно смахивает на C.

Бесплатные уроки: Давайте создадим язык программирования.

Составить впечатление о том, что вас ждёт, поможет эта видеонарезка.