Объяснить C ++ SFINAE программисту не на C ++

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

Я понятия не имею, есть ли в Python аналогичная функция, и не понимаю, почему программисту, не работающему на C ++, должна быть интересна эта функция. Но если вы хотите узнать больше о шаблонах, лучшая книга по ним - это C ++ Templates: The Complete Guide .

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

SFINAE - это принцип, который компилятор C ++ использует для фильтрации некоторых перегрузок шаблонных функций во время разрешения перегрузки (1)

Когда компилятор разрешает конкретный вызов функции, он рассматривает набор доступных функций и объявления шаблонов функций, чтобы узнать, какой из них будет использоваться. В принципе, для этого есть два механизма. Его можно охарактеризовать как синтаксический. Данные объявления:

template <class T> void f(T);                 //1
template <class T> void f(T*);                //2
template <class T> void f(std::complex<T>);   //3

разрешение f ((int) 1) удалит версии 2 и 3, потому что int не равно complex или T * для некоторых T . Аналогично, f (std :: complex (1)) удалит второй вариант, а f ((int *) & x) удалит третий. Компилятор делает это, пытаясь вывести параметры шаблона из аргументов функции. Если вывод не удается (как в T * против int ), перегрузка сбрасывается.

Причина, по которой мы этого хотим, очевидна - мы можем захотеть сделать несколько разные вещи для разных типов (например, абсолютное значение комплекса вычисляется с помощью x * con (x) и дает реальное значение число, а не комплексное число, которое отличается от вычисления для чисел с плавающей запятой).

Если вы уже занимались декларативным программированием раньше, этот механизм похож на (Haskell):

f Complex x y = ...
f _           = ...

Способ, которым C ++ продвигает это дальше, заключается в том, что вывод может завершиться неудачно, даже если выведенные типы в порядке, но обратная подстановка в другой дают какой-то "бессмысленный" результат (подробнее об этом позже).Например:

template <class T> void f(T t, int(*)[sizeof(T)-sizeof(int)] = 0);

при выводе f ('c') (мы вызываем с одним аргументом, потому что второй аргумент неявный):

1. компилятор сопоставляет T с char , который тривиально дает T как char
2. , компилятор заменяет все T в объявлении как char s . Это дает void f (char t, int (*) [sizeof (char) -sizeof (int)] = 0) .
3. Типом второго аргумента является указатель на массив int [sizeof (char) -sizeof (int)] . Размер этого массива может быть, например. -3 (в зависимости от вашей платформы).
4. Массивы длины <= 0 недопустимы, поэтому компилятор отклоняет перегрузку. Ошибка замены не является ошибкой , компилятор не отклонит программу.

В конце концов, если остается более одной перегрузки функции, компилятор использует сравнение последовательностей преобразования и частичное упорядочение шаблонов, чтобы выбрать тот, который является «лучшим».

Есть и другие такие «бессмысленные» результаты, которые работают подобным образом, они перечислены в списке в стандарте (C ++ 03). В C ++ 0x область SFINAE расширена почти до любой ошибки типа.

Я не буду писать обширный список ошибок SFINAE, но некоторые из наиболее популярных:

• выбор вложенного типа для типа, у которого его нет. например. typename T :: type для T = int или T = A , где A - это класс без вложенного типа с именем типа .
• создание типа массива неположительного размера.В качестве примера см. этот литб-ответ
• , создающий указатель члена на тип, не являющийся классом. например. int C :: * for C = int

Этот механизм не похож ни на что в других известных мне языках программирования. Если бы вы проделали то же самое в Haskell, вы бы использовали более мощные средства защиты, но невозможные в C ++.

1: или частичная специализация шаблонов, когда речь идет о шаблонах классов

Python вам совершенно не поможет. Но вы говорите, что уже в основном знакомы с шаблонами.

Самая фундаментальная конструкция SFINAE - это использование enable_if . Единственная сложность заключается в том, что класс enable_if не инкапсулирует SFINAE, а просто предоставляет его.

template< bool enable >
class enable_if { }; // enable_if contains nothing…

template<>
class enable_if< true > { // … unless argument is true…
public:
    typedef void type; // … in which case there is a dummy definition
};

template< bool b > // if "b" is true,
typename enable_if< b >::type function() {} //the dummy exists: success

template< bool b >
typename enable_if< ! b >::type function() {} // dummy does not exist: failure
    /* But Substitution Failure Is Not An Error!
     So, first definition is used and second, although redundant and
     nonsensical, is quietly ignored. */

int main() {
    function< true >();
}

В SFINAE есть некоторая структура, которая устанавливает условие ошибки (здесь class enable_if ) и ряд параллельных, иначе конфликтующих определений. Некоторая ошибка возникает во всех определениях, кроме одного, которое компилятор выбирает и использует, не жалуясь на другие.

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