#include <vector>
#include <string>
#include <map>

int main() {
    auto i = 10; // i bir int türündedir
    auto d = 3.14; // d bir double türündedir
    auto s = "Merhaba Dünya"; // s bir const char* türündedir

    std::vector<int> numbers = {1, 2, 3, 4, 5};
    // Uzun tür adlarını kısaltmak için harika:
    for (auto it = numbers.begin(); it != numbers.end(); ++it) {
        // it'in türü std::vector<int>::iterator
    }

    // C++11 Range-based for döngüsü ile daha da basit:
    for (auto num : numbers) {
        // num'un türü int (değer kopyası)
    }
    
    // Eğer referans istiyorsak:
    for (auto& num_ref : numbers) {
        // num_ref'in türü int& (referans)
    }
    
    // C++14 ile lambda parametrelerinde auto kullanımı:
    auto sum = [](auto a, auto b) { 
        return a + b; 
    };
    
    // sum(5, 10) çağrıldığında int, sum(3.5, 2.1) çağrıldığında double çıkarılır.

    // C++14 ile fonksiyon dönüş türlerinde auto kullanımı:
    auto multiply = [](int x, int y) { 
        return x * y; // Dönüş türü int olarak çıkarılır
    };

    std::map<std::string, int> ages;
    ages["Alice"] = 30;
    ages["Bob"] = 25;
    
    // std::pair<const std::string, int> olarak çıkarılır
    for (const auto& pair : ages) {
        // pair.first bir const std::string&, pair.second bir const int&
    }

    return 0;
}

template<typename T>
void func(T param);
// auto x = expr; ifadesi, func(expr); çağrılmış gibi T'nin türünü çıkarır.

