अवधारणाओं की पहली छाप

सामान्य जानकारी

template<int I> 
concept Even = I % 2 == 0;  

template<typename T>
concept FourByte = sizeof(T)==4;

template<int I>
constexpr bool EvenX = I % 2 == 0; 

template<typename T>
constexpr bool FourByteX = sizeof(T)==4;

bool b1 = Even<2>; 

का उपयोग करते हुए

template<FourByte T>
void foo(T const & t) {}

की आवश्यकता है

अभिव्यक्ति की आवश्यकता है

bool b = requires { 3.14 >> 1; };

template<typename T>
constexpr bool Shiftable = requires(T i) { i>>1; };

bool b1 = Shiftable<int>; // true
bool b2 = Shiftable<double>; // false

template <typename T>
concept Machine = 
  requires(T m) {  //   `m` ,   Machine
	m.start();     //    `m.start()` 
	m.stop();      //   `m.stop()`
};  

अंदर की जाँच प्रकार की आवश्यकता है

requires(T v, int i) {
  { v.f(i) } -> std::convertible_to<int>;
}  

requires(T v, int i) {
  { v.f(i) } -> std::same_as<int>; 
}  

अंदर आवश्यकता होती है

requires { 
  expression;         // expression is valid
  requires predicate; // predicate is true
};

requires(Iter it) {
  //     (   Iter   *  ++)
  *it++;
 
  //    -  
  requires std::convertible_to<decltype(*it++), typename Iter::value_type>;
 
  //    -  
  requires std::is_convertible_v<decltype(*it++), typename Iter::value_type>;
}

requires (T v) { 
  requires (typename T::value_type x) { ++x; }; //     , 
												//     !
};  

requires (T v) { 
  requires requires (typename T::value_type x) { ++x; }; //       "++x"
};  

template <typename T>
  requires requires(T x, T y) { bool(x < y); }
bool equivalent(T const& x, T const& y)
{
  return !(x < y) && !(y < x);
};

खंड की आवश्यकता है

//  require
template<typename Cont>
	requires Sortable<Cont>
void sort(Cont& container);

//   require (  )
template<typename Cont>
void sort(Cont& container) requires Sortable<Cont>;

//    typename
template<Sortable Cont>
void sort(Cont& container)  

template <typename T>
  requires is_standard_layout_v<T> && is_trivial_v<T>
void fun(T v); 
 
int main()
{
  std::string s;
 
  fun(1);  // ok
  fun(s);  // compiler error
}

template <typename T>
  requires is_standard_layout_v<T> && !is_trivial_v<T>
void fun(T v); 

template <typename T>
  requires !is_trivial_v<T>
void fun(T v);	

template <typename T> 
  requires (bool)&T::operator short unsigned int foo();

template <typename T>
  requires (!is_trivial_v<T>)
void fun(T v);

अब आवश्यक सुविधाओं के बारे में क्लॉज़ की आवश्यकता है

template <typename T>
  requires is_trivial_v<typename T::value_type> 
void fun(T v); 

template <typename T>
  requires is_trivial_v<typename T::value_type> 
void fun(T v) { std::cout << "1"; } 
 
template <typename T>
void fun(T v) { std::cout << "2"; } 
 
int main()
{
  fun(1);  // displays: "2"
}

requires is_trivial_v<typename T::value_type> 

!is_trivial_v<typename T::value_type> 

template <typename T>
concept value_type_valid_and_trivial 
  = is_trivial_v<typename T::value_type>; 
 
template <typename T>
  requires (!value_type_valid_and_trivial<T>)
void fun(T v); 

संयोजन और विघटन

template <typename T, typename U>
  requires std::is_trivial_v<typename T::value_type>
		|| std::is_trivial_v<typename U::value_type>
void fun(T v, U u); 

template <typename T, typename U>
  requires (std::is_trivial_v<typename T::value_type>
		 || std::is_trivial_v<typename U::value_type>)
void fun(T v, U u); 

std::optional<int> oi {};
int i {};
fun(i, oi);

निष्कर्ष के तौर पर