Implementation of std::common_type

On topic
Metafunctions using specializations
Metafunctions using SFINAE
Implementation of std::common_type

Template specialization
template
class container {
T content{};
};
int main() {
container
cont1;
container cont2;
container
> cont3;
}

Template specialization
template
class container {
T content{};
};
int main() {
container
cont1; //OK container
cont2; //OK
container
> cont3; //OK
}

Template specialization
struct Special {
Special(int){}
Special() = delete;
};

Template specialization
struct Special {
Special(int){}
Special() = delete;
};
template
class container {
T content{};
};
int main() {
container
cont;
}

Template specialization
struct Special {
Special(int){}
Special() = delete;
};
template
class container {
T content{}; //error: use of deleted function ‘container
::container()’
};
int main() {
container
cont;
}

Template specialization
struct Special { /* ... */ };
template
class container { /* ... */ };
template<>
struct container
{
Special content{0};
};
int main() {
container
cont;
}

Template specialization
struct Special { /* ... */ };
template
class container { /* ... */ };
template<>
struct container
{
Special content{0};
};
int main() {
container
cont; //OK
}

std::is_same
template
struct is_same {
static const bool value = false;
};
template T>
struct is_same
{
static const bool value = true;
};

std::is_same
template
struct is_same { /* ... */ };
template
struct is_same T> { /* ... */ };
int main() {
static_assert(is_same
::value);
static_assert(not is_same
::value);
}

std::is_same
template
struct is_same { /* ... */ };
template
struct is_same T> { /* ... */ };
int main() {
static_assert(is_same
::value);
static_assert(not is_same
::value);
}

std::is_same
template
struct is_same { /* ... */ };
template
struct is_same T> { /* ... */ };
int main() {
static_assert(is_same
::value);
static_assert(not is_same
::value);
}

std::remove_reference
template
struct remove_reference {
using type = T;
};
template
struct remove_reference
{
using type = T;
};
template
struct remove_reference
{
using type = T;
};

std::remove_reference
template
struct remove_reference {
using type = T;
};
template
struct remove_reference
{ // If l-reference
using type = T;
};
template
struct remove_reference
{
using type = T;
};

std::remove_reference
template
struct remove_reference {
using type = T;
};
template
struct remove_reference
{ // If l-reference
using type = T;
};
template
struct remove_reference
{ //If r-reference
using type = T;
};

std::remove_reference
template
struct remove_reference { //Any other type (not reference)
using type = T;
};
template
struct remove_reference
{ // If l-reference
using type = T;
};
template
struct remove_reference
{ //If r-reference
using type = T;
};

std::remove_reference
// is_same def
// remove_reference def
int main() {
static_assert(is_same
::type, int>::value);
static_assert(is_same
::type, char**>::value);
static_assert(is_same
::type, bool*>::value);
}

std::remove_reference
//...
template
struct remove_reference
{ // If r-reference
using type = T;
};
//...
int main() {
static_assert(is_same
::type, int>::value);
static_assert(is_same
::type, char**>::value);
static_assert(is_same
::type, bool*>::value);
}

std::remove_reference
//...
template
struct remove_reference
{ // If l-reference
using type = T;
};
//...
int main() {
static_assert(is_same
::type, int>::value);
static_assert(is_same
::type, char**>::value);
static_assert(is_same
::type, bool*>::value);
}

std::remove_reference
//...
template
struct remove_reference { //Any other type (not reference)
using type = T;
};
//...
int main() {
static_assert(is_same
::type, int>::value);
static_assert(is_same
::type, char**>::value);
static_assert(is_same
::type, bool*>::value);
}

std::is_const
template
struct is_const {
static const bool value = false;
};
template
struct is_const T> {
static const bool value = true;
};

std::is_function

std::is_function

std::is_function

std::is_function

std::is_function
template
struct is_function {
static const bool value = not std::is_const
::value;
};
template T>
struct is_function
{
static const bool value = false;
};
template
struct is_function
{
static const bool value = false;
};

std::is_function
template
struct is_function {
static const bool value = not std::is_const
::value;//Only functions and references have this trait
};
template
struct is_function
{
static const bool value = false;
};
template
struct is_function
{
static const bool value = false;
};

std::is_function
template
struct is_function {
static const bool value = not std::is_const
::value;//Only functions and references have this trait
};
template
struct is_function
{
static const bool value = false;
};
template
struct is_function
{
static const bool value = false;
};
using l_ref_t = int&;
using r_ref_t = int&&;
using funct_t = int(char*, bool);