• Değer Kopyalama (Value Copy): Başlatıcı ifade bir referans veya const niteliğe sahipse, auto varsayılan olarak bu nitelikleri çıkarmaz, sadece temel türü (decayed type) çıkarır. Örneğin, `const int&` türündeki bir ifade için `auto` sadece `int` çıkarır. Eğer referans veya const nitelikleri korunmak isteniyorsa, `auto&` veya `const auto&` kullanılmalıdır.
• Dizi ve Fonksiyon Decay: Diziler `pointer`'a, fonksiyonlar `function pointer`'a dönüşür (decay). Örneğin, `auto arr = {1, 2, 3};` hatalıdır çünkü bir diziye auto ile doğrudan tür çıkarımı yapılamaz (C++11/14'te initializer listeler için özel kurallar vardır, C++17 ile `auto x = {1,2,3};` `std::initializer_list<int>` olarak çıkarılır).

• Kodun Kısalığı ve Okunabilirliği: Özellikle uzun şablon türlerinde, kodu çok daha kısa ve okunabilir hale getirir. Örneğin, `std::map<std::string, std::vector<std:air<int, double>>>::iterator` yerine sadece `auto` kullanmak.
• Refactoring Kolaylığı: Bir ifadenin türü değiştiğinde, auto kullanılan yerlerde manuel tür güncellemeleri yapmaya gerek kalmaz.
• Performans: Bazı durumlarda (örneğin, lambda'lar veya karmaşık kütüphane nesneleri), auto ile derleyicinin optimal türü seçmesi, elle yazılan türden daha verimli olabilir.
• Doğruluk: İnsan hatasıyla yanlış tür yazma olasılığını ortadan kaldırır. Derleyici her zaman doğru türü çıkaracaktır.

• Tür Açıklığının Kaybolması: Temel türlerde (int, double vb.) auto kullanmak, kodun amacını veya türün boyutunu belirsizleştirebilir. Örneğin, `auto count = some_function();` ifadesinde `count`'un `int` mi, `long` mu, yoksa `size_t` mi olduğunu anlamak için `some_function`'ın tanımına bakmak gerekebilir.
• Beklenmeyen Türler (Type Decay): Yukarıda belirtildiği gibi, auto bazı durumlarda referans veya const niteliklerini düşürebilir, bu da beklenmeyen kopyalamalara veya davranışlara yol açabilir. Örneğin:
  
  Kod:

  int x = 5;
  const int& rx = x;
  auto val = rx; // val bir int'tir, rx'in const veya referans özelliği kaybolur.

• Çoklu Değişken Tanımlamaları: `auto x = 1, y = 2.0;` gibi tanımlamalar hatalıdır, çünkü auto aynı bildirimdeki tüm değişkenler için aynı türü çıkarmalıdır. Burada `1` için `int`, `2.0` için `double` çıkarılacağı için çelişki oluşur.

• Eğer ifade bir lvalue ise, decltype bir lvalue referans türü çıkarır (örn: `int&`).
• Eğer ifade bir prvalue (veya xvalue) ise, decltype bir prvalue türü çıkarır (örn: `int`).
• Tüm `const` ve `volatile` niteleyicileri korunur.

• Fonksiyon Dönüş Türleri: Bu, decltype(auto)'nun en yaygın ve faydalı kullanım alanıdır. Özellikle, jenerik bir fonksiyonda, dönüş değerinin çağrı argümanlarının değer kategorisine ve referans niteliklerine bağlı olmasını istediğimizde kullanılır. Bu, mükemmel iletmeyi (perfect forwarding) kolaylaştırır.
  
  Kod:

  template<typename T>
  decltype(auto) pick_first(T&& arg1, T&& /*arg2*/) {
      // arg1'in değer kategorisi ve referans niteliği korunur
      return std::forward<T>(arg1);
  }
  
  int main() {
      int a = 10;
      int& b = pick_first(a, 20); // b bir int& olur
  
      int c = pick_first(100, 200); // c bir int olur (prvalue döndüğü için)
  
      // Bu, auto kullanılsaydı farklı olurdu:
      // auto d = pick_first(a, 20); // d bir int olur, referans kaybedilir.
      return 0;
  }

• Değişken Bildirimleri: Teorik olarak decltype(auto) değişken bildirimlerinde de kullanılabilir, ancak genellikle auto'dan daha az yaygındır ve potansiyel olarak kodun okunabilirliğini azaltabilir. Ancak, eğer bir ifadenin tam türünü (referans nitelikleri dahil) korumak kritikse kullanılabilir.
  
  Kod:

  int x = 10;
  int& ref_x = x;
  
  decltype(auto) var1 = x;      // var1 türü int
  decltype(auto) var2 = (x);    // var2 türü int& (parantezler lvalue ifadesi yapar)
                                 // Bu, decltype'ın kendi kuralıdır, ifadenin lvalue olup olmadığına bakar.
                                 // (x) bir lvalue ifadesidir.
  
  const int cx = 5;
  decltype(auto) var3 = cx;     // var3 türü const int
  const int& cref_cx = cx;
  decltype(auto) var4 = cref_cx; // var4 türü const int& (referans korunur)

• Ne Zaman auto Kullanmalı:
  • Değişkenlerin türlerinin açıkça belirtilmesinin kodu karmaşıklaştırdığı durumlarda (uzun yineleyici türleri, lambda ifadeleri, şablon dönüş değerleri).
  • Bir değerin kopyasını veya temel türünü istediğinizde.
  • C++17 ile birlikte yapısal bağlamalar (structured bindings) ile kullanıldığında.
  • Basit lambda parametrelerinde (generic lambdas).
• Ne Zaman decltype(auto) Kullanmalı:
  • Bir fonksiyonun dönüş türünün, çağrı argümanlarının değer kategorisine ve referans niteliğine bağlı olmasına ihtiyacınız olduğunda (özellikle mükemmel iletme senaryolarında).
  • Kesinlikle bir ifadenin 'tam' türünü, yani referans ve const/volatile niteliklerini de içeren türünü korumanız gerektiğinde. Bu genellikle std::forward ile birlikte kullanılır.
  • Bir değişkeni bir ifadeye initialize ederken, ifadenin tam türünü korumak istediğiniz çok nadir durumlarda.

"Use `auto` for variables unless you have a reason not to. Use `decltype(auto)` for return types when perfect forwarding the return value of an expression." - Modern C++ Topluluğu Genel Kanısı

Genişletmek için tıkla ...

• Tür Açıklığı İçin Dikkat: API'lerde veya temel türlerde `auto` kullanmaktan kaçının, çünkü bu, kullananlar için türün ne olduğunu anlamayı zorlaştırabilir. Dahili kodda ve karmaşık türlerde `auto` tercih edilebilir.
• `const` ve Referanslara Dikkat: `auto` ile birlikte `const` ve `&` veya `&&` niteleyicilerini kullanarak, çıkarılan türün tam olarak ne olduğunu kontrol edin. `auto&` veya `const auto&` kullanmak sıkça tercih edilen bir yaklaşımdır.
• İlklendirme Zorunluluğu: auto ile bildirilen her değişken mutlaka ilklendirilmelidir. Bu, iyi bir pratik olmakla birlikte, auto'nun bir gerekliliğidir.
• Kod Okunabilirliği: Bazen, karmaşık bir ifade için `auto` kullanmak yerine, ara değişkenlere açıkça tür vererek kodu daha anlaşılır hale getirmek daha iyi olabilir. Amacınız her zaman 'en kısa kod' değil, 'en okunabilir ve sürdürülebilir kod' olmalıdır.
• Diziler ve İlklendirme Listeleri: `auto` ile dizilerin ve `std::initializer_list`'lerin davranışına dikkat edin. Özellikle C++17 öncesi sürümlerde, `auto list = {1,2,3};` bir `std::initializer_list` olarak değil, derleme hatası olarak sonuçlanabilir veya yanlış tür çıkarabilir. C++17 ve sonrası için bu sorun çözülmüştür.