`auto` (C++)

Härleds typen av en deklarerad variabel från dess initieringsuttryck.

Anmärkning

C++-standarden definierar ett original och en reviderad betydelse för det här nyckelordet. Före Visual Studio 2010 deklarerar nyckelordet auto en variabel i den automatiska lagringsklassen, det vill säga en variabel som har en lokal livslängd. Från och med Visual Studio 2010 deklarerar nyckelordet auto en variabel vars typ härleds från initieringsuttrycket i deklarationen. Kompilatoralternativet /Zc:auto[-] styr nyckelordets auto innebörd.

Syntax

auto deklaratorinitierare;

[](auto param1, autoparam2) {};

Anmärkningar

Nyckelordet auto instruerar kompilatorn att använda initieringsuttrycket för en deklarerad variabel, eller lambda-uttrycksparameter, för att härleda dess typ.

Vi rekommenderar att du använder nyckelordet auto för de flesta situationer – om du inte verkligen vill ha en konvertering – eftersom det ger följande fördelar:

Robusthet: Om uttryckets typ ändras, inklusive när en funktionsreturtyp ändras, fungerar den bara.
Föreställning: Du är garanterad att det inte finns någon konvertering.
Användbarhet: Du behöver inte bekymra dig om stavningsproblem och stavfel för typnamn.
Effektivitet: Din kodning kan vara effektivare.

Konverteringsfall där du kanske inte vill använda auto:

Du vill ha en viss typ och inget annat kommer att göra.
I hjälptyper för uttrycksmallar – till exempel (valarray+valarray).

Om du vill använda nyckelordet auto använder du det i stället för en typ för att deklarera en variabel och anger ett initieringsuttryck. Dessutom kan du ändra nyckelordet auto med hjälp av specificerare och deklaratorer som const, volatile, pekare (*), referens (&) och rvalue-referens (&&). Kompilatorn utvärderar initieringsuttrycket och använder sedan den informationen för att härleda variabeltypen.

Initieringsuttrycket auto kan ha flera former:

Universell initieringssyntax, till exempel auto a { 42 };.
Tilldelningssyntax, till exempel auto b = 0;.
Universell tilldelningssyntax, som kombinerar de två tidigare formulären, till exempel auto c = { 3.14159 };.
Direktinitiering eller syntax i konstruktorstil, till exempel auto d( 1.41421f );.

Mer information finns i Initierare och kodexemplen senare i det här dokumentet.

När auto används för att deklarera loopparametern i en intervallbaserad for instruktion använder den en annan initieringssyntax, till exempel for (auto& i : iterable) do_action(i);. Mer information finns i Range-based for Statement (C++).

Nyckelordet auto är en platshållare för en typ, men det är inte i sig en typ. Därför kan nyckelordet auto inte användas i casts eller operatorer som sizeof och (för C++/CLI) typeid.

Användbarhet

Nyckelordet auto är ett enkelt sätt att deklarera en variabel som har en komplicerad typ. Du kan till exempel använda auto för att deklarera en variabel där initieringsuttrycket omfattar mallar, pekare till funktioner eller pekare till medlemmar.

Du kan också använda auto för att deklarera och initiera en variabel till ett lambda-uttryck. Du kan inte deklarera variabeltypen själv eftersom typen av ett lambda-uttryck endast är känd för kompilatorn. Mer information finns i Exempel på Lambda-uttryck.

Avslutande returtyper

Du kan använda auto, tillsammans med decltype typspecificeraren, för att skriva mallbibliotek. Använd auto och decltype för att deklarera en funktionsmall vars returtyp beror på typen av mallargument. Du kan också använda auto och decltype deklarera en funktionsmall som omsluter ett anrop till en annan funktion och sedan returnerar den andra funktionens returtyp. Mer information finns i decltype.

Referenser och cv-kvalificerare

Använda auto droppar referenser, const kvalificerare och volatile kvalificerare. Tänk på följande exempel:

// 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;
}

I föregående exempel är myAuto en int, inte en int referens, så utdata är 11 11, inte 11 12 som skulle vara fallet om referenskvalificeraren inte hade släppts av auto.

Skriv avdrag med klammerparenteserade initialiserare (C++14)

I följande kodexempel visas hur du initierar en auto variabel med hjälp av klammerparenteser. Observera skillnaden mellan B och C och mellan A och 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;
}

Begränsningar och felmeddelanden

I följande tabell visas begränsningarna för användningen av nyckelordet auto och motsvarande diagnostikfelmeddelande som kompilatorn genererar.

Felnummer	Beskrivning
C3530	Nyckelordet `auto` kan inte kombineras med någon annan typspecificerare.
C3531	En symbol som deklareras med nyckelordet `auto` måste ha en initialiserare.
C3532	Du använde nyckelordet `auto` felaktigt för att deklarera en typ. Du har till exempel deklarerat en metodreturtyp eller en matris.
C3533, C3539	Det går inte att deklarera ett parameter- eller mallargument med nyckelordet `auto` .
C3535	Det går inte att deklarera en metod- eller mallparameter med nyckelordet `auto` .
C3536	Det går inte att använda en symbol innan den initieras. I praktiken innebär det att en variabel inte kan användas för att initiera sig själv.
C3537	Du kan inte casta till en typ som deklareras med nyckelordet `auto` .
C3538	Alla symboler i en deklaratorlista som deklareras med nyckelordet `auto` måste matcha till samma typ. Mer information finns i Deklarationer och definitioner.
C3540, C3541	Operatorerna sizeof och typeid kan inte tillämpas på en symbol som deklareras med nyckelordet`auto`.

Exempel

Dessa kodfragment illustrerar några av de sätt på vilka nyckelordet auto kan användas.

Följande deklarationer är likvärdiga. I den första instruktionen deklareras variabeln j som typ int. I den andra instruktionen härleds variabeln k till typ int eftersom initieringsuttrycket (0) är ett heltal.

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

Följande deklarationer är likvärdiga, men den andra deklarationen är enklare än den första. En av de mest övertygande anledningarna till att använda nyckelordet auto är enkelhet.

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

Följande kodfragment deklarerar typen av variabler iter och elem när for looparna och -intervallet for startar.

// 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
    { /* ... */ }
}

Följande kodfragment använder operatorn och pekardeklarationen new för att deklarera pekare.

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

Nästa kodfragment deklarerar flera symboler i varje deklarationssats. Observera att alla symboler i varje instruktion matchar samma typ.

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.

Det här kodfragmentet använder den villkorsstyrda operatorn (?:) för att deklarera variabeln x som ett heltal som har värdet 200:

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

Följande kodfragment initierar variabeln x för att skriva int, variabel y till en referens till typen const intoch variabeln fp till en pekare till en funktion som returnerar typen 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;
    //...
}

Se även

nyckelord
/Zc:auto (Härled variabeltyp)
sizeof operatör
typeid
operator new
Deklarationer och definitioner
Exempel på lambda-uttryck
Initierare
decltype

Feedback

Var den här sidan till hjälp?

Last updated on 2025-11-07