A placeholder type specifier designates aplaceholder type that will be replaced later, typically by deduction from aninitializer.

[edit]Syntax

The placeholderauto may be accompanied by modifiers, such asconst or&, which will participate in the type deduction.The placeholderdecltype(auto) must be the sole constituent of the declared type.(since C++14)

[edit]Explanation

A placeholder type specifier may appear in the following contexts:

[edit]Function declarations

A placeholder type can appear in thedeclaration specifiers for afunction declarator that includes a trailing return type.

auto f()->int;// OK: f returns intauto g(){return0.0;}// OK since C++14: g returns doubleauto h();// OK since C++14: h’s return type will be deduced when it is defined

[edit]Variable declarations

The type of a variable declared using a placeholder type is deduced from itsinitializer. This use is allowed in an initializing declaration of a variable.

The placeholder type can only appear as one of thedeclaration specifiers in the declaration specifier sequence or as one of the type specifiers in a trailing return type that specifies the type that replaces such a declaration specifier. In this case, the declaration must declare at least one variable, and each variable must have a non-empty initializer.

// “auto”s in declaration specifiersauto x=5;// OK: x has type intconstauto*v=&x, u=6;// OK: v has type const int*, u has type const intstaticauto y=0.0;// OK: y has type double auto f()->int;auto(*fp)()->auto= f;// OK: the “auto” in the trailing return type// can be deduced from f

[edit]new expressions

A placeholder type can be used in the type specifier sequence of the type-id of anew expression. In such a type-id, the placeholder type must appear as one of the type specifiers in the type specifier sequence or a trailing return type that specifies the type that replacessuch a type specifier.

[edit]Notes

Until C++11,auto had the semantic of astorage duration specifier.

A program that uses a placeholder type in a context not explicitly stated above is ill-formed.

If a declaration declares multiple entities, and the declaration specifier sequence uses a placeholder type, the program is ill-formed if any of the following conditions is satisfied:

• Some of the entities declared are not variables.
• The type that replaces the placeholder type is not the same in each deduction.

auto f()->int, i=0;// Error: declares a function and a variable with “auto”auto a=5, b={1,2};// Error: different types for “auto”

If a function or variable with an unreplaced placeholder type is referenced by an expression, the program is ill-formed.

auto v=1;auto l=[&]{    v++;return l;// Error: The placeholder type for l was not replaced};std::function<void()> p=[&]{    v++;return p;// OK};

[edit]Keywords

auto,decltype

[edit]Example

#include <iostream>#include <utility> template<class T,class U>auto add(T t, U u){return t+ u;}// the return type is the type of operator+(T, U) // perfect forwarding of a function call must use decltype(auto)// in case the function it calls returns by referencetemplate<class F,class...Args>decltype(auto) PerfectForward(F fun, Args&&...args){return fun(std::forward<Args>(args)...);} template<auto n>// C++17 auto parameter declarationauto f()->std::pair<decltype(n), decltype(n)>// auto can't deduce from brace-init-list{return{n, n};} int main(){auto a=1+2;// type of a is intauto b= add(1,1.2);// type of b is double    static_assert(std::is_same_v<decltype(a),int>);    static_assert(std::is_same_v<decltype(b),double>); auto c0= a;// type of c0 is int, holding a copy of a    decltype(auto) c1= a;// type of c1 is int, holding a copy of a    decltype(auto) c2=(a);// type of c2 is int&, an alias of astd::cout<<"before modification through c2, a = "<< a<<'\n';++c2;std::cout<<" after modification through c2, a = "<< a<<'\n'; auto[v, w]= f<0>();//structured binding declaration auto d={1,2};// OK: type of d is std::initializer_list<int>auto n={5};// OK: type of n is std::initializer_list<int>//  auto e{1, 2};    // Error as of DR n3922, std::initializer_list<int> beforeauto m{5};// OK: type of m is int as of DR n3922, initializer_list<int> before//  decltype(auto) z = { 1, 2 } // Error: {1, 2} is not an expression // auto is commonly used for unnamed types such as the types of lambda expressionsauto lambda=[](int x){return x+3;}; //  auto int x; // valid C++98, error as of C++11//  auto x;     // valid C, error in C++ [](...){}(c0, c1, v, w, d, n, m, lambda);// suppresses "unused variable" warnings}

before modification through c2, a = 3 after modification through c2, a = 4

[edit]Defect reports

The following behavior-changing defect reports were applied retroactively to previously published C++ standards.

[edit]References

• In other languages

• Deutsch
• Español
• Français
• Italiano
• 日本語
• Português
• Русский
• 中文