std::is_function
template
struct is_function {
static const bool value = not std::is_const
::value;//Only functions and references have this trait
};
template
struct is_function
{
static const bool value = false;
};
template
struct is_function
{
static const bool value = false;
};
using l_ref_t = int&;
using r_ref_t = int&&;
using funct_t = int(char*, bool);
static_assert(std::is_same_v
);

std::is_function
template
struct is_function {
static const bool value = not std::is_const
::value;//Only functions and references have this trait
};
template
struct is_function
{
static const bool value = false;
};
template
struct is_function
{
static const bool value = false;
};
using l_ref_t = int&;
using r_ref_t = int&&;
using funct_t = int(char*, bool);
static_assert(std::is_same_v
);
static_assert(std::is_same_v
);

std::is_function
template
struct is_function {
static const bool value = not std::is_const
::value;//Only functions and references have this trait
};
template
struct is_function
{
static const bool value = false;
};
template
struct is_function
{
static const bool value = false;
};
using l_ref_t = int&;
using r_ref_t = int&&;
using funct_t = int(char*, bool);
static_assert(std::is_same_v
);
static_assert(std::is_same_v
);
static_assert(std::is_same_v
);

std::is_function
template
struct is_function {
static const bool value = not std::is_const
::value;//Only functions and references have this trait
};
template
struct is_function
{
static const bool value = false;
};
template
struct is_function
{
static const bool value = false;
};
using l_ref_t = int&;
using r_ref_t = int&&;
using funct_t = int(char*, bool);
static_assert(std::is_same_v
);
static_assert(std::is_same_v
);
static_assert(std::is_same_v
);

template
struct is_function {
static const bool value = not std::is_const
::value;//Only functions and references have this trait
};
template
struct is_function
{
static const bool value = false;
};
template
struct is_function
{
static const bool value = false;
};
using l_ref_t = int&;
using r_ref_t = int&&;
using funct_t = int(char*, bool);
static_assert(std::is_same_v
);
static_assert(std::is_same_v
);
static_assert(std::is_same_v
);
template
constexpr bool is_same_v = is_same
::value; //since c++14
std::is_function

std::is_function
template
struct is_function {
static const bool value = not std::is_const
::value;
};
template T>
struct is_function
{ //Filtering out l-references
static const bool value = false;
};
template
struct is_function
{ //Filtering out r-references
static const bool value = false;
};

std::is_array
template
struct is_array {
static const bool value = false;
};
template
struct is_array {
static const bool value = true;
};
template
struct is_array
{
static const bool value = true;
};

std::is_array
template
struct is_array {
static const bool value = false;
};
template
struct is_array { // Specialization for unknown length array type
static const bool value = true;
};
template
struct is_array
{
static const bool value = true;
};

std::is_array
template
struct is_array {
static const bool value = false;
};
template
struct is_array { // Specialization for unknown length array type
static const bool value = true;
};
template
struct is_array
{ // Specialization for length-known array type
static const bool value = true;
};

std::is_array
template
struct is_array { // Primary template for non-array types
static const bool value = false;
};
template
struct is_array
{ // Specialization for unknown length array type
static const bool value = true;
};
template
struct is_array
{ // Specialization for length-known array type
static const bool value = true;
};

std::remove_extent
template
struct remove_extent {
using type = T;
};
template
struct remove_extent {
using type = T;
};
template
struct remove_extent
{
using type = T;
};

std::remove_extent
template
struct remove_extent {
using type = T;
};
template
struct remove_extent {
using type = T;
};
template
struct remove_extent
{
using type = T;
};

std::remove_extent
template
struct remove_extent {
using type = T;
};
template
struct remove_extent {
using type = T;
};
template
struct remove_extent
{
using type = T;
};

std::enable_if
template
struct enable_if;
template
struct enable_if
{
using type = IfTrue;
};
template IfTrue>
struct enable_if
{ };

std::enable_if
template
struct enable_if;
template
struct enable_if
{
using type = IfTrue;
};
template IfTrue>
struct enable_if
{ };

std::enable_if
template
struct enable_if;
template
struct enable_if
{
using type = IfTrue;
};
template IfTrue>
struct enable_if
{ };

std::enable_if
template
struct enable_if;
template
struct enable_if
{
using type = IfTrue;
};
template IfTrue>
struct enable_if
{ };
std::enable_if
::type
std::enable_if
::type
std::enable_if
::type
std::enable_if
::type

std::enable_if
template
struct enable_if;
template
struct enable_if
{
using type = IfTrue;
};
template IfTrue>
struct enable_if
{ };
std::enable_if
::type //OK
std::enable_if
::type //OK
std::enable_if
::type //OK
std::enable_if
::type

