Type traits, if constexpr and reading SFINAE code

std::is_integral_v<const int&> is false, std::is_signed_v<double> is true, and std::is_signed_v<char> is true on this Mac but false on Arm Linux. Questions about types have exact answers, not always the expected ones. A type traittype trait: A class template of <type_traits> that the compiler answers about a type, such as std::is_integral<T>, read through its _v variable template, or that produces a new type, such as std::remove_cvref_t<T>. Every answer is known while compiling. asks them while the program compiles, and if constexpr uses the answer to keep one branch of a function template for each type, so that one template can run different code for numbers, strings and containers.

You will read the answers of four traits for eight types, write an if constexpr chain whose order matters, see why a plain if fails to compile where if constexpr succeeds, and read the SFINAESFINAE: Substitution failure is not an error: when putting deduced template arguments into a function template's declaration gives an invalid type or expression, the template quietly leaves the set of candidates. An error inside the body is still an error. code of libraries written before C++20, which uses std::enable_if and std::void_t to drop a template whose declaration does not fit a type, then rewrite it with the concepts of the previous lesson. Every example ran with Apple clang 21 and GCC 16.

A type trait answers a question about a type

The header <type_traits> declares more than a hundred traits: std::is_integral_v<T> is true when T is an integer type, and std::remove_cvref_t<T> is T without const, volatile or a reference. Each trait is a class template, and since C++17 a _v variable template gives its answer directly (paper P0006R0), while since C++14 a _t alias gives the type a transformation produces (paper N3655). Older code spells the same things out as std::is_integral<T>::value and typename std::remove_cv<T>::type. This program asks four questions of eight types:

// The same four questions asked of eight types, all answered by the compiler.
#include <print>
#include <string>
#include <type_traits>

template <typename T>
void row(const char* name) {
    std::println("{:<12} integral={:<5} signed={:<5} floating={:<5} integral after remove_cvref={}", name,
                 std::is_integral_v<T>, std::is_signed_v<T>, std::is_floating_point_v<T>,
                 std::is_integral_v<std::remove_cvref_t<T>>);
}

int main() {
    row<int>("int");
    row<unsigned>("unsigned");
    row<const int&>("const int&");
    row<bool>("bool");
    row<char>("char");
    row<double>("double");
    row<std::string>("std::string");
    row<int*>("int*");
}

from session import run

run("""
clang++ -std=c++23 -Wall -Wextra traits.cpp -o traits && ./traits
g++-16 -std=c++23 -Wall -Wextra traits.cpp -o traits-gcc && ./traits-gcc
""")

$ clang++ -std=c++23 -Wall -Wextra traits.cpp -o traits && ./traits
int          integral=true  signed=true  floating=false integral after remove_cvref=true
unsigned     integral=true  signed=false floating=false integral after remove_cvref=true
const int&   integral=false signed=false floating=false integral after remove_cvref=true
bool         integral=true  signed=false floating=false integral after remove_cvref=true
char         integral=true  signed=true  floating=false integral after remove_cvref=true
double       integral=false signed=true  floating=true  integral after remove_cvref=false
std::string  integral=false signed=false floating=false integral after remove_cvref=false
int*         integral=false signed=false floating=false integral after remove_cvref=false
$ g++-16 -std=c++23 -Wall -Wextra traits.cpp -o traits-gcc && ./traits-gcc
int          integral=true  signed=true  floating=false integral after remove_cvref=true
unsigned     integral=true  signed=false floating=false integral after remove_cvref=true
const int&   integral=false signed=false floating=false integral after remove_cvref=true
bool         integral=true  signed=false floating=false integral after remove_cvref=true
char         integral=true  signed=true  floating=false integral after remove_cvref=true
double       integral=false signed=true  floating=true  integral after remove_cvref=false
std::string  integral=false signed=false floating=false integral after remove_cvref=false
int*         integral=false signed=false floating=false integral after remove_cvref=false

The traits fall into a few families:

Four rows of the program’s output hold the usual surprises:

• const int& is not integral, because a reference type is a category of its own. Strip it first with std::remove_cvref_t, as the last column does; template parameters deduced from forwarding referencesforwarding reference: A reference written auto&&, or T&& in a template whose T is deduced, that binds to anything: it becomes an lvalue reference for a named variable and an rvalue reference for a temporary. More in “C++ auto, decltype and type aliases” are often references, so this comes up constantly.
• double is signed: for arithmetic types the standard defines is_signed_v<T> as T(-1) < T(0), which holds for floating-point types. Test for floating point before you test for signed.
• bool is integral but not signed. Check for it first when it must be treated differently from numbers.
• char is signed, on this Mac. The next section shows why that answer is not universal.

