Плюсы как скриптовый язык (вывод констант во время компеляции)

P.S. Туплю, но ещё маленький вопрос: почему __FILE__ не подставляется?

Потому что он не раскрывает макросы?

пытался сделать что-то с макросами

Этапы разные. После препроцессора никаких макросов не остаётся.

Да, кстати. Принимается любое решение, в порядке убывания:

• Что-то из плюсовых функций, типа std::enable_if, обрущащих компиляцию многословно, но чтобы ответ был (к примеру, static_assert(false, «как-то интерполированная сюда константа, идеально — с сообщением вместе»);
  
• Макросы (пусть даже большие);
  
• Компиляторо-зависимые штуки
  

Я понимаю. Но #error срабатывает во время препроцессинга же.

Г-ди, что за изврат, ну да ладно, отвечу по пунктам 1. https://github.com/mikael-s-persson/templight - тебе в эту сторону копать 2. Макросы не рекурсивны. __FILE__ уже определен как макрос, а значит не может использоваться как часть макроса (точнее препроцессор не будет повторно искать чему равен __FILE__ после того как он один раз подставил его в твой код)

Блин, про нерекурсивность макросов реально забыл после темплейтов. Действительно «туплю».

За ссылку спасибо.

На тебе костыльное решение для данного случая

constexpr void err_getter() {
  std::integral_constant<xy_type, fact<X>().y> err =
      std::integral_constant<xy_type, fact<X + 1>().y>();
}

int main() {
  err_getter();
  return 0;
}

У меня при X = 2 вывело «ошибка: запрошено преобразование от «std::integral_constant<long long unsigned int, 6>» к нескалярному типу «std::integral_constant<long long unsigned int, 2>»»

Извращаюсь дальше, теперь более общий случай

template <class T, T value> struct holder { holder(holder<T, value> &&val); };

constexpr void err_getter() { holder<decltype(fact<3>().y), fact<3>().y>(); }

Выводит:

izvrat/main.cpp:11:74: ошибка: no matching function for call to «holder<long long unsigned int, 6>::holder()»

Вау, круто. Правда, циферка в ответе была только в gcc, в шланге не смогло. Ну и ладно.

Вообще, как я понимаю, происходит тут следующее: делаем структуру, принимающую тип и значение этого типа, у которой только один конструктор перемещения, остальные удалились.

Дальше функция, где конструируем объект с удалённым конструктором по-умолчанию, а gcc конкретизирует тип (вычислив для этого факториал) и падает из-за отсутствия конструктора, в сообщении выводя, что нет конструктора уже у конкретного типа, параметризованного решением.

Я правильно понимаю?

В принципе, такой же (и даже менее многословный) эффект, если в holder просто написать holder() = delete;.

В общем, спасибо!

Да, все правильно понял, и да, будет тот же эффект при удалении конструктора без аргументов

using xy_type = unsigned long long;
template <xy_type x>
struct fact {
  static constexpr xy_type y = x * fact<x-1>().y;
};

template <>
struct fact<0> {
  static constexpr xy_type y = 1;
};

template<int x>
class Boo
{
public:
    Boo() {}
    ~Boo(){}
    ~Boo(){}
};



template<>
class Boo<fact<9>::y>
{
public:
    Boo() {}
    static_assert(false, "This is the answer");
    ~Boo(){}
    ~Boo(){}
};

Выхлоп компилятора: ../AG/main.cpp:282:5: error: static assertion failed: This is the answer static_assert(false, «This is the answer»); ^ ../AG/main.cpp:284:5: error: ‘Boo<362880>::~Boo()’ cannot be overloaded

Довольно таки элегантно, хотя clang при таком решении тоже ответа не выдал, только gcc.

Раз уж олимпиада пошла:

using xy_type = unsigned long long;
template <xy_type x>
struct fact {
  static constexpr xy_type y = x * fact<x-1>().y;
};

template <>
struct fact<0> {
  static constexpr xy_type y = 1;
};

template <int i>
bool deleted() = delete;

static bool n = deleted<fact<3>::y>();

compile-time-print.cpp:15:37: error: use of deleted function ‘bool deleted() [with int i = 6]’
 static bool n = deleted<fact<3>::y>();
                                     ^
compile-time-print.cpp:13:6: note: declared here
 bool deleted() = delete;
      ^

как-то frustum на гитхабе выкладывал свое изобретение про испольование си++ в качестве скриптового языка. Сейчас почему-то выпилил репозиторий((((

Касательно того __FILE__ — тебе нужен _Pragma, как тут (в самом низу абзаца): https://clang.llvm.org/docs/UsersManual.html#controlling-errors-and-warnings

2. Макросы не рекурсивны. __FILE__ уже определен как макрос, а значит не может использоваться как часть макроса (точнее препроцессор не будет повторно искать чему равен __FILE__ после того как он один раз подставил его в твой код)

Какой бред. Нет тут ни рекурсии, ни повторного подстановки. Потому что тут никакой подстановки нет. Всё что после #error — просто строка.

Neither ‘#error’ nor ‘#warning’ macro-expands its argument. Internal whitespace sequences are each replaced with a single space. The line must consist of complete tokens. It is wisest to make the argument of these directives be a single string constant; this avoids problems with apostrophes and the like.

А если шаблонный параметр назвать «answer», то оба компилятора выдают [with answer = N], только gcc ещё и добавляет тип. Выглядит красиво.

Без static constexpr оно работает как и с ним, так что оригинальный код можно не править.

А если сочетать это с ответом от KennyMinigun, то можно решить сразу обе проблемы, привязавшись к clang.

2 KennyMinigun: спасибо за ссылку, попробовал, в clang работает, в gcc пока что нет. Но уже очень хорошо, учитывая верхнюю часть данного комментария.

как-то frustum на гитхабе выкладывал свое изобретение про испольование си++ в качестве скриптового языка. Сейчас почему-то выпилил репозиторий((((

Печально, было бы любопытно посмотреть.

Там была именно тема в том же духе, «пусть компилятор шаблоны выполняет», или попытка запилить интерпретатор?

Там была именно тема в том же духе, «пусть компилятор шаблоны выполняет», или попытка запилить интерпретатор?

там было что-то в стиле «запускаем gcc на лету, линкуем хитрым способом». Что-то типа loadlibrary без loadlibrary. Я даже уже не помню, но решение какое-то интересное, если вы понимаете, кто такой @frustum.

#define STR(X) #X
#define DEFER(M,...) M(__VA_ARGS__)
#define CUSTOM_ERROR_(a) _Pragma(STR(a))
#define CUSTOM_ERROR(...) CUSTOM_ERROR_(GCC error DEFER(STR, __VA_ARGS__))

#ifndef X
CUSTOM_ERROR(usage: c++ --std=c++11 -fmax-errors=1 -DX=<argument> __FILE__ && ./a.out)
#endif // X

compile-time-print.cpp:7:11: error: usage: c++ --std=c++11 -DX=<argument> «compile-time-print.cpp» && ./a.out
 CUSTOM_ERROR(usage: c++ --std=c++11 -fmax-errors=1 -DX=<argument> __FILE__ && ./a.out)
           ^

Я ещё -fmax-errors=1 добавил, так короче вывод.

Зачем нужно наколеночное решение, когда есть нормальный интерпретатор плюсов

Всё хорошо, но не достигнута одна цель: я хочу выводить fact<X>().y во время компиляции, желательно роняя её

Ты хочешь compile time function execution с выводом результата в консоль? Тогда где у тебя constexpr?

Чтобы получить производительность с++ на любой платформе.

К сожалению, не знаком.

Был, выкинул, ибо то что я хотел не работало. Теперь понимаю, как сделать чтобы работало, теперь он есть. Собственно, результаты выше по треду.

Да, круто, так работает.

Итоговый код, работающий везде:

#include <iostream>
#include <type_traits>

#define STR(X) #X
#define DEFER(M,...) M(__VA_ARGS__)
#define CUSTOM_ERROR_(a) _Pragma(STR(a))
#define CUSTOM_ERROR(...) CUSTOM_ERROR_(GCC error DEFER(STR, __VA_ARGS__))

#ifndef X
CUSTOM_ERROR(usage: c++ --std=c++11 -fmax-errors=1 -DX=<argument> __FILE__)
#endif // X

using xy_type = std::enable_if<std::is_integral<decltype(X)>::value,
      decltype(X)>::type;

template <xy_type x>
struct fact {
  xy_type y = x * fact<x-1>().y;
};

template <>
struct fact<0> {
  xy_type y = 1;
};

constexpr xy_type y = fact<X>().y;

template <xy_type answer>
bool deleted() = delete;

static bool n = deleted<y>();

int main() {
  return 0;
}

Ввод организовать легко, через -D, а с выводом придумать не могу. Есть идеи?

#warn

Стоит читать внимательнее. Выводить нужно было результат вычислений, произведённых уже после подстановки макросов.