std::enable_if
template
struct enable_if;
template
struct enable_if
{
using type = IfTrue;
};
template IfTrue>
struct enable_if
{ };
std::enable_if
::type //OK
std::enable_if
::type //OK
std::enable_if
::type //OK
std::enable_if
::type

std::enable_if
template
struct enable_if;
template
struct enable_if
{
using type = IfTrue;
};
template IfTrue>
struct enable_if
{ };
std::enable_if
::type //OK
std::enable_if
::type //OK
std::enable_if
::type //OK
std::enable_if
::type // Error

std::enable_if
template
struct enable_if;
template
struct enable_if
{
using type = IfTrue;
};
template IfTrue>
struct enable_if
{ };
std::enable_if
::type //OK
std::enable_if
::type //OK
std::enable_if
::type //OK
std::enable_if
::type // Error

std::enable_if
template
struct enable_if;
template
struct enable_if
{
using type = IfTrue;
};
template IfTrue>
struct enable_if
{ };
std::enable_if
::type //OK
std::enable_if
::type //OK
std::enable_if
::type //OK
std::enable_if
::type // Error

std::enable_if
template
struct enable_if;
template
struct enable_if
{
using type = IfTrue;
};
template IfTrue>
struct enable_if
{ };
std::enable_if
::type //OK
std::enable_if
::type //OK
std::enable_if
::type //OK
std::enable_if
::type // Error
‘type’ is not a member of ‘std::enable_if
’

std::enable_if
template
struct enable_if;
template
struct enable_if
{
using type = IfTrue;
};
template IfTrue>
struct enable_if
{ };
std::enable_if
::type //OK
std::enable_if
::type //OK
std::enable_if
::type //OK
std::enable_if
::type // Error
‘type’ is not a member of ‘std::enable_if
’
template
using enable_if_t = typename enable_if
::type; //since c++11

std::enable_if
template
struct enable_if;
template
struct enable_if
{
using type = IfTrue;
};
template IfTrue>
struct enable_if
{ };
std::enable_if
::type //OK
std::enable_if
::type //OK
std::enable_if
::type //OK
std::enable_if
::type // Error
‘type’ is not a member of ‘std::enable_if
’
template
using enable_if_t = typename enable_if
::type; //since c++11

SFINAE (Substitution Fail Is Not An Error)

SFINAE (Substitution Failure Is Not An Error)
template
std::enable_if_t
, void> foo(const T&) { std::cout<<"I'm foo(int)\n";
}
template
std::enable_if_t
, void> foo(const T&) {
std::cout<<"I'm foo(char)\n";
}
int main() {
foo(5);
foo('x');
}

SFINAE (Substitution Failure Is Not An Error)
template
std::enable_if_t
, void> foo(const T&) { std::cout<<"I'm foo(int)\n";
}
template
std::enable_if_t
, void> foo(const T&) { // Substitution Failure (not member ‘type’ in std::enable_if
)
std::cout<<"I'm foo(char)\n";
}
int main() {
foo(5);
foo('x');
}

SFINAE (Substitution Failure Is Not An Error)
template
std::enable_if_t
, void> foo(const T&) { std::cout<<"I'm foo(int)\n";
}
template
std::enable_if_t
, void> foo(const T&) { // Substitution Failure (not member ‘type’ in std::enable_if
)
std::cout<<"I'm foo(char)\n";
}
int main() {
foo(5);
foo('x');
}

SFINAE (Substitution Failure Is Not An Error)
template
std::enable_if_t
, void> foo(const T&) { std::cout<<"I'm foo(int)\n";
}
template
std::enable_if_t
, void> foo(const T&) { // Substitution Failure (not member ‘type’ in std::enable_if
)
std::cout<<"I'm foo(char)\n";
}
int main() {
foo(5);
foo('x');
}

SFINAE (Substitution Failure Is Not An Error)
template
std::enable_if_t
, void> foo(const T&) { //enable_if
. OK
std::cout<<"I'm foo(int)\n";
}
template
std::enable_if_t
, void> foo(const T&) { // Substitution Failure (not member ‘type’ in std::enable_if
)
std::cout<<"I'm foo(char)\n";
}
int main() {
foo(5);
foo('x');
}

SFINAE (Substitution Failure Is Not An Error)
template
std::enable_if_t
, void> foo(const T&) { //enable_if
. OK
std::cout<<"I'm foo(int)\n";
}
template
std::enable_if_t
, void> foo(const T&) { // Substitution Failure (not member ‘type’ in std::enable_if
)
std::cout<<"I'm foo(char)\n";
}
int main() {
foo(5); // I'm foo(int)
foo('x');
}

