auto (C++)auto (C++)

宣言された変数の型を、その初期化式から推測します。Deduces the type of a declared variable from its initialization expression.

注意

C++ 標準では、このキーワードの元の意味と改訂された意味が定義されています。The C++ standard defines an original and a revised meaning for this keyword. Visual Studio 2010 より前では、キーワードは、 auto 自動 ストレージクラスの変数、つまりローカルの有効期間を持つ変数を宣言しています。Before Visual Studio 2010, the auto keyword declares a variable in the automatic storage class; that is, a variable that has a local lifetime. Visual Studio 2010 以降では、 auto キーワードは、宣言の初期化式から推測される型を持つ変数を宣言します。Starting with Visual Studio 2010, the auto keyword declares a variable whose type is deduced from the initialization expression in its declaration. /Zc:auto[ ]コンパイラオプションは、キーワードの意味を制御し auto ます。The /Zc:auto[-] compiler option controls the meaning of the auto keyword.

構文Syntax

auto***宣言子の初期化子*;auto declarator initializer ;

*[](auto***param1 , autoparam2) {};[](auto param1 , auto param2 ) {};

解説Remarks

キーワードは、宣言された auto 変数の初期化式、またはラムダ式のパラメーターを使用してその型を推測するようにコンパイラに指示します。The auto keyword directs the compiler to use the initialization expression of a declared variable, or lambda expression parameter, to deduce its type.

変換が必要な場合を除き、ほとんどの状況でキーワードを使用することをお勧めし auto ます。これには、次のような利点があります。We recommend that you use the auto keyword for most situations—unless you really want a conversion—because it provides these benefits:

  • 堅牢性: 式の型が変更された場合は、関数の戻り値の型が変更されたときにのみ機能します。Robustness: If the expression’s type is changed—this includes when a function return type is changed—it just works.

  • パフォーマンス: 変換が行われないことは保証されています。Performance: You’re guaranteed that there will be no conversion.

  • 使いやすさ: 型名のスペルの問題や誤字を心配する必要はありません。Usability: You don't have to worry about type name spelling difficulties and typos.

  • 効率: コーディングの方が効率的です。Efficiency: Your coding can be more efficient.

以下を使用する必要がない変換ケース auto :Conversion cases in which you might not want to use auto:

  • 特定の型が必要であり、他の型を使用できない場合。When you want a specific type and nothing else will do.

  • 式テンプレートヘルパー型 (たとえば、) (valarray+valarray)Expression template helper types—for example, (valarray+valarray).

キーワードを使用するには、 auto 変数を宣言するために型の代わりに使用し、初期化式を指定します。To use the auto keyword, use it instead of a type to declare a variable, and specify an initialization expression. また、、 auto const volatile 、pointer ( * )、reference ( & )、右辺値参照 () などの指定子と宣言子を使用して、キーワードを変更することもでき && ます。In addition, you can modify the auto keyword by using specifiers and declarators such as const, volatile, pointer (*), reference (&), and rvalue reference (&&). コンパイラは初期化式を評価し、その情報を使用して変数の型を推測します。The compiler evaluates the initialization expression and then uses that information to deduce the type of the variable.

初期化式には、代入 (等号の構文)、直接の初期化 (関数形式の構文)、 operator new 式、または、範囲ベースの for ステートメント (C++)ステートメントでの範囲宣言のパラメーターを指定できます。The initialization expression can be an assignment (equal-sign syntax), a direct initialization (function-style syntax), an operator new expression, or the initialization expression can be the for-range-declaration parameter in a Range-based for Statement (C++) statement. 詳細については、このドキュメントで後述する「 初期化子 とコード例」を参照してください。For more information, see Initializers and the code examples later in this document.

キーワードは、 auto 型のプレースホルダーですが、それ自体は型ではありません。The auto keyword is a placeholder for a type, but it is not itself a type. そのため、キーワードは、やなどの auto キャストまたは演算子では使用できません sizeof (C++/cli の場合) typeidTherefore, the auto keyword cannot be used in casts or operators such as sizeof and (for C++/CLI) typeid.

実用性Usefulness

auto キーワードは、複雑な型を持つ変数を宣言する簡単な方法です。The auto keyword is a simple way to declare a variable that has a complicated type. たとえば、を使用して、 auto 初期化式にテンプレート、関数へのポインター、またはメンバーへのポインターが含まれる変数を宣言できます。For example, you can use auto to declare a variable where the initialization expression involves templates, pointers to functions, or pointers to members.

