C++ Interview Prep

Appearance

Type Traits and Metafunctions ​

Type traits are compile-time functions that operate on types, providing information about type properties or performing type transformations. They are fundamental to template metaprogramming and enable compile-time type decisions.

Standard Library Type Traits ​

The standard library provides type traits from the <type_traits> header.

Boolean Type Traits ​

These traits provide a static constexpr bool value member:

cpp
// Check if two types are identical
std::is_same<int, int>::value;        // true
std::is_same<int, double>::value;     // false

// Check if a type is integral
std::is_integral<int>::value;         // true
std::is_integral<double>::value;      // false

// Check if a type is a pointer
std::is_pointer<int*>::value;         // true
std::is_pointer<int>::value;          // false

Type Transformation Traits ​

These traits provide a using type = ... member:

cpp
// Remove const qualifier
std::remove_const<const int>::type;   // int
std::remove_const<int>::type;         // int (unchanged)

// Decay type (arrays to pointers, functions to function pointers)
std::decay<int[5]>::type;             // int*
std::decay<void(int)>::type;          // void(*)(int)
std::decay<const int>::type;          // int

Conditional Type Selection ​

cpp
// Select type based on condition
std::conditional<true, int, double>::type;   // int
std::conditional<false, int, double>::type;  // double

Writing Custom Type Traits ​

You can use template specializatoins and argument deduction to create your own type traits.

Boolean Type Traits ​

cpp
// Check if type is a pointer
template<typename T>
struct is_pointer {
    static constexpr bool value = false;
};

template<typename T>
struct is_pointer<T*> {
    static constexpr bool value = true;
};

// Usage
is_pointer<int>::value;      // false
is_pointer<int*>::value;     // true

Type Transformation Traits ​

cpp
// Remove const qualifier
template<typename T>
struct remove_const {
    using type = T;
};

template<typename T>
struct remove_const<const T> {
    using type = T;
};

// Usage
remove_const<const int>::type;   // int
remove_const<int>::type;         // int

Type Comparison Traits ​

cpp
// Check if two types are the same
template<typename T, typename U>
struct is_same {
    static constexpr bool value = false;
};

template<typename T>
struct is_same<T, T> {
    static constexpr bool value = true;
};

// Usage
is_same<int, int>::value;        // true
is_same<int, double>::value;     // false

Benefits of Type Traits ​

  1. Compile-Time Type Decisions: Enable different behavior based on type properties
  2. Type Safety: Catch type-related errors at compile time
  3. Performance: No runtime overhead for type checking
  4. Generic Programming: Write code that works with any type satisfying certain properties

Type traits are essential for advanced template metaprogramming and enable powerful compile-time type manipulation.

Implement a metafunction called 'count_if' that counts how many types in a parameter pack satisfy a given type trait. The metafunction should take a type trait as its first template parameter and a variadic parameter pack of types to check. Use template specialization and type traits.

cpp
#include <type_traits>

// TODO: Implement a metafunction called 'count_if' that counts how many types 
// in a parameter pack satisfy a given type trait. The metafunction should take 
// a type trait as its first template parameter and a variadic parameter pack 
// of types to check. Use template specialization and type traits.

// Your implementation here