SFINAE (Substitution Failure Is Not An Error)
template
std::enable_if_t
, void> foo(const T&) {
std::cout<<"I'm foo(int)\n";
}
template
std::enable_if_t
, void> foo(const T&) {
std::cout<<"I'm foo(char)\n";
}
int main() {
foo(5); // I'm foo(int)
foo('x');
}

SFINAE (Substitution Failure Is Not An Error)
template
std::enable_if_t
, void> foo(const T&) { // Substitution Failure (not member ‘type’ in std::enable_if
)
std::cout<<"I'm foo(int)\n";
}
template
std::enable_if_t
, void> foo(const T&) {
std::cout<<"I'm foo(char)\n";
}
int main() {
foo(5); // I'm foo(int)
foo('x');
}

SFINAE (Substitution Failure Is Not An Error)
template
std::enable_if_t
, void> foo(const T&) { // Substitution Failure (not member ‘type’ in std::enable_if
)
std::cout<<"I'm foo(int)\n";
}
template
std::enable_if_t
, void> foo(const T&) {
std::cout<<"I'm foo(char)\n";
}
int main() {
foo(5); // I'm foo(int)
foo('x');
}

SFINAE (Substitution Failure Is Not An Error)
template
std::enable_if_t
, void> foo(const T&) { // Substitution Failure (not member ‘type’ in std::enable_if
)
std::cout<<"I'm foo(int)\n";
}
template
std::enable_if_t
, void> foo(const T&) { // enable_if
. OK.
std::cout<<"I'm foo(char)\n";
}
int main() {
foo(5); // I'm foo(int)
foo('x');
}

SFINAE (Substitution Failure Is Not An Error)
template
std::enable_if_t
, void> foo(const T&) { // Substitution Failure (not member ‘type’ in std::enable_if
)
std::cout<<"I'm foo(int)\n";
}
template
std::enable_if_t
, void> foo(const T&) { // enable_if
. OK.
std::cout<<"I'm foo(char)\n";
}
int main() {
foo(5); // I'm foo(int)
foo('x'); // I'm foo(char)
}

std::void_t
template
using void_t = void;

std::void_t
template
using void_t = void;
static_assert(std::is_same_v
{}.begin())>, void>);

std::is_defaut_constructible

std::is_defaut_constructible
template< class T, class = void, class... Args>
struct is_constructible_impl {
static const bool value = false;
};
template
struct is_constructible_impl
, Args...> {
static const bool value = true;
};

std::is_defaut_constructible
template< class T, class = void, class... Args>
struct is_constructible_impl {
static const bool value = false;
};
template
struct is_constructible_impl
, Args...> {
static const bool value = true;
};

std::is_defaut_constructible
template< class T, class = void, class... Args>
struct is_constructible_impl {
static const bool value = false;
};
template
struct is_constructible_impl
, Args...> {
static const bool value = true;
};

std::is_defaut_constructible
template< class T, class = void, class... Args>
struct is_constructible_impl {
static const bool value = false;
};
template
struct is_constructible_impl
, Args...> {
static const bool value = true;
};
static_assert(is_constructible_impl
, void, int*>::value);

std::is_defaut_constructible
template< class T, class = void, class... Args>
struct is_constructible_impl {
static const bool value = false;
};
template
struct is_constructible_impl
, Args...> {
static const bool value = true;
};
static_assert(is_constructible_impl
, void, int*>::value);
[T = std::unique_ptr
]
[Args... = int*]

std::is_defaut_constructible
template< class T, class = void, class... Args>
struct is_constructible_impl {
static const bool value = false;
};
template
struct is_constructible_impl
, Args...> {
static const bool value = true;
};
static_assert(is_constructible_impl
, void, int*>::value);
[T = std::unique_ptr
]
[Args... = int*] std::unique_ptr
(int*{}) //OK

std::is_defaut_constructible
template< class T, class = void, class... Args>
struct is_constructible_impl {
static const bool value = false;
};
template
struct is_constructible_impl
, Args...> {
static const bool value = true;
};
static_assert(is_constructible_impl
, void, int*>::value);
[T = std::unique_ptr
]
[Args... = int*] std::unique_ptr
(int*{}) //OK

std::is_defaut_constructible
template< class T, class = void, class... Args>
struct is_constructible_impl {
static const bool value = false;
};
template
struct is_constructible_impl
, Args...> {
static const bool value = true;
};
static_assert(is_constructible_impl
, void, int*>::value);
[T = std::unique_ptr
]
[Args... = int*] std::unique_ptr
(int*{})

