C++20 concept Kullanarak std::enable_if'ten Kurtulmak

Giriş 
std::enable_if iki tane metod varsa birini seçmek veya derleme hatası almak için kullanılabilir.

Örnek - SFINAE
Önce concept tanımlarız. Şöyle yaparız.

template<typename T>
concept HasGetInt = requires (T& v) { { v.getInt() } -> std::convertible_to<int>; };

Daha sonra şöyle yaparız. Burada iki tane f() metodundan birisini seçmek için kullanılıyor.

class X {
public:
  int getInt(){
    return 9;
  }
};

class Y {};

template <typename T>
void f(T& v) {
  // only for Y
  std::cout << "Y" << std::endl;
}

template <HasGetInt T>
void f(T& v){
  // only for X
  int i = v.getInt();
  std::cout << "X" << std::endl;
}

int main() {
  X x;
  f(x);

  Y y;
  f(y);
}

Örnek - Derleme Hatası

Şöyle yaparız.

// Taken from https://en.cppreference.com/w/cpp/experimental/constraints
template <typename T>
concept bool Integral = std::is_integral<T>::value;

template <Integral T> // Using concept Integral.
void foo(T i) { /* ... */ } // 'i' has to be integral, or compile time error.

Örnek - Derleme Hatası
Şöyle yaparız.

template <typename T, typename ...U>
concept one_of = (std::is_same_v<T, U> || ...);

template <one_of<int, MyEnum> T>
bool isFunction(T const& aVariable) {
    return true;
}

Kullanmak için şöyle yaparız.

int main() {
    isFunction(MyEnum::A);
    isFunction(3);
    isFunction("my_string"); // error
    return 0;
}

Örnek
Elimizde şöyle bir kod olsun.

template<typename T>
concept LessCompareable=requires(const T& lhs, const T& rhs)
{
      {lhs<rhs}->bool;
};

Kullanmak için şöyle yaparız

template<LessCompareable T>
const T& comp(const T& a , const T& b)
{return a<b?a:b;}

Örnek - Derleme Hatası
Elimizde şöyle bir kod olsunn

template<typename T>
concept MyClassIter = std::is_same_v<
                        MyClass, 
                        typename std::iterator_traits<T>::value_type
                      >;

Şöyle yaparız

template <MyClassIter IteratorType>
void myFunction( IteratorType begin, IteratorType end ) {}