How a trait is built

A trait is an ordinary class template with a value member, usually inherited from std::true_type or std::false_type, plus specialisations for the types whose answer differs, as the specialisation lesson built by hand. A few traits, such as is_union and is_trivially_copyable, cannot be written in plain C++ and use built-in compiler functions instead. Write traits of your own for questions about your own types, but never specialise the standard ones: a program that adds specialisations to the templates of <type_traits> has undefined behaviourundefined behaviour: What a program does when it breaks a rule for which the C++ standard sets no requirements, such as reading past the end of an array. The compiler may assume it never happens, so the result can change with the compiler and the optimisation level. More in “Object lifetime and undefined behaviour in C++”, unless a trait’s description allows it.

Plain char is signed on one target and unsigned on another

The C++ standard lets each platform decide whether plain char is signed, so the answer is implementation-definedimplementation-defined behaviour: Behaviour that the C++ standard leaves to each implementation, which must document its choice, such as sizeof(int). A program that relies on it is valid, but may give other results with another compiler or platform. More in “Object lifetime and undefined behaviour in C++”. Apple’s ARM64 platforms make it signed; the standard ABI for 64-bit Arm, which Linux follows, makes it unsigned. A trait answers for the platform the program is compiled for:

// Is plain char signed? The answer belongs to the platform the program is compiled for.
#include <print>
#include <type_traits>

int main() {
    char c = static_cast<char>(200);
    std::println("std::is_signed_v<char> = {}, char(200) holds {}", std::is_signed_v<char>, static_cast<int>(c));
}

from session import run

# The compiler defines __CHAR_UNSIGNED__ on targets whose char is unsigned.
run("""
clang++ --target=aarch64-linux-gnu -dM -E -x c++ /dev/null | grep CHAR_UNSIGNED || echo "not defined"
clang++ --target=arm64-apple-macos -dM -E -x c++ /dev/null | grep CHAR_UNSIGNED || echo "not defined"
clang++ -std=c++23 char_sign.cpp -o char_sign && ./char_sign
clang++ -std=c++23 -funsigned-char char_sign.cpp -o char_sign && ./char_sign
g++-16 -std=c++23 -funsigned-char char_sign.cpp -o char_sign-gcc && ./char_sign-gcc
""")

$ clang++ --target=aarch64-linux-gnu -dM -E -x c++ /dev/null | grep CHAR_UNSIGNED || echo "not defined"
#define __CHAR_UNSIGNED__ 1
#define __WCHAR_UNSIGNED__ 1
$ clang++ --target=arm64-apple-macos -dM -E -x c++ /dev/null | grep CHAR_UNSIGNED || echo "not defined"
not defined
$ clang++ -std=c++23 char_sign.cpp -o char_sign && ./char_sign
std::is_signed_v<char> = true, char(200) holds -56
$ clang++ -std=c++23 -funsigned-char char_sign.cpp -o char_sign && ./char_sign
std::is_signed_v<char> = false, char(200) holds 200
$ g++-16 -std=c++23 -funsigned-char char_sign.cpp -o char_sign-gcc && ./char_sign-gcc
std::is_signed_v<char> = false, char(200) holds 200

Asked to compile for 64-bit Arm Linux, Clang defines the macro __CHAR_UNSIGNED__; for this Mac it does not. On the Mac std::is_signed_v<char> is true and char(200) holds -56, the same bits read as a signed value. Both compilers accept -funsigned-char, which makes plain char unsigned on any target, and the same program then prints false and 200:

Code that needs a definite range should use signed char, unsigned char or std::uint8_t; a trait can then confirm it with static_assert.

if constexpr keeps one branch for each instantiation

if constexpr is an if whose condition is a compile-time answer. to_text uses four of them to turn a value into text, with one rule for bool, one for numbers, one for strings and one for ranges, whose elements it converts recursively:

// One function template with a different body for each kind of type, chosen by if constexpr.
#include <print>
#include <ranges>
#include <string>
#include <string_view>
#include <type_traits>
#include <vector>

template <typename T>
std::string to_text(const T& value) {
    if constexpr (std::is_same_v<T, bool>) {
        return value ? "yes" : "no";
    } else if constexpr (std::is_arithmetic_v<T>) {
        return std::to_string(value);
    } else if constexpr (std::is_convertible_v<const T&, std::string_view>) {
        return '"' + std::string(std::string_view(value)) + '"';
    } else if constexpr (std::ranges::range<T>) {
        std::string out = "[";
        for (const auto& element : value) {
            if (out.size() > 1) out += ", ";
            out += to_text(element);   // a call for the element type: another instantiation
        }
        return out + "]";
    } else {
        static_assert(false, "to_text: no rule for this type");
    }
}

