Концептуальный wish-you-happy-debug
На эти грабли я чуть не наступил (но не наступил!) в рабочем коде, когда захотел прикрутить концепты. Просто задумался о последствиях, проверил на дистиллированном коде, — и да, оно стреляет. Поэтому предлагаю вам в качестве упражнения по ненормальному C++.
Итак. Пусть у нас есть полиморфная (шаблонная, перегруженная, — неважно) функция f (x).
И мы написали концепт, который говорит, что тип может быть аргументом этой функции.
Назовём его fable, то есть, «f-абельный», или, по-русски, «сказка». (Эта сказка будет страшной).
На C++20 это выглядит очень просто и элегантно. (Без requires в виде шаблонной метафункции это тоже делается, но заметно громоздче).
template concept fable = requires(const T& x) { f(x); }; И попробуем применить его на практике.
struct A{};
struct B{};
void f(A);
static_assert(fable);
static_assert(!fable);
const char* kind(auto x) { return "non-fable"; }
// функция с ограничением имеет приоритет
const char* kind(fable auto x) { return "fable"; }
template void test() {
T x;
std::cout << kind(x) << std::endl;
}
int main() {
test(); // fable
test(); // non-fable
} Пока что всё было хорошо… Но вдруг что-то сломалось и пошло не так.
struct C{};
... /* здесь какой-то код */
f(C);
static_assert(fable); // ошибка! fable == false. Сломав голову, что же там неправильно, напишем второй — точно такой же — концепт!
template concept fable2 = requires(const T& x) { f(x); };
// и сделаем проверку рядом с тем злосчастным ассертом
static_assert(fable2);
static_assert(!fable); // мы уже знаем, что он false :( Даже напихаем отладочного вывода в test ()
template void test() {
T x;
bool a = fable;
bool b = fable2;
std::cout << std::boolalpha
<< kind(x) << " "
<< a << " " << b << " " << (a == b ? "ok" : "wtf")
<< std::endl;
}
int main() {
test(); // true true ok
test(); // false false ok
test(); // false true wtf
} Итак, загадка. Ниже приведён почти полный код (можете поиграть с ним на godbolt).
Wish you happy debug!
#include
#include
template concept fable = requires(const T& x) { f(x); };
template concept fable2 = requires(const T& x) { f(x); };
template void test() {
T x;
bool a = fable;
bool b = fable2;
std::cout << std::boolalpha
<< kind(x) << " "
<< a << " " << b << " " << (a == b ? "ok" : "wtf")
<< std::endl;
}
struct A{};
struct B{};
struct C{};
void f(A);
.....
void f(C);
int main() {
test(); // true true ok
test(); // false false ok
test(); // false true wtf
static_assert( fable && fable2);
static_assert(!fable && !fable2);
static_assert(!fable && fable2);
} Что же такое — весьма невинное, на первый взгляд, — притаилось на месте многоточия?
Клянусь, что это ничего похожего на традиционное заподло!
#define true false // wish you happy debugПопробуйте сами придумать минимальный код, прежде чем читать отгадку дальше.
Скрытый текст
Буквально одна строчка.
static_assert(!fable); Я же говорил! Выглядит совершенно невинно. И, что самое удивительное, выглядит справедливо. Ведь сразу после объявления типа C у нас ещё нет функции f©. А значит, и требование для концепта не выполняется.
Зато именно в этом месте мы инстанцировали шаблонную булеву константу fable
Это касается абсолютно всех шаблонов — и классов, и функций, и обычных констант.
В ходе обсуждения на RSDN подсветили смежную проблему. Расскажу о ней тоже в виде страшной сказки-подсказки. Ладно, уже без спойлера, — вы ведь успели поломать голову самостоятельно (или уже посмотрели отгадку)?
Для начала, — чтобы не копипастить концепт, сделаем его параметризуемым. И будем проверять его значения в разных точках кода (опять же, можете проверить на godbolt):
template concept boo = requires(T x) { f(x); };
struct D{};
// ещё нет функции f(D)
static_assert(!boo);
void f(auto) {}
// а теперь она есть!
static_assert( boo);
void f(D) = delete;
// а теперь её снова нет!
static_assert(!boo);
int main() {} Стандарт говорит про концепты:
If, at different points in the program, the satisfaction result is different for identical atomic constraints and template arguments, the program is ill-formed, no diagnostic required.
Очевидно, что в коде выше — одинаковые атомарные ограничения дали разный результат. И вот clang (trunk на момент написания статьи 19.1.0) воспользовался тем, что «no diagnostic required» и скомпилировал как смог.
А gcc — воспользовался тем, что «диагностика не требуется» не значит, что она запрещена. И показал 2 ошибки. Но в первом случае он был прав, а во втором — ошибся! Стоит удалить первый ассерт, и он тоже перестанет выдавать диагностику.
И вот это уже — БУУ!
