decltype is a new keyword that infers the type of a given expression. Though it can be used instead of auto; it is used mainly on return types.

For example; this function:

int sum(int a, int b)
{
  typedef int ret;
  ret x = a + b;
  return x;
}

could be written using decltype:

int sum(int a, int b)
{
  typedef decltype(a+b) ret;
  ret x = a + b;
  return x;
}

The compiler evaluates ‘a+b’ and infers the type of such expression is ‘int’ and defines ‘ret’ as an ‘int’.

Useful? In the case shown above: Not at all.

But what if I would want the compiler to infer the return type of my method shown above?. What if I say:

auto sum(int a, int b)  //does not compile!!!
{
  return a + b;
}

Though it is apparently correct, ‘auto’ is not supported on return types; so, this example does not compile.

What if I decide to use decltype:

decltype(a+b) sum(int a, int b) //does not compile!!!
{
  return a + b;
}

Though the decltype usage shown in the example above is correct and worked in the earlier example; in this case it does not compile because when parsing the ‘decltype(a+b)’ thing, the compiler does not know what ‘a’ and ‘b’ are.

To solve this problem, in C++0x there is a new way to declare functions and methods:

auto sum(int a, int b) -> int
{
  return a + b;
}

In the example shown above, with the ‘auto’ keyword you are saying to the compiler that the return type will be specified later, and “later” means after the ‘->’. Using this syntax, you can use decltype to specify the return type:

auto sum(int a, int b) -> decltype(a+b)
{
  return a + b;
}

Useful? With my example, it is still not useful at all; however, the new syntax lets you use the decltype in more complex function declarations and the new syntax is also useful to declare ‘lambda expressions’.

decltype becomes really useful when it is used with templates.

Consider a method template called ‘execute’ that receives as parameters the pointer to the function to execute and a value to pass to such function:

template <class T, class F> //does not compile
??? execute(const T& val, F func)
{
  return func(val);
}

what would be the return type of that function? I want to use it with these functions:

string getname(int x)
{
  switch (x)
  {
    case 0: return "zero";
    case 1: return "one";
    case 2: return "two";
  }
  return "I need to learn to count";
}

and

int getlength(const string& s)
{
  return s.length();
}

I would want to use my ‘execute’ function in this way:

cout << execute("hello", getlength) << endl;
cout << execute(1, getname) << endl;

To solve this problem, we can declare our method template using decltype:

template <typename T, typename F>
auto execute(const T& t, F func) -> decltype(func(t))
{
  return func(t);
}

So in this case, decltype is very very useful and without it maybe implementing this kind of things would be impossible.