int main() {
    std::println("{}", to_text(42));
    std::println("{}", to_text(2.5));
    std::println("{}", to_text(true));
    std::println("{}", to_text(std::string("chai")));
    std::println("{}", to_text("samosa"));
    std::println("{}", to_text(std::vector<int>{3, 1, 4}));
    std::println("{}", to_text(std::vector<std::vector<std::string>>{{"a", "b"}, {}, {"c"}}));
}

from session import run

run("""
clang++ -std=c++23 -Wall -Wextra to_text.cpp -o to_text && ./to_text
g++-16 -std=c++23 -Wall -Wextra to_text.cpp -o to_text-gcc && ./to_text-gcc
""")

$ clang++ -std=c++23 -Wall -Wextra to_text.cpp -o to_text && ./to_text
42
2.500000
yes
"chai"
"samosa"
[3, 1, 4]
[["a", "b"], [], ["c"]]
$ g++-16 -std=c++23 -Wall -Wextra to_text.cpp -o to_text-gcc && ./to_text-gcc
42
2.500000
yes
"chai"
"samosa"
[3, 1, 4]
[["a", "b"], [], ["c"]]

Each call instantiates to_text for one type, and in each instantiation the conditions are constants. The compiler keeps the first branch whose condition is true and discards the rest: each discarded statementdiscarded statement: The branch an if constexpr does not take. Inside a template it is not instantiated for that template argument, so it may hold code that would not compile for the current type; in ordinary code it is still checked. is not instantiated, so code that makes no sense for that type, such as std::to_string on a std::vector, is never compiled for it. Step through the seven calls and watch which branch each type keeps:

The vector of vectors of strings uses three instantiations, one per level: both vector levels keep the range branch, and to_text<std::string> keeps the string branch. Three calls of the program, for int, std::string and std::vector<int>, show three instantiations that each keep a different branch:

The order of the branches matters. bool comes before the arithmetic test because bool is an arithmetic type, and std::to_string(true) would give 1. The string test comes before the range test because a std::string is also a range of characters.

A plain if compiles every branch

With an ordinary if, both branches are compiled for every T, even though only one can run:

// The same idea with a plain if: both branches are compiled for every T.
#include <string>
#include <type_traits>

template <typename T>
std::string to_text(const T& value) {
    if (std::is_arithmetic_v<T>) {
        return std::to_string(value);
    } else {
        return '"' + std::string(value) + '"';
    }
}

int main() {
    std::string a = to_text(42);
    std::string b = to_text(std::string("chai"));
}

// to_text with a type it has no rule for: the static_assert(false) in the last branch fires.
#include <string>
#include <type_traits>

struct Point {
    int x, y;
};

template <typename T>
std::string to_text(const T& value) {
    if constexpr (std::is_arithmetic_v<T>) {
        return std::to_string(value);
    } else {
        static_assert(false, "to_text: no rule for this type");
    }
}

int main() {
    std::string a = to_text(42);
    std::string b = to_text(Point{1, 2});
}

from session import run

# A plain if: count the lines and list the errors only
run("""
clang++ -std=c++23 -c plain_if.cpp 2>&1 | awk '/error:/ { e++ } END { print NR " lines, " e (e == 1 ? " error" : " errors") }'
clang++ -std=c++23 -c plain_if.cpp 2>&1 | grep -E "error:|requested here"
g++-16 -std=c++23 -c plain_if.cpp 2>&1 | awk '/error:/ { e++ } END { print NR " lines, " e (e == 1 ? " error" : " errors") }'
# A type with no rule, in C++23 and in C++17 mode
clang++ -std=c++23 -c unsupported.cpp
g++-16 -std=c++17 -c unsupported.cpp
""")

$ clang++ -std=c++23 -c plain_if.cpp 2>&1 | awk '/error:/ { e++ } END { print NR " lines, " e (e == 1 ? " error" : " errors") }'
129 lines, 2 errors
$ clang++ -std=c++23 -c plain_if.cpp 2>&1 | grep -E "error:|requested here"
plain_if.cpp:10:22: error: no matching conversion for functional-style cast from 'const int' to 'std::string' (aka 'basic_string<char>')
plain_if.cpp:15:21: note: in instantiation of function template specialization 'to_text<int>' requested here
plain_if.cpp:8:16: error: no matching function for call to 'to_string'
plain_if.cpp:16:21: note: in instantiation of function template specialization 'to_text<std::string>' requested here
$ g++-16 -std=c++23 -c plain_if.cpp 2>&1 | awk '/error:/ { e++ } END { print NR " lines, " e (e == 1 ? " error" : " errors") }'
230 lines, 3 errors
# A type with no rule, in C++23 and in C++17 mode
$ clang++ -std=c++23 -c unsupported.cpp
unsupported.cpp:14:23: error: static assertion failed: to_text: no rule for this type
   14 |         static_assert(false, "to_text: no rule for this type");
      |                       ^~~~~
