Type Deduction Using decltype and declval

Occasionally, it will be easier (or necessary) to ask the compiler to figure out what type an expression returns. We can do this using the decltype specifier.

In the following examples, we use decltype simply to set up type aliases, but its applications are much wider ranging as we'll see through the rest of this chapter.

Below, 42 is an int, so decltype(42) will result in int:

1int main() {
2  // SomeType will be an alias for int
3  using SomeType = decltype(42);
4
5  SomeType SomeValue;
6}

The expression we use with decltype does not need to be a simple literal - below, we use it to determine what is returned by a function:

1int SomeFunction() { return 42; }
2
3int main() {
4  // SomeType will be an alias for int
5  using SomeType = decltype(SomeFunction());
6
7  // This will be an int
8  SomeType SomeValue;
9}

We don't need to use it with a type alias - we can use it almost anywhere a type is expected:

1int SomeFunction() { return 42; }
2
3int main() {
4  // This will be an int
5  decltype(SomeFunction()) SomeValue;
6}

In some scenarios, the expression we need to write to determine a type using decltype can be quite complex. For example, we might want to get the type returned by some member function. This requires us to construct an object just to see what its SomeFunction() method return type is:

1struct MyType {
2  int SomeFunction(){};
3};
4
5int main() {
6  // Will be int
7  using SomeType = decltype(
8    MyType{}.SomeFunction()
9  );
10}

Things can get more awkward if the type isn't default-constructible. This means we now need to provide some random constructor arguments just to find out what type SomeFunction() returns:

1struct MyType {
2  MyType(int, float, bool) {}
3  int SomeFunction(){};
4};
5
6int main() {
7  // Will be int
8  using SomeType = decltype(
9    MyType{42, 9.8, true}.SomeFunction()
10  );
11}

Worse, in more complex scenarios involving templates that we'll cover later, we won't even know what type we're constructing, or what arguments its constructor requires.

To help with this, we have std::declval.

std::declval is available by including <utility>, and it allows us to work with a hypothetical object of a specific type. The following examples are not directly useful, but they lay the foundations:

1#include <utility>
2
3struct SomeType {};
4
5int main() {
6  // A hypthetical int
7  std::declval<int>();
8
9  // A hypthetical float
10  std::declval<float>();
11
12  // A hypthetical SomeType
13  std::declval<SomeType>();
14}

This hypothetical object is only useful to assess the characteristics of its type at compile time, such as the types of its member variables, and the return types of its member functions.

The key advantage of std::declval over decltype is that it doesn't need to actually construct an object, so we don't need to provide constructor arguments. We can solve our original problem like this:

1#include <utility>
2
3struct MyType {
4  MyType(int, float, bool) {}
5  int SomeFunction(){};
6};
7
8int main() {
9  // Before:
10  using SomeType = decltype(
11    MyType{42, 9.8, true}.SomeFunction()
12  );
13  
14  // After:
15  using SomeType = decltype(
16    std::declval<MyType>().SomeFunction()
17  );
18}

Obviously, these examples are extremely contrived. We can clearly see that MyType::SomeFunction() returns an int, so we don't need this complexity.

However, the rest of this chapter will introduce scenarios where, at the time we're writing our code, we don't necessarily know what types we will be dealing with. In these scenarios, tools like decltype and std::declval become much more valuable.

This lesson introduced decltype and std::declval as tools for compile-time type deduction. We saw how decltype can determine the type of an expression, and how std::declval can simplify this process by providing a hypothetical object, avoiding the need for actual construction.

These are especially useful in generic programming contexts which we'll be introducing in the next chapter.

Key Takeaways:

• decltype(expression) returns the type of the given expression without evaluating it.
• It can be used to declare variables or create type aliases with a deduced type.
• To get the return type of a member function, you often need an object instance.
• std::declval<T>() creates a reference to a hypothetical object of type T, usable only within unevaluated contexts like decltype.
• Using std::declval<MyType>().MemberFunction() inside decltype avoids the need to construct an object of MyType.