std::is_defaut_constructible
template< class T, class = void, class... Args>
struct is_constructible_impl {
static const bool value = false;
};
template
struct is_constructible_impl
, Args...> {
static const bool value = true;
};
static_assert(is_constructible_impl
, void, char*>::value);
[T = std::unique_ptr
]
[Args... =char*] std::unique_ptr
(char*{})

std::is_defaut_constructible
template< class T, class = void, class... Args>
struct is_constructible_impl {
static const bool value = false;
};
template
struct is_constructible_impl
, Args...> { //SF
static const bool value = true;
};
static_assert(is_constructible_impl
, void, char*>::value);
[T = std::unique_ptr
]
[Args... =char*] std::unique_ptr
(char*{}) //NOT OK

std::is_defaut_constructible
template< class T, class = void, class... Args>
struct is_constructible_impl {
static const bool value = false; //That’s it!
};
template
struct is_constructible_impl
, Args...> { //SF
static const bool value = true;
};
static_assert(is_constructible_impl
, void, char*>::value);
[T = std::unique_ptr
]
[Args... =char*] std::unique_ptr
(char*{}) //NOT OK

std::is_defaut_constructible
template< class T, class = void, class... Args>
struct is_constructible_impl {
static const bool value = false; //That’s it!
};
template
struct is_constructible_impl
, Args...> { //SF
static const bool value = true;
};
static_assert(is_constructible_impl
, void, char*>::value); //Assertion fail!
[T = std::unique_ptr
]
[Args... =char*] std::unique_ptr
(char*{}) //NOT OK

std::is_defaut_constructible
static_assert(is_constructible_impl
, void, int*>::value);

std::is_defaut_constructible
static_assert(is_constructible_impl
, void, int*>::value);
???

std::is_defaut_constructible
static_assert(is_constructible_impl
, void, int*>::value);
???

std::is_defaut_constructible
static_assert(is_constructible_impl
, void, int*>::value);
???
template
struct is_constructible : is_constructible_impl { };

std::is_defaut_constructible
static_assert(is_constructible_impl
, void, int*>::value);
???
template
struct is_constructible : is_constructible_impl { };
static_assert(is_constructible
, int*>::value);

std::is_defaut_constructible
static_assert(is_constructible_impl
, void, int*>::value);
???
template
struct is_constructible : is_constructible_impl { };
static_assert(is_constructible
, int*>::value);
//Looks like all is good...

std::is_defaut_constructible
template< class T, class = void, class... Args>
struct is_constructible_impl {
static const bool value = false;
};
template
struct is_constructible_impl
, Args...> {
static const bool value = true;
};

std::declval
template
T&& declval() {};

std::declval
template
T&& declval() {};
static_assert(std::is_same_v
()),int&&>);

std::declval
template
T&& declval() {};
static_assert(std::is_same_v
()),int&&>);
static_assert(std::is_same_v
()),char&>);

std::declval
template
T&& declval() {};
static_assert(std::is_same_v
()),int&&>);
static_assert(std::is_same_v
()),char&>);
static_assert(std::is_same_v<
decltype(std::declval
>().begin()),
std::vector
::iterator>
);

std::declval
template
T&& declval() {};
static_assert(std::is_same_v
()),int&&>);
static_assert(std::is_same_v
()),char&>);
static_assert(std::is_same_v<
decltype(std::declval
>().begin()),
std::vector
::iterator>
);

std::is_defaut_constructible
template< class T, class = void, class... Args>
struct is_constructible_impl {
static const bool value = false;
};
template
struct is_constructible_impl
, Args...> {
static const bool value = true;
};

std::is_defaut_constructible
template< class T, class = void, class... Args>
struct is_constructible_impl {
static const bool value = false;
};
template
struct is_constructible_impl
()...))>, Args...> {
static const bool value = true;
};

std::common_type

std::common_type
auto var = true ? bool{} : char{};
What is a type of `var`?

std::common_type
auto var = true ? bool{} : char{}; // bool?
What is a type of `var`?

std::common_type
auto var = true ? bool{} : char{}; // bool?
What is a type of `var`?
bool b{};
std::cin>>b;
auto var2 = b ? bool{} : char{};
What is a type of `var2`?

std::common_type
auto var = true ? bool{} : char{}; // bool?
What is a type of `var`?
bool b{};
std::cin>>b;
auto var2 = b ? bool{} : char{}; // ???
What is a type of `var2`?

std::common_type
auto var = true ? bool{} : char{}; // bool?
What is a type of `var`? // int !
bool b{};
std::cin>>b;
auto var2 = b ? bool{} : char{}; // ???
What is a type of `var2`? // int !

std::common_type
How it works?