Концепты для отчаявшихся05.07.2016 13:03

Всё началось с того, что мне понадобилось написать функцию, принимающую на себя владение произвольным объектом. Казалось бы, что может быть проще:

template 
void f (T t)
{
    // Завладели экземпляром `t` типа `T`.
    ...

    // Хочешь — переноси.
    g(std::move(t));

    // Не хочешь — не переноси.
    ...
}

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

1. Сообщать об ошибке компиляции при попытке передать lvalue.
2. Избежать лишнего вызова конструктора при создании объекта на стеке.

А вот это уже сложнее сделать.

Поясню.

Требования к входным аргументам

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

template 
void f (T & t);

Такая запись означает, что функция f принимает lvalue-ссылку на объект типа T. При этом заранее не оговариваются cv-квалификаторы. Это может быть и ссылка на константу, и ссылка на неконстанту, и любые другие варианты.

Но ссылкой на rvalue она быть не может: если передать в функцию f ссылку на rvalue, то программа не скомпилируется:

template 
void f (T &) {}

int main ()
{
    auto x = 1;
    f(x); // Всё хорошо, T = int.

    const auto y = 2;
    f(y); // Всё хорошо, T = const int.

    f(6.1); // Ошибка компиляции.
}

Может, есть синтаксис и для обратного случая, когда нужно принимать только rvalue и сообщать об ошибке при передаче lvalue?

К сожалению, нет.

Единственная возможность принять rvalue-ссылку на произвольный объект — это сквозная ссылка (forwarding reference):

template 
void f (T && t);

Но сквозная ссылка может быть ссылкой как на rvalue, так и на lvalue. Следовательно, нужного эффекта мы пока не добились.

Добиться нужного эффекта можно при помощи механизма SFINAE, но он достаточно громоздкий и неудобный как для написания, так и для чтения:

#include 

template ::value>>
void f (T &&) {}

int main ()
{
    auto x = 1;
    f(x); // Ошибка компиляции.

    f(std::move(x)); // Всё хорошо.

    f(6.1); // Всё хорошо.
}

А чего бы на самом деле хотелось?

Хотелось бы вот такой записи:

template 
void f (rvalue t);

Думаю, смысл данной записи выражен достаточно чётко: принять произвольное rvalue.

Первая мысль, которая приходит в голову, — это создать псевдоним типа:

template 
using rvalue = T &&;

Но такая штука, к несчастью, не сработает, потому что подстановка псевдонима происходит до вывода типа шаблона, поэтому в данной ситуации запись rvalue в аргументах функции полностью эквивалентна записи T &&.

Ещё одна идея — по сути, аналогичная, — которая может прийти в голову знатоку шаблонного метапрограммирования — это написать следующий код:

template 
struct rvalue_t
{
    using type = T &&;
};

template 
using rvalue = typename rvalue_t::type;

К структуре rvalue_t можно было бы припилить SFINAE, которое отваливалось бы, если бы T было ссылкой на lvalue.

Но, к сожалению, эта идея также обречена на провал, потому что такая структура «ломает» механизм вывода типов. В результате функцию f вообще будет невозможно вызвать без явного указания аргумента шаблона.

Я очень расстроился и на время забросил эту идею.

Возвращение

В начале этого года, когда появилась новость о том, что комитет не включил концепты в стандарт C++17, я решил вернуться к заброшенной идее.

Немного поразмыслив, я сформулировал «требования»:

1. Должен работать механизм вывода типа.
2. Должна быть возможность натравливать SFINAE-проверки на выводимый тип.

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

Тогда возникает закономерный вопрос: можно ли натравливать SFINAE на псевдонимы типов?

Оказывается, можно. И выглядеть это будет, например, следующим образом:

template ::value>>
using rvalue = T &&;

Наконец-то получаем и требуемый интерфейс, и требуемое поведение:

template 
void f (rvalue) {}

int main ()
{
    auto x = 1;
    f(x); // Ошибка компиляции.

    f(std::move(x)); // Всё хорошо.

    f(6.1); // Всё хорошо.
}

Победа.

Концепты

Внимательный читатель негодует: «Так где же тут концепты-то?».

Но если он не только внимательный, но ещё и сообразительный, то быстро поймёт, что эту идею можно использовать и для «концептов». Например, следующим образом:

template ::value>>
using Integer = I;

template 
void g (Integer t);

int main ()
{
    g(1); // Всё хорошо.
    g(1.2); // Ошибка компиляции.
}

template 
void g (I n);

#define Integer(I) typename I, typename = Integer

template 
void g (I n);

template 
void g (Integer) {}

template 
void g (Floating) {}