Kata Kunci auto C++: Penjelasan Deduksi Tipe dengan Contoh

Biarkan Compiler Memilih Tipenya

Di halaman sebelumnya kamu melihat bahwa setiap variabel C++ punya tipe yang tetap: int, double, std::string, dan seterusnya. Menulis tipe itu secara manual tidak masalah untuk int count = 0;, tetapi jadi ramai begitu nama tipenya panjang. Kata kunci auto (C++11 ke atas) membiarkan compiler menyimpulkan tipe dari nilai yang kamu berikan, jadi kamu cukup menulis nilainya sekali dan compiler melengkapi sisanya.

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

Ide kuncinya: auto bukan dynamic typing. Setiap variabel tetap punya satu tipe konkret yang dikunci saat kompilasi. auto hanya menghemat kamu dari menuliskannya.

Kenapa auto Layak Dipakai

Untuk tipe yang pendek dan jelas, auto count = 0; dan int count = 0; sama mudahnya dibaca. auto benar-benar terasa manfaatnya untuk nama tipe yang panjang dan berulang, seperti yang kamu dapat dari container dan iterator standard library.

Bandingkan versi panjang dengan versi auto:

// Without auto - the type is written twice, in effect
std::vector<std::pair<std::string, int>>::iterator it = scores.begin();

// With auto - the compiler already knows the type
auto it = scores.begin();

Keduanya mendeklarasikan tipe iterator yang persis sama. Yang kedua lebih mudah dibaca dan tidak akan jadi tidak cocok kalau nanti kamu mengganti scores dengan container lain.

Berikut contohnya dalam program lengkap:

#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 di Range-Based for Loop

Tempat paling umum kamu bertemu auto adalah range-based for loop. Kamu hampir tidak pernah ingin menulis tipe elemennya secara manual, dan cara kamu menulis auto menentukan apakah kamu mendapat salinan atau referensi.

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

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

    // const auto& - read-only, no copy. The usual default for reading.
    for (const auto& name : names) {
        cout << name << "\n";
    }
    return 0;
}

Ada tiga variasi yang akan kamu lihat, dan artinya masing-masing:

• for (auto x : v): x adalah salinan dari setiap elemen. Murah untuk int, boros untuk objek besar.
• for (auto& x : v): x adalah referensi; kamu bisa mengubah elemennya langsung di tempat.
• for (const auto& x : v): x adalah referensi read-only. Pakai ini kalau kamu hanya perlu membaca.

Program berikut mengubah isi container lewat auto&:

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

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

    for (auto& n : nums) {
        n *= 10;        // modifies the real element
    }

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

Jebakannya: tulis for (auto n : nums) (tanpa &) di loop itu, dan n *= 10 diam-diam hanya mengubah salinannya, sementara nums tetap utuh. Compiler tidak akan memperingatkanmu; loop-nya hanya tidak melakukan apa pun yang berguna.

Apa yang Dibuang oleh auto

auto biasa menyimpulkan tipe dengan cara yang sama seperti parameter fungsi by value: ia membuang const tingkat atas, referensi, dan volatile. Artinya auto selalu memberimu salinan baru yang bisa diubah, kecuali kamu meminta yang lain.

#include <iostream>
using namespace std;

int main() {
    const int original = 42;

    auto copy = original;   // type is int, NOT const int
    copy = 100;             // perfectly legal - the const was stripped

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

Kalau kamu ingin mempertahankan const atau menghindari salinan, tambahkan sendiri qualifier-nya. Polanya adalah menghias auto dengan cara yang sama seperti kamu menghias tipe apa pun:

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

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

    const auto& ref = name;   // const std::string& - no copy, read-only
    cout << ref << " has " << ref.size() << " letters\n";

    // ref = "Boris";         // error: ref is const
    return 0;
}

Jadi auto menyimpulkan tipe dasar-nya; &, const, dan * adalah tambahan yang kamu pasang di atasnya. auto adalah tipenya, const auto& adalah referensi read-only ke tipe itu.

Kesalahan Umum dan Jebakan

auto menghilangkan usaha mengetik, bukan kebutuhan untuk memahami tipe. Beberapa jebakan sering menangkap pemula:

Kamu wajib menginisialisasi. auto tidak punya apa pun untuk disimpulkan dari deklarasi kosong, jadi ini compile error:

auto x;        // error: declaration of 'auto x' has no initializer
auto y = 0;    // fine

Literal bilangan bulat bertipe int, bukan double. auto half = 1 / 2; menyimpulkan int dan menyimpan 0, karena 1 / 2 adalah pembagian bilangan bulat sebelum auto sempat melihatnya. Tipenya mengikuti nilainya:

#include <iostream>
using namespace std;

int main() {
    auto wrong = 1 / 2;      // int division -> 0
    auto right = 1.0 / 2;    // double -> 0.5

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

auto membuang referensi, jadi waspadai kejutan salinan. Kalau sebuah fungsi mengembalikan referensi dan kamu menangkapnya dengan auto biasa, kamu mendapat salinan, yang kadang menjadi bug performa nyata di loop yang sering dijalankan (deep copy objek besar di setiap iterasi). Pakai const auto& kalau maksudmu "lihat saja, jangan ambil."

Jangan sembunyikan tipe saat tipe itu penting. auto result = compute(); tidak masalah kalau tipe kembalian compute jelas dari konteksnya, tetapi kalau pembaca harus mencari-cari apa sebenarnya result, menuliskan tipenya bisa jadi pilihan yang lebih ramah. auto gunanya untuk mengurangi keramaian, bukan untuk menyembunyikan maksud.

Berikutnya: Konstanta dan const

Sekarang kamu tahu bahwa auto sengaja membuang const kecuali kamu memintanya dipertahankan. Ini memunculkan pertanyaan yang jelas: apa sebenarnya yang dijamin oleh const, dan kapan kamu sebaiknya menandai sebuah nilai sebagai tidak bisa diubah? Halaman berikutnya membahas const, ekspresi konstan, dan kenapa "jadikan const secara default" adalah salah satu kebiasaan paling berguna di C++.