また、を使用し auto て、変数を宣言し、ラムダ式に初期化することもできます。You can also use auto to declare and initialize a variable to a lambda expression. ラムダ式の型を認識できるのはコンパイラのみであるため、プログラマが変数の型を宣言することはできません。You can't declare the type of the variable yourself because the type of a lambda expression is known only to the compiler. 詳細については、「 ラムダ式の例」を参照してください。For more information, see Examples of Lambda Expressions.

後続の戻り値の型Trailing Return Types

を型指定子と共に使用すると、 auto decltype テンプレートライブラリを記述するのに役立ちます。You can use auto, together with the decltype type specifier, to help write template libraries. とを使用し auto て、 decltype 戻り値の型がテンプレート引数の型に依存するテンプレート関数を宣言します。Use auto and decltype to declare a template function whose return type depends on the types of its template arguments. または、とを使用して、 auto decltype 別の関数の呼び出しをラップするテンプレート関数を宣言し、その他の関数の戻り値の型を返します。Or, use auto and decltype to declare a template function that wraps a call to another function, and then returns whatever is the return type of that other function. 詳細については、decltype を参照してください。For more information, see decltype.

参照と cv 修飾子References and cv-qualifiers

を使用する auto と、参照、修飾子、および修飾子が削除されることに注意 const volatile してください。Note that using auto drops references, const qualifiers, and volatile qualifiers. 次に例を示します。Consider the following example:

// cl.exe /analyze /EHsc /W4
#include <iostream>

using namespace std;

int main( )
{
    int count = 10;
    int& countRef = count;
    auto myAuto = countRef;

    countRef = 11;
    cout << count << " ";

    myAuto = 12;
    cout << count << endl;
}

前の例では、myAuto は int 参照ではなくです int 。そのため、 11 11 11 12 参照修飾子がによって削除されていない場合のように、出力はになり auto ます。In the previous example, myAuto is an int, not an int reference, so the output is 11 11, not 11 12 as would be the case if the reference qualifier had not been dropped by auto.

かっこ付き初期化子を使用した型推論 (C++ 14)Type deduction with braced initializers (C++14)

次のコード例は、 auto 中かっこを使用して変数を初期化する方法を示しています。The following code example shows how to initialize an auto variable using braces. B と C の違いと A と E の違いに注意してください。Note the difference between B and C and between A and E.

#include <initializer_list>

int main()
{
    // std::initializer_list<int>
    auto A = { 1, 2 };

    // std::initializer_list<int>
    auto B = { 3 };

    // int
    auto C{ 4 };

    // C3535: cannot deduce type for 'auto' from initializer list'
    auto D = { 5, 6.7 };

    // C3518 in a direct-list-initialization context the type for 'auto'
    // can only be deduced from a single initializer expression
    auto E{ 8, 9 };

    return 0;
}

制限事項とエラー メッセージRestrictions and Error Messages

次の表に、キーワードの使用に関する制限 auto と、コンパイラによって生成される対応する診断エラーメッセージの一覧を示します。The following table lists the restrictions on the use of the auto keyword, and the corresponding diagnostic error message that the compiler emits.

エラー番号Error number 説明Description
C3530C3530 auto キーワードを他の型指定子と組み合わせることはできません。The auto keyword cannot be combined with any other type-specifier.
C3531C3531 キーワードで宣言されたシンボルには auto 初期化子が必要です。A symbol that is declared with the auto keyword must have an initializer.
C3532C3532 キーワードを誤って使用して auto 型を宣言した。You incorrectly used the auto keyword to declare a type. たとえば、メソッドの戻り値の型または配列を宣言しました。For example, you declared a method return type or an array.
C3533C3539C3533, C3539 パラメーターまたはテンプレート引数をキーワードで宣言することはできません autoA parameter or template argument cannot be declared with the auto keyword.
C3535C3535 メソッドまたはテンプレートパラメーターをキーワードで宣言することはできません autoA method or template parameter cannot be declared with the auto keyword.
C3536C3536 シンボルは初期化前に使用することはできません。A symbol cannot be used before it is initialized. 実際には、変数はその変数自体を初期化するために使用できないことを意味します。In practice, this means that a variable cannot be used to initialize itself.
C3537C3537 キーワードで宣言された型にキャストすることはできません autoYou cannot cast to a type that is declared with the auto keyword.
C3538C3538 キーワードを使用して宣言されている宣言子リスト内のすべてのシンボルは、 auto 同じ型に解決する必要があります。All the symbols in a declarator list that is declared with the auto keyword must resolve to the same type. 詳細については、「 宣言と定義」を参照してください。For more information, see Declarations and Definitions.
C3540C3541C3540, C3541 Sizeofおよびtypeid演算子は、キーワードで宣言されたシンボルには適用できません autoThe sizeof and typeid operators cannot be applied to a symbol that is declared with the auto keyword.