unsupported.cpp:20:21: note: in instantiation of function template specialization 'to_text<Point>' requested here
   20 |     std::string b = to_text(Point{1, 2});
      |                     ^
1 error generated.
[exit status 1]
$ g++-16 -std=c++17 -c unsupported.cpp
unsupported.cpp: In instantiation of 'std::string to_text(const T&) [with T = Point; std::string = std::__cxx11::basic_string<char>]':
unsupported.cpp:20:28:   required from here
   20 |     std::string b = to_text(Point{1, 2});
      |                     ~~~~~~~^~~~~~~~~~~~~
unsupported.cpp:14:23: error: static assertion failed: to_text: no rule for this type
   14 |         static_assert(false, "to_text: no rule for this type");
      |                       ^~~~~
  • 'false' evaluates to false
[exit status 1]

to_text<int> fails in the string branch and to_text<std::string> in the number branch: two errors from Clang in 129 lines, three from GCC in 230. Step through what each instantiation asks of its two branches, then the safe ending:

The second file shows that safe ending for an if constexpr chain. Its last branch holds static_assert(false, "…"), which fires only when a type reaches it, here Point, with your own message.

Discarding happens only inside a template, where the condition depends on a template parameter. In an ordinary function, if constexpr (sizeof(int) == 2) never runs its branch, but the branch is still checked like any other code, so a call to a function that was never declared is an error there.

SFINAE quietly drops a template whose declaration fails

Before C++20 there was no way to write a constraint, so libraries used a rule of template argument deduction instead. When the compiler substitutes the deduced types into a function template’s declaration and the result is an invalid type or expression, deduction fails and the template quietly leaves the set of candidates. The standard limits this to the “immediate context”, the declaration itself: an error inside the body is still an error. That rule is SFINAE, “substitution failure is not an error”.

std::enable_if_t<Condition, T> names the type T when Condition is true and names nothing at all when it is false. Put it in a declaration and the declaration becomes invalid exactly when the condition fails:

// C++11 to C++17: enable_if removes the template from overload resolution unless T is an integer type.
#include <type_traits>

template <typename T, std::enable_if_t<std::is_integral_v<T>, int> = 0>
T gcd_of(T a, T b) {
    while (b != 0) {
        T r = a % b;
        a = b;
        b = r;
    }
    return a;
}

int main() {
    int g = gcd_of(84, 36);
    double h = gcd_of(8.4, 3.6);
    return g + static_cast<int>(h);
}

// C++20: the same rule as a concept.
#include <concepts>

template <std::integral T>
T gcd_of(T a, T b) {
    while (b != 0) {
        T r = a % b;
        a = b;
        b = r;
    }
    return a;
}

int main() {
    int g = gcd_of(84, 36);
    double h = gcd_of(8.4, 3.6);
    return g + static_cast<int>(h);
}

from session import run

run("""
clang++ -std=c++23 -c gcd_enable_if.cpp
clang++ -std=c++23 -c gcd_concept.cpp
g++-16 -std=c++23 -c gcd_enable_if.cpp
g++-16 -std=c++23 -c gcd_concept.cpp
""")

$ clang++ -std=c++23 -c gcd_enable_if.cpp
gcd_enable_if.cpp:16:16: error: no matching function for call to 'gcd_of'
   16 |     double h = gcd_of(8.4, 3.6);
      |                ^~~~~~
gcd_enable_if.cpp:5:3: note: candidate template ignored: requirement 'std::is_integral_v<double>' was not satisfied [with T = double]
    5 | T gcd_of(T a, T b) {
      |   ^
1 error generated.
[exit status 1]
$ clang++ -std=c++23 -c gcd_concept.cpp
gcd_concept.cpp:16:16: error: no matching function for call to 'gcd_of'
   16 |     double h = gcd_of(8.4, 3.6);
      |                ^~~~~~
gcd_concept.cpp:5:3: note: candidate template ignored: constraints not satisfied [with T = double]
    5 | T gcd_of(T a, T b) {
      |   ^
gcd_concept.cpp:4:11: note: because 'double' does not satisfy 'integral'
    4 | template <std::integral T>
      |           ^
/Library/Developer/CommandLineTools/SDKs/MacOSX.sdk/usr/include/c++/v1/__concepts/arithmetic.h:28:20: note: because 'is_integral_v<double>' evaluated to false
   28 | concept integral = is_integral_v<_Tp>;
      |                    ^
1 error generated.
[exit status 1]
$ g++-16 -std=c++23 -c gcd_enable_if.cpp
gcd_enable_if.cpp: In function 'int main()':
gcd_enable_if.cpp:16:22: error: no matching function for call to 'gcd_of(double, double)'
   16 |     double h = gcd_of(8.4, 3.6);
      |                ~~~~~~^~~~~~~~~~
  • there is 1 candidate
    • candidate 1: 'template<class T, typename std::enable_if<is_integral_v<T>, int>::type <anonymous> > T gcd_of(T, T)'
      gcd_enable_if.cpp:5:3:
          5 | T gcd_of(T a, T b) {
            |   ^~~~~~
      • template argument deduction/substitution failed:
        • error: no type named 'type' in 'struct std::enable_if<false, int>'
          gcd_enable_if.cpp:4:70:
              4 | template <typename T, std::enable_if_t<std::is_integral_v<T>, int> = 0>
                |                                                                      ^
[exit status 1]
$ g++-16 -std=c++23 -c gcd_concept.cpp
gcd_concept.cpp: In function 'int main()':
gcd_concept.cpp:16:22: error: no matching function for call to 'gcd_of(double, double)'
   16 |     double h = gcd_of(8.4, 3.6);
      |                ~~~~~~^~~~~~~~~~
  • there is 1 candidate
    • candidate 1: 'template<class T>  requires  integral<T> T gcd_of(T, T)'
      gcd_concept.cpp:5:3:
          5 | T gcd_of(T a, T b) {
            |   ^~~~~~
      • template argument deduction/substitution failed:
        • constraints not satisfied
In file included from gcd_concept.cpp:2:
          • /opt/homebrew/Cellar/gcc/16.2.0/include/c++/16/concepts: In substitution of 'template<class T>  requires  integral<T> T gcd_of(T, T) [with T = double]':
          • required from here
            gcd_concept.cpp:16:22:   
               16 |     double h = gcd_of(8.4, 3.6);
                  |                ~~~~~~^~~~~~~~~~
          • required for the satisfaction of 'integral<T>' [with T = double]
            /opt/homebrew/Cellar/gcc/16.2.0/include/c++/16/concepts:109:13:   
              109 |     concept integral = is_integral_v<_Tp>;
                  |             ^~~~~~~~
          • the expression 'is_integral_v<_Tp> [with _Tp = double]' evaluated to 'false'
            /opt/homebrew/Cellar/gcc/16.2.0/include/c++/16/concepts:109:24:
              109 |     concept integral = is_integral_v<_Tp>;
                  |                        ^~~~~~~~~~~~~~~~~~
[exit status 1]

Both versions reject gcd_of(8.4, 3.6) at the call. Step through what the compiler did with the enable_if version, from the call to the candidate that disappears:

Clang recognises the enable_if pattern and reports requirement 'std::is_integral_v<double>' was not satisfied, which is as clear as its concept message. GCC 16 reports the mechanism instead of the reason: no type named 'type' in 'struct std::enable_if<false, int>'. For the concept, both compilers name integral and the trait inside it. The concept also reads better in the declaration and takes part in subsumption; enable_if conditions never make one overload more specialised than another.

enable_if hides in four places, and you should recognise all of them:

• the return type, as std::enable_if_t<cond, T> f(T);
• a default template argument, typename = std::enable_if_t<cond>;
• a non-type template parameter, std::enable_if_t<cond, int> = 0, as in gcd_enable_if.cpp;
• an extra function parameter with a default value.

Two templates that differ only in a default argument clash

The default-argument form has a trap. Default template arguments are not part of a template’s signature, so two templates that differ only in them are the same template declared twice:

// Two "overloads" that differ only in a default template argument declare the same template twice.
#include <string>
#include <type_traits>

template <typename T, typename = std::enable_if_t<std::is_integral_v<T>>>
std::string kind(T) { return "integer"; }

template <typename T, typename = std::enable_if_t<std::is_floating_point_v<T>>>
std::string kind(T) { return "floating point"; }

int main() {
    return static_cast<int>(kind(1).size() + kind(1.0).size());
}

// The C++11 to C++17 fix: put enable_if in the type of a non-type parameter, which is part of the signature.
#include <print>
#include <string>
#include <type_traits>

template <typename T, std::enable_if_t<std::is_integral_v<T>, int> = 0>
std::string kind(T) { return "integer"; }

template <typename T, std::enable_if_t<std::is_floating_point_v<T>, int> = 0>
std::string kind(T) { return "floating point"; }

int main() {
    std::println("{} and {}", kind(1), kind(1.0));
}

from session import run

run("""
clang++ -std=c++23 -c redecl.cpp 2>&1 | grep -E "error:"
g++-16 -std=c++23 -c redecl.cpp 2>&1 | grep -E "error:"
clang++ -std=c++23 -Wall -Wextra redecl_fixed.cpp -o redecl_fixed && ./redecl_fixed
g++-16 -std=c++23 -Wall -Wextra redecl_fixed.cpp -o redecl_fixed-gcc && ./redecl_fixed-gcc
""")

$ clang++ -std=c++23 -c redecl.cpp 2>&1 | grep -E "error:"
redecl.cpp:8:34: error: template parameter redefines default argument
redecl.cpp:9:13: error: redefinition of 'kind'
redecl.cpp:12:29: error: no matching function for call to 'kind'
redecl.cpp:12:46: error: no matching function for call to 'kind'
$ g++-16 -std=c++23 -c redecl.cpp 2>&1 | grep -E "error:"
redecl.cpp:9:13: error: redefinition of 'template<class T, class> std::string kind(T)'
redecl.cpp:12:50: error: no matching function for call to 'kind(double)'
        • error: no type named 'type' in 'struct std::enable_if<false, void>'
$ clang++ -std=c++23 -Wall -Wextra redecl_fixed.cpp -o redecl_fixed && ./redecl_fixed
integer and floating point
$ g++-16 -std=c++23 -Wall -Wextra redecl_fixed.cpp -o redecl_fixed-gcc && ./redecl_fixed-gcc
integer and floating point

Both compilers report a redefinition of kind, and Clang adds template parameter redefines default argument: it reads the second declaration as the first template again, with a second default for a parameter that already has one. The two conditions are never compared, because by then there is only one template. Step through what the compiler compares, before and after the fix:

The pre-C++20 fix moves the condition into the type of a non-type parameter, std::enable_if_t<cond, int> = 0, which is part of the signature, so the two templates differ. In C++20, kind(std::integral auto) and kind(std::floating_point auto) say it without either trick.

The detection idiom asks whether an expression compiles

The other common idiom answers “does this type have a size() member?”. std::void_t<…> is void for any list of valid types (paper N3911), so a partial specialisationpartial specialisation: A definition of a class or variable template for a family of argument lists, written as a pattern that keeps parameters to deduce, such as template <typename T> struct TypeName<T*>, which matches every pointer type. More in “C++ template specialisation and overloading” that names an expression inside it matches only when the expression is valid. This is the detection idiomdetection idiom: The C++17 way to ask whether an expression compiles for a type: a primary template that answers false, and a partial specialisation with std::void_t<decltype(expression)> that matches, and answers true, only when the expression is valid.:

// Does T have a size() member? Once with the C++17 detection idiom, once with a C++20 concept.
#include <list>
#include <print>
#include <string>
#include <type_traits>
#include <utility>
#include <vector>

// The partial specialisation is chosen only when the expression inside void_t is valid for T.
template <typename T, typename = void>
struct has_size : std::false_type {};

template <typename T>
struct has_size<T, std::void_t<decltype(std::declval<const T&>().size())>> : std::true_type {};

// The same question as a concept.
template <typename T>
concept HasSize = requires(const T& t) { t.size(); };

struct Bag {
    int size() const { return 3; }
};
struct Box {};

template <typename T>
void row(const char* name) {
    std::println("{:<18} has_size={:<5} HasSize={}", name, has_size<T>::value, HasSize<T>);
}

int main() {
    row<std::vector<int>>("std::vector<int>");
    row<std::list<int>>("std::list<int>");
    row<std::string>("std::string");
    row<int[4]>("int[4]");
    row<Bag>("Bag");
    row<Box>("Box");
}

from session import run

run("""
clang++ -std=c++23 -Wall -Wextra detect.cpp -o detect && ./detect
g++-16 -std=c++23 -Wall -Wextra detect.cpp -o detect-gcc && ./detect-gcc
""")

$ clang++ -std=c++23 -Wall -Wextra detect.cpp -o detect && ./detect
std::vector<int>   has_size=true  HasSize=true
std::list<int>     has_size=true  HasSize=true
std::string        has_size=true  HasSize=true
int[4]             has_size=false HasSize=false
Bag                has_size=true  HasSize=true
Box                has_size=false HasSize=false
$ g++-16 -std=c++23 -Wall -Wextra detect.cpp -o detect-gcc && ./detect-gcc
std::vector<int>   has_size=true  HasSize=true
std::list<int>     has_size=true  HasSize=true
std::string        has_size=true  HasSize=true
int[4]             has_size=false HasSize=false
Bag                has_size=true  HasSize=true
Box                has_size=false HasSize=false

has_size<T> starts from the primary templateprimary template: The general definition of a template, such as template <typename T> struct TypeName, that its specialisations refine. It is used for every argument list that no full or partial specialisation matches. More in “C++ template specialisation and overloading”, std::false_type, whose second parameter defaults to void. For has_size<Bag> the compiler also tries the specialisation; substituting Bag into decltype(std::declval<const Bag&>().size()) succeeds, void_t of it is void, the same as the default, so the specialisation matches and the answer is true. Step through Bag, Box and int[4], then the three standard containers:

For Box the substitution fails, SFINAE discards the specialisation and the primary template answers false. std::declval<const T&>() produces an expression of type const T& without creating an object, which is allowed only in unevaluated places such as decltype. The concept HasSize asks the same question in one line, and the two agree for all six types.

Every SFINAE idiom has a concept that says it directly

Old code mixes the spellings of several standards, and each one dates the code that uses it: ::type and ::value need only C++11, a _t alias needs C++14, and a _v variable or std::void_t needs C++17. Knowing which standard an idiom belongs to tells you what a library still supports, and which concept can replace it. Walk through where each idiom of this lesson comes from:

Rewrite one overload set at a time and keep its behaviour. A condition that removed a template in SFINAE removes it as a constraint too, but two things change: overlapping concepts now order the overloads by subsumption, where enable_if needed mutually exclusive conditions, and error messages name the concept. A library that must still build as C++17 keeps its enable_if; it can test __cpp_concepts and offer both.

Practise: a describe function for any type

describe.h declares describe<T>(), which should return a short description of T such as "unsigned integer, 4 bytes". Its comment lists seven cases in the order to test them, and bytes(n) writes “1 byte” or “4 bytes” for you:

// Starter code for "Your turn": write describe<T>().
#pragma once
#include <cstddef>
#include <string>
#include <type_traits>

// "1 byte" or "4 bytes": the size part of every description.
inline std::string bytes(std::size_t n) {
    return std::to_string(n) + (n == 1 ? " byte" : " bytes");
}

// A short description of T, such as "unsigned integer, 4 bytes". The cases, in the order to test them:
//   bool                                    "bool, 1 byte"
//   signed or unsigned integer types        "signed integer, 4 bytes", "unsigned integer, 2 bytes"
//   floating-point types                    "floating point, 8 bytes"
//   pointers                                "pointer, 8 bytes"
//   enumerations                            "enum, 1 byte"
//   classes                                 "class, 24 bytes"
//   anything else                           "other, 16 bytes"
// References and const describe the type they refer to: describe<const int&>() is "signed integer, 4 bytes".
template <typename T>
std::string describe() {
    // TODO: one if constexpr branch per case, on std::remove_cvref_t<T>.
    return "other, " + bytes(sizeof(T));
}

// Sample tests for describe.h. Build: clang++ -std=c++23 -Wall -Wextra describe_tests.cpp -o describe_tests
#include <cstdint>
#include <print>
#include <string>
#include "describe.h"

enum class Colour : std::uint8_t { red, green, blue };
struct Pixel {
    std::uint8_t r, g, b;
};

int checks = 0;
int failures = 0;

void check(const std::string& got, const std::string& want) {
    ++checks;
    if (got != want) {
        ++failures;
        std::println("FAIL got \"{}\", want \"{}\"", got, want);
    }
}

int main() {
    check(describe<int>(), "signed integer, 4 bytes");
    check(describe<unsigned short>(), "unsigned integer, 2 bytes");
    check(describe<signed char>(), "signed integer, 1 byte");
    check(describe<bool>(), "bool, 1 byte");
    check(describe<double>(), "floating point, 8 bytes");
    check(describe<float>(), "floating point, 4 bytes");
    check(describe<const long long&>(), "signed integer, 8 bytes");
    check(describe<int*>(), "pointer, " + bytes(sizeof(int*)));
    check(describe<Colour>(), "enum, 1 byte");
    check(describe<Pixel>(), "class, 3 bytes");
    check(describe<std::string>(), "class, " + bytes(sizeof(std::string)));
    std::println("{} of {} checks passed", checks - failures, checks);
    return failures == 0 ? 0 : 1;
}

from session import run

# The sample tests, built against the starter code before the TODO is done.
run("""
clang++ -std=c++23 -Wall -Wextra describe_tests.cpp -o describe_tests && ./describe_tests
g++-16 -std=c++23 -Wall -Wextra describe_tests.cpp -o describe_tests-gcc && ./describe_tests-gcc
""")

$ clang++ -std=c++23 -Wall -Wextra describe_tests.cpp -o describe_tests && ./describe_tests
FAIL got "other, 4 bytes", want "signed integer, 4 bytes"
FAIL got "other, 2 bytes", want "unsigned integer, 2 bytes"
FAIL got "other, 1 byte", want "signed integer, 1 byte"
FAIL got "other, 1 byte", want "bool, 1 byte"
FAIL got "other, 8 bytes", want "floating point, 8 bytes"
FAIL got "other, 4 bytes", want "floating point, 4 bytes"
FAIL got "other, 8 bytes", want "signed integer, 8 bytes"
FAIL got "other, 8 bytes", want "pointer, 8 bytes"
FAIL got "other, 1 byte", want "enum, 1 byte"
FAIL got "other, 3 bytes", want "class, 3 bytes"
FAIL got "other, 24 bytes", want "class, 24 bytes"
0 of 11 checks passed
[exit status 1]
$ g++-16 -std=c++23 -Wall -Wextra describe_tests.cpp -o describe_tests-gcc && ./describe_tests-gcc
FAIL got "other, 4 bytes", want "signed integer, 4 bytes"
FAIL got "other, 2 bytes", want "unsigned integer, 2 bytes"
FAIL got "other, 1 byte", want "signed integer, 1 byte"
FAIL got "other, 1 byte", want "bool, 1 byte"
FAIL got "other, 8 bytes", want "floating point, 8 bytes"
FAIL got "other, 4 bytes", want "floating point, 4 bytes"
FAIL got "other, 8 bytes", want "signed integer, 8 bytes"
FAIL got "other, 8 bytes", want "pointer, 8 bytes"
FAIL got "other, 1 byte", want "enum, 1 byte"
FAIL got "other, 3 bytes", want "class, 3 bytes"
FAIL got "other, 32 bytes", want "class, 32 bytes"
0 of 11 checks passed
[exit status 1]

Every check fails at first, because the starter answers “other” for everything. Write one if constexpr branch per case, on std::remove_cvref_t<T>, so that const long long& describes a long long. Mind the order the traits table taught: bool before the integers, and floating point before any test of is_signed_v. The last check compares std::string with its own sizeof, which differs between the two standard libraries: 24 bytes in libc++ and 32 in libstdc++, as the starter’s output shows. When all is done, both compilers print 11 of 11 checks passed. Then ask for describe<char>() and predict what it prints with -funsigned-char.

Then test what you can predict without a compiler: a trait’s answer, the branch a type keeps, the template SFINAE drops and the C++20 spelling of an old idiom. Practice opens with the concept you have answered least well, and each choice carries the reason it fits or fails here:

Interview questions

Fresher · What does if constexpr do that a plain if does not?

Its condition must be a constant expression, and in a template the branch that is not taken is discarded: it is not instantiated for that type, so it may contain code that would not compile for it. With a plain if, both branches are compiled for every type, even if only one can run, so if (std::is_arithmetic_v<T>) return std::to_string(value); fails for a std::string argument. if constexpr lets one function template hold a separate body for numbers, strings and containers. Two details make a good answer complete. Discarding happens only inside a template, where the condition depends on a template parameter; in ordinary code the skipped branch is still fully checked. And a final else with static_assert(false, "…") turns an unsupported type into a clear error, which current compilers accept even in C++17 mode.

The usual follow-ups probe where if constexpr can choose and where it cannot. Decide these two:

Two harder questions take traits into code you maintain: two enable_if overloads that refuse to build, and a type dispatch that writes the wrong values in production:

Key takeaways

• <type_traits> answers questions about types at compile time, in categories, properties, relations and transformations read through _v and _t, and references are not integral while double is signed.
• Plain char is signed on this Mac and unsigned on Arm Linux, so code that needs a range names signed char, unsigned char or std::uint8_t.
• if constexpr keeps the first true branch of each instantiation and discards the rest, so the order of its tests decides what bool and strings become.
• A plain if compiles every branch for every type, and a final static_assert(false, "…") is the safe ending of an if constexpr chain.
• SFINAE drops a template when substitution makes its declaration invalid, as enable_if does for gcd_of(8.4, 3.6), and templates that differ only in default template arguments clash.
• The detection idiom with std::void_t asks whether an expression compiles, and concepts say every one of these idioms more readably, with clearer errors and ordered overloads.