Understanding Type Predicates in C++

Programs constantly deal with types, and sometimes the most useful thing a program can do is ask a plain question about one. Is this a type that behaves a certain way? Does this type have a property I need? Answering such questions by hand for every situation would be tedious and error-prone. The C++ standard library provides tools designed for exactly this purpose, and the first idea you need in order to use them is the type predicate.

Before reading further, pause and think about what kind of answer a question about a type should produce. A question that can be answered only with yes or no is a particularly convenient kind of question, because the answer can be used directly to decide what a program does next. That idea is the key to everything that follows.

A type predicate takes a type as its input and produces one answer, which is either true or false. Nothing about a particular value comes into play. You can picture the type going in on one side and a single yes-or-no result coming out on the other side. The diagram below traces the int type through the std::is_integral predicate.

Notice what is absent from this picture. There is no variable, no assignment, and no value being computed. The predicate looks only at the type it was given and reports a fact about that type. The word type function in the source description signals this: the predicate operates on types rather than on ordinary values.

Each part of that definition carries meaning. The word predicate comes from logic, where a predicate is a statement that is either true or false for a given subject. A type predicate follows the same pattern: it takes a type as its subject and returns a true-or-false answer about that type. The phrase fundamental question tells you that these predicates address basic questions, the kind a program is likely to need before it can make sound decisions about types.

A type predicate is not a special keyword and not a language rule that changes how types work. It is an ordinary function, supplied by the library, whose purpose is to answer a single fundamental question. Seeing it this way keeps the idea grounded in familiar territory: a function receives something, and it returns a result. Here the thing received is a type and the result is true or false.

The defining word in the description is standard-library. Type predicates are ready-made tools that come with the language's standard facilities. You do not need to invent the questions or write the logic that answers them from scratch. Your job is to know that a tool exists, understand which question it asks, and read its answer correctly.

In C++ the standard type predicates are provided through the type_traits header of the standard library. The program you write only includes that header and asks the predicate its question. The question-answering logic already lives inside the library. The learner's responsibility is choosing the right predicate and interpreting its answer.

The most reliable way to work with a type predicate is to translate it into a sentence. Each predicate asks one question, and its result is the answer. The expression std::is_integral<int>::value can be read as: is int an integral type? The answer is true. The expression std::is_integral<double>::value can be read as: is double an integral type? The answer is false.

A type predicate inspects the type, not the runtime value of any variable. Suppose you have a variable holding 5 and another holding 7, and both are declared as int. Asking whether int is integral gives the same answer no matter which number the variable holds, because the question is about the type int and not about the value stored in it.

The predicate for int returns the same answer whether you think of the value 5, the value 7, or any other int. The answer belongs to the type, so every value of that type shares it. This is why a type predicate is a question about categories of data rather than about the data at a given moment in the program.