Examples

これらのコードフラグメントは、キーワードを使用するいくつかの方法を示して auto います。These code fragments illustrate some of the ways in which the auto keyword can be used.

次の宣言は同等です。The following declarations are equivalent. 最初のステートメントでは、変数 j が型として宣言されてい int ます。In the first statement, variable j is declared to be type int. 2番目のステートメントで k は、 int 初期化式 (0) が整数であるため、変数は型と推測されます。In the second statement, variable k is deduced to be type int because the initialization expression (0) is an integer.

int j = 0;  // Variable j is explicitly type int.
auto k = 0; // Variable k is implicitly type int because 0 is an integer.

次の宣言は同じ意味を持ちますが、2 番目の宣言の方が最初の宣言より単純です。The following declarations are equivalent, but the second declaration is simpler than the first. キーワードを使用する最も説得力のある理由の1つ auto は、単純であることです。One of the most compelling reasons to use the auto keyword is simplicity.

map<int,list<string>>::iterator i = m.begin();
auto i = m.begin();

次のコード片では、変数の型 iter と、 elem 範囲のループが開始されるタイミングを宣言し for for ます。The following code fragment declares the type of variables iter and elem when the for and range for loops start.

// cl /EHsc /nologo /W4
#include <deque>
using namespace std;

int main()
{
    deque<double> dqDoubleData(10, 0.1);

    for (auto iter = dqDoubleData.begin(); iter != dqDoubleData.end(); ++iter)
    { /* ... */ }

    // prefer range-for loops with the following information in mind
    // (this applies to any range-for with auto, not just deque)

    for (auto elem : dqDoubleData) // COPIES elements, not much better than the previous examples
    { /* ... */ }

    for (auto& elem : dqDoubleData) // observes and/or modifies elements IN-PLACE
    { /* ... */ }

    for (const auto& elem : dqDoubleData) // observes elements IN-PLACE
    { /* ... */ }
}

次のコード片では、 new 演算子とポインターの宣言を使用してポインターを宣言しています。The following code fragment uses the new operator and pointer declaration to declare pointers.

double x = 12.34;
auto *y = new auto(x), **z = new auto(&x);

次のコード片は各宣言ステートメントで複数のシンボルを宣言します。The next code fragment declares multiple symbols in each declaration statement. 各ステートメントのすべてのシンボルが同じ型に解決されることに注意してください。Notice that all of the symbols in each statement resolve to the same type.

auto x = 1, *y = &x, **z = &y; // Resolves to int.
auto a(2.01), *b (&a);         // Resolves to double.
auto c = 'a', *d(&c);          // Resolves to char.
auto m = 1, &n = m;            // Resolves to int.

次のコード片は、値が 200 の整数として変数 ?: を宣言するために、条件演算子 (x) を使用します。This code fragment uses the conditional operator (?:) to declare variable x as an integer that has a value of 200:

int v1 = 100, v2 = 200;
auto x = v1 > v2 ? v1 : v2;

次のコードフラグメントは、変数を型に、変数を型への参照に、変数を型を x int y const int fp 返す関数へのポインターに初期化し int ます。The following code fragment initializes variable x to type int, variable y to a reference to type const int, and variable fp to a pointer to a function that returns type int.

int f(int x) { return x; }
int main()
{
    auto x = f(0);
    const auto& y = f(1);
    int (*p)(int x);
    p = f;
    auto fp = p;
    //...
}

関連項目See also

キーワードKeywords
/Zc:auto (変数の型の推測)/Zc:auto (Deduce Variable Type)
sizeof 演算子sizeof Operator
typeid
operator new
宣言と定義Declarations and Definitions
ラムダ式の例Examples of Lambda Expressions
初期化子Initializers
decltype