C++ auto Anahtar Sözcüğü: Örneklerle Tür Çıkarımı

Türü Derleyici Seçsin

Önceki sayfada her C++ değişkeninin sabit bir türü olduğunu gördün - int, double, std::string vb. Bu türü elle yazmak int count = 0; için sorun değil, ama türler uzadıkça gürültülü hale gelir. auto anahtar sözcüğü (C++11 ve sonrası) derleyicinin türü atadığın değerden çıkarmasına izin verir, böylece değeri bir kez yazarsın ve gerisini derleyici doldurur.

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

Temel fikir: auto dinamik tür değildir. Her değişkenin hâlâ derleme zamanında kilitlenmiş tek bir somut türü vardır. auto sadece bunu yazmaktan seni kurtarır.

auto Neden Hakkını Verir

Kısa, bariz türler için auto count = 0; ve int count = 0; eşit derecede okunabilirdir. auto'nun gerçekten kazandırdığı yer uzun, tekrar eden tür adlarıdır - standart kütüphanenin kapsayıcılarından ve yineleyicilerinden gelen türden.

Ayrıntılı sürümü auto sürümüyle karşılaştır:

// auto olmadan - tür etkin biçimde iki kez yazılır
std::vector<std::pair<std::string, int>>::iterator it = scores.begin();

// auto ile - derleyici türü zaten biliyor
auto it = scores.begin();

Her ikisi de tam olarak aynı yineleyici türünü tanımlar. İkincisi okunması daha kolaydır ve daha sonra scores'u farklı bir kapsayıcıya değiştirirsen senkronizasyondan çıkmaz.

İşte tam bir programın içinde:

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

Aralık Tabanlı for Döngülerinde auto

auto ile karşılaşacağın en yaygın yer aralık tabanlı for döngüsüdür. Eleman türünü elle yazmak neredeyse hiç istemezsin ve auto'yu nasıl yazdığın, bir kopya mı yoksa bir referans mı alacağına karar verir.

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

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

    // const auto& - salt okunur, kopya yok. Okuma için olağan varsayılan.
    for (const auto& name : names) {
        cout << name << "\n";
    }
    return 0;
}

Göreceğin üç çeşit ve her birinin anlamı:

• for (auto x : v) - x, her elemanın bir kopyasıdır. int için ucuz, büyük nesneler için savurgan.
• for (auto& x : v) - x bir referanstır; elemanları yerinde değiştirebilirsin.
• for (const auto& x : v) - x salt okunur bir referanstır. Yalnızca okuman gerektiğinde bunu kullan.

Bir sonraki program kapsayıcıyı auto& aracılığıyla değiştirir:

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

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

    for (auto& n : nums) {
        n *= 10;        // gerçek elemanı değiştirir
    }

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

Tuzak: o döngüde for (auto n : nums) (& olmadan) yazarsan, n *= 10 sessizce yalnızca kopyayı değiştirir ve nums'a dokunmaz. Derleyici seni uyarmaz - döngü işe yarar hiçbir şey yapmaz.

auto Neyi Atar

Sade bir auto, türü tıpkı değere göre alınan bir işlev parametresinin yaptığı gibi çıkarır: üst düzey const, referansları ve volatile'i atar. Bu, aksini istemediğin sürece auto'nun sana her zaman taze, değiştirilebilir bir kopya vermesi demektir.

#include <iostream>
using namespace std;

int main() {
    const int original = 42;

    auto copy = original;   // tür int'tir, const int DEĞİL
    copy = 100;             // tamamen yasal - const atıldı

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

const'i korumak veya kopyadan kaçınmak istiyorsan, niteleyicileri kendin eklersin. Kalıp, auto'yu herhangi bir türü süsleyeceğin gibi süslemektir:

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

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

    const auto& ref = name;   // const std::string& - kopya yok, salt okunur
    cout << ref << " has " << ref.size() << " letters\n";

    // ref = "Boris";         // hata: ref const'tur
    return 0;
}

Yani auto, temel türü çıkarır; &, const ve * üstüne eklediğin düğmelerdir. auto türdür, const auto& ise ona salt okunur bir referanstır.

Yaygın Hatalar ve Tuzaklar

auto yazma çabasını ortadan kaldırır, türleri anlama ihtiyacını değil. Yeni başlayanları yakalayan birkaç tuzak var:

Başlatmak zorundasın. auto'nun boş bir bildirimden çıkaracak hiçbir şeyi yoktur, bu yüzden bu kesin bir derleme hatasıdır:

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

Tamsayı değişmezleri int'tir, double değil. auto half = 1 / 2; int çıkarır ve 0 saklar, çünkü 1 / 2, auto onu görmeden önce tamsayı bölmesidir. Tür değeri izler:

#include <iostream>
using namespace std;

int main() {
    auto wrong = 1 / 2;      // tamsayı bölmesi -> 0
    auto right = 1.0 / 2;    // double -> 0.5

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

auto referansı atar - sarkan kopya sürprizlerine dikkat et. Bir işlev bir referans döndürüyorsa ve onu sade auto ile yakalarsan, bir kopya alırsın, ki bu sıcak bir döngüde bazen gerçek bir performans hatasıdır (her yinelemede büyük bir nesnenin derin kopyası). "Bak, ama alma" demek istediğinde const auto&'a uzan.

Önemli olduğunda türü gizleme. auto result = compute();, compute'un dönüş türü bağlamdan bariz olduğunda sorun değil, ama bir okuyucunun result'ın gerçekte ne olduğunu avlaması gerekiyorsa, türü açıkça yazmak daha dostça bir tercih olabilir. auto gürültüyü kesmek içindir, niyeti gizlemek için değil.

Sıradaki: Sabitler ve const

Artık auto'nun, korumasını istemediğin sürece const'i kasıtlı olarak attığını gördün - ki bu bariz soruyu doğurur: const gerçekte neyi garanti eder ve bir değeri en başında ne zaman değiştirilemez olarak işaretlemelisin? Sonraki sayfa const'i, sabit ifadeleri ve "varsayılan olarak const yap"ın neden C++'taki en faydalı alışkanlıklardan biri olduğunu derinlemesine ele alıyor.