Słowo kluczowe auto w C++: dedukcja typu na przykładach

Niech kompilator wybierze typ

Na poprzedniej stronie widać było, że każda zmienna w C++ ma stały typ: int, double, std::string i tak dalej. Ręczne wypisanie typu jest w porządku przy int count = 0;, ale robi się uciążliwe, gdy typy stają się długie. Słowo kluczowe auto (od C++11) pozwala kompilatorowi wywnioskować typ z przypisywanej wartości, więc piszesz wartość raz, a resztę uzupełnia kompilator.

#include <iostream>
using namespace std;

int main() {
    auto count = 0;        // int
    auto price = 3.99;     // double
    auto letter = 'A';     // char
    auto greeting = "hi";  // const char*

    cout << count << " " << price << " " << letter << " " << greeting << "\n";
    return 0;
}

Kluczowa myśl: auto to nie dynamiczne typowanie. Każda zmienna nadal ma jeden konkretny typ, ustalony w czasie kompilacji. auto oszczędza ci tylko jego wypisywania.

Dlaczego auto się opłaca

Przy krótkich, oczywistych typach auto count = 0; i int count = 0; są równie czytelne. auto naprawdę się opłaca przy długich, powtarzalnych nazwach typów, takich jak te z kontenerów biblioteki standardowej i iteratorów.

Porównaj rozwlekłą wersję z wersją z auto:

// Bez auto: typ w praktyce jest zapisany dwa razy
std::vector<std::pair<std::string, int>>::iterator it = scores.begin();

// Z auto: kompilator już zna typ
auto it = scores.begin();

Obie deklarują dokładnie ten sam typ iteratora. Druga jest czytelniejsza i nie rozjedzie się z resztą kodu, jeśli później zmienisz scores na inny kontener.

Oto to samo w kompletnym programie:

#include <iostream>
#include <vector>
#include <string>
using namespace std;

int main() {
    vector<pair<string, int>> scores = {{"Ada", 90}, {"Boris", 85}};

    for (auto it = scores.begin(); it != scores.end(); ++it) {
        cout << it->first << ": " << it->second << "\n";
    }
    return 0;
}

auto w pętlach for po zakresie

Najczęściej spotkasz auto w pętli for po zakresie. Prawie nigdy nie chcesz ręcznie wypisywać typu elementu, a sposób zapisania auto decyduje, czy dostajesz kopię, czy referencję.

#include <iostream>
#include <vector>
#include <string>
using namespace std;

int main() {
    vector<string> names = {"Ada", "Boris", "Rosa"};

    // const auto&: tylko odczyt, bez kopii. Zwykły wybór domyślny do czytania.
    for (const auto& name : names) {
        cout << name << "\n";
    }
    return 0;
}

Trzy warianty, które zobaczysz, i co każdy oznacza:

• for (auto x : v): x jest kopią każdego elementu. Tanie dla int, marnotrawne dla dużych obiektów.
• for (auto& x : v): x jest referencją; możesz modyfikować elementy w miejscu.
• for (const auto& x : v): x jest referencją tylko do odczytu. Używaj, gdy potrzebujesz tylko czytać.

Ten program modyfikuje kontener przez auto&:

#include <iostream>
#include <vector>
using namespace std;

int main() {
    vector<int> nums = {1, 2, 3};

    for (auto& n : nums) {
        n *= 10;        // modyfikuje prawdziwy element
    }

    for (const auto& n : nums) {
        cout << n << " ";   // 10 20 30
    }
    cout << "\n";
    return 0;
}

Pułapka: napisz w tej pętli for (auto n : nums) (bez &), a n *= 10 po cichu zmieni tylko kopię, a nums zostanie nietknięte. Kompilator cię nie ostrzeże; pętla po prostu nie zrobi nic pożytecznego.

Co auto odrzuca

Zwykłe auto wnioskuje typ tak samo jak parametr funkcji przekazywany przez wartość: odrzuca const najwyższego poziomu, referencje i volatile. Oznacza to, że auto zawsze daje ci świeżą, modyfikowalną kopię, chyba że poprosisz o coś innego.

#include <iostream>
using namespace std;

int main() {
    const int original = 42;

    auto copy = original;   // typ to int, NIE const int
    copy = 100;             // całkowicie legalne: const zostało odrzucone

    cout << original << " " << copy << "\n";  // 42 100
    return 0;
}

Jeśli chcesz zachować const albo uniknąć kopii, dodajesz kwalifikatory samodzielnie. Wzorzec polega na ozdobieniu auto dokładnie tak samo jak każdego innego typu:

#include <iostream>
#include <string>
using namespace std;

int main() {
    string name = "Ada";

    const auto& ref = name;   // const std::string&: bez kopii, tylko odczyt
    cout << ref << " has " << ref.size() << " letters\n";

    // ref = "Boris";         // błąd: ref jest const
    return 0;
}

Tak więc auto wnioskuje typ bazowy, a &, const i * to pokrętła, które dokładasz na wierzchu. auto to sam typ, a const auto& to referencja do niego tylko do odczytu.

Częste błędy i pułapki

auto oszczędza pisania, ale nie zwalnia z rozumienia typów. Kilka pułapek łapie początkujących:

Musisz zainicjalizować zmienną. auto nie ma z czego wnioskować przy pustej deklaracji, więc to twardy błąd kompilacji:

auto x;        // error: declaration of 'auto x' has no initializer
auto y = 0;    // w porządku

Literały całkowite to int, a nie double. auto half = 1 / 2; wnioskuje int i zapisuje 0, bo 1 / 2 to dzielenie całkowite wykonane zanim auto w ogóle zobaczy wynik. Typ podąża za wartością:

#include <iostream>
using namespace std;

int main() {
    auto wrong = 1 / 2;      // dzielenie całkowite -> 0
    auto right = 1.0 / 2;    // double -> 0.5

    cout << wrong << " " << right << "\n";  // 0 0.5
    return 0;
}

auto odrzuca referencję, więc uważaj na niespodziewane kopie. Jeśli funkcja zwraca referencję, a ty przechwycisz ją zwykłym auto, dostaniesz kopię, co w gorącej pętli bywa prawdziwym problemem wydajności (głęboka kopia dużego obiektu w każdej iteracji). Sięgaj po const auto&, gdy masz na myśli "popatrz, nie zabieraj".

Nie ukrywaj typu, gdy ma znaczenie. auto result = compute(); jest w porządku, gdy typ zwracany przez compute wynika jasno z kontekstu, ale jeśli czytelnik musi szukać, czym właściwie jest result, jawne wypisanie typu bywa bardziej przyjazne. auto służy do redukowania szumu, a nie do ukrywania intencji.

Dalej: stałe i const

Wiesz już, że auto celowo odrzuca const, chyba że poprosisz o jego zachowanie. To rodzi oczywiste pytanie: co właściwie gwarantuje const i kiedy w ogóle oznaczać wartość jako niezmienną? Następna strona omawia const, wyrażenia stałe i to, dlaczego zasada "domyślnie const" to jeden z najbardziej przydatnych nawyków w C++.