C ++ 03'te 'auto' anahtar sözcüğünü kullanmak için herhangi bir neden var mı?

Bu sorunun ilk olarak 2009'da, C ++ 11 onaylanmadan önce ve autoanahtar kelimenin anlamı büyük ölçüde değiştirilmeden önce yayınlandığını unutmayın . Verilen yanıtlar, yalnızca C ++ 03'ün anlamı ile ilgilidir auto- bu, belirtilen bir depolama sınıfıdır - ve C ++ 11'in anlamı auto- otomatik tür kesintisi değildir. C ++ 11'i ne zaman kullanacağınızla ilgili tavsiye arıyorsanız auto, bu soru bu soruyla alakalı değildir.

En uzun süre, kullanmak için bir neden olmadığını düşündüm. static anahtar kelimeyi C'de , çünkü blok kapsamının dışında bildirilen değişkenler dolaylı olarak küreseldi. Sonra, bir değişkeni staticblok kapsamı içinde ilan etmenin ona kalıcı bir süre vereceğini ve onu blok kapsamı dışında (program kapsamında) ilan etmenin ona dosya kapsamı vereceğini keşfettim (sadece bu derleme biriminde erişilebilir).

Yani bu bana, henüz tam olarak anlamadığım (belki de) tek bir anahtar kelime bırakıyor: autoAnahtar kelime. Bunun 'yerel değişken'den başka bir anlamı var mı? Kullanmak isteyebileceğiniz her yerde sizin için dolaylı olarak yapılmayan herhangi bir şey? Bir autodeğişken program kapsamında nasıl davranır? static autoDosya kapsamındaki bir değişken nedir ? Bu anahtar kelimenin tamlık için var olmaktan başka bir amacı var mı ?

autobir depolama sınıfı belirteci, static, registerveextern de. Bir bildirimde bu dördünden yalnızca birini kullanabilirsiniz.

Yerel değişkenler (olmadan static ) otomatik depolama süresine sahiptir, bu da tanımlarının başından bloklarının sonuna kadar yaşadıkları anlamına gelir. Auto'yu onların önüne koymak gereksizdir çünkü zaten bu varsayılandır.

C ++ 'da kullanmak için herhangi bir neden bilmiyorum. Örtük int kuralı olan eski C sürümlerinde, aşağıdaki gibi bir değişken bildirmek için kullanabilirsiniz:

int main(void) { auto i = 1; }

iKapsam dahilinde olması durumunda sözdizimini geçerli kılmak veya bir atama ifadesinden netleştirmek için . Ancak bu zaten C ++ 'da çalışmaz (bir tür belirtmeniz gerekir). Yeterince komik, C ++ Standardı şöyle yazıyor:

Blok kapsamında depolama sınıfı belirticisi olmadan veya bir işlev parametresi olarak bildirilen bir nesne, varsayılan olarak otomatik depolama süresine sahiptir. [Not: dolayısıyla, otomatik tanımlayıcı neredeyse her zaman gereksizdir ve sıklıkla kullanılmaz; auto'nun bir kullanımı, bir bildirim-ifadeyi bir ifade-ifadeden (6.8) açıkça ayırmaktır. - son not]

olan bir döküm ya da aşağıdaki gibi olabilir senaryoda, değinmektedir aiçin intya da bir değişken bildirimi aÇeşidi intçevresinde yedek parantez sahip olan a. Her zaman bir beyan olarak alınır, bu yüzden autoburada yararlı bir şey eklemeyin, bunun yerine insan için olur. Ama sonra yine, insan etrafındaki gereksiz parantezleri kaldırsa daha iyi aolurdu, derdim:

int(a);

autoC ++ 0x ile gelmenin yeni anlamı ile, onu C ++ 03'ün koddaki anlamı ile kullanmaktan vazgeçerdim.

C ++ 11'de autoyeni bir anlama sahiptir: bir değişkenin türünü otomatik olarak çıkarmanıza izin verir.

Bu neden her zaman işe yarar? Basit bir örneği ele alalım:

std::list<int> a;
// fill in a
for (auto it = a.begin(); it != a.end(); ++it) {
  // Do stuff here
}

autoTüründe bir yineleyici orada yaratır std::list<int>::iterator.

Bu, bazı ciddi karmaşık kodların okunmasını çok daha kolay hale getirebilir.

Başka bir örnek:

int x, y;
auto f = [&]{ x += y; };
f();
f();

Burada, autobir değişkende bir lambda ifadesini depolamak için gereken tür çıkarıldı. Wikipedia, konu hakkında iyi bir haber içeriyor.

Auto anahtar kelimesinin şu anda bir amacı yok. Yerel bir değişkenin varsayılan depolama sınıfını yeniden ifade ettiği konusunda tam olarak haklısınız, gerçekten kullanışlı bir alternatif static.

Bu sahiptir yepyeni bir anlam C ++ 0x ile. Bu size ne kadar işe yaramaz olduğuna dair bir fikir verir!

GCC, autoiç içe geçmiş işlevler için özel bir kullanıma sahiptir - buraya bakın .

Tanımından önce çağırmak istediğiniz yuvalanmış işleviniz varsa, ile bildirmeniz gerekir auto.

"auto", derleyiciye değişkeni (bellek veya kayıt) nereye koyacağına kendisi karar vermesini söyler. Onun analogu "register" dır ve derleyiciye onu bir kayıtta tutmaya çalışmasını söyler. Modern derleyiciler her ikisini de görmezden gelir, bu yüzden siz de yapmalısınız.

Bu anahtar sözcüğü, işlev için kritik olduğunda, değişken yığın tabanlı işlemciler için yığına yerleştirileceğini açıkça belgelemek için kullanıyorum. Bu işlev, bir işlevden dönmeden (veya hizmet rutinini kesmeden) önce yığını değiştirirken gerekli olabilir. Bu durumda beyan ederim:

auto unsigned int auiStack[1];   //variable must be on stack

Ve sonra değişkenin dışına erişiyorum:

#define OFFSET_TO_RETURN_ADDRESS 8     //depends on compiler operation and current automatics
auiStack[OFFSET_TO_RETURN_ADDRESS] = alternate_return_address;

Dolayısıyla autoanahtar kelime, amacı belgelemeye yardımcı olur.

Stroustrup'a göre, "The C Programming Language" (4. Baskı, C 11'i kapsayan), 'auto' kullanımının aşağıdaki ana nedenleri vardır (bölüm 2.2.2) (Stroustrup sözcükleri alıntılanmıştır):

1)

Tanım, türü kodumuzun okuyucuları tarafından açıkça görülebilir hale getirmek istediğimiz geniş bir kapsamdadır.

'Auto' ve gerekli başlatıcı ile değişkenin türünü bir bakışta öğrenebiliriz!

2)

Değişkenin aralığı veya hassasiyeti hakkında açık olmak istiyoruz (örneğin, float yerine çift)

Bence buraya uyan bir durum şuna benzer:

   double square(double d)
    {
        return d*d; 
    }

    int square(int d)
    {
        return d*d; 
    }

    auto a1 = square(3);

    cout << a1 << endl;

    a1 = square(3.3);

    cout << a1 << endl;

3)

'Auto' kullanarak fazlalıktan ve uzun tip isimler yazmaktan kaçınırız.

Şablon haline getirilmiş bir yineleyiciden uzun bir tür adı düşünün:

(bölüm 6.3.6.1'deki kod)

template<class T> void f1(vector<T>& arg) {
    for (typename vector<T>::iterator p = arg.begin(); p != arg.end();   p)
        *p = 7;

    for (auto p = arg.begin(); p != arg.end();   p)
        *p = 7;
}

Eski derleyicide auto, yerel bir değişkeni bildirmenin bir yoluydu. Turbo C gibi eski derleyicilerde auto anahtar sözcüğü veya benzeri olmadan yerel değişkenler bildiremezsiniz.

STL MSDN'ın Kanal 9 Alanda bulunan C ++ 0 x oto anahtar kelimenin yeni bir anlam, bir serbestçe görüntülenebilir / indirilebilir video dersinde Microsoft'un Stephan T. Lavavej tarafından çok güzel tarif edilir burada .

Ders bütünüyle izlenmeye değer, ancak auto anahtar kelimesiyle ilgili kısım yaklaşık 29. dakika işaretindedir (yaklaşık olarak).

"Otomatik" için "yerel değişken" dışında başka bir anlam var mı?

C ++ 03'te değil.

Kullanmak isteyebileceğiniz her yerde sizin için örtük olarak yapılmayan herhangi bir şey?

C ++ 03'te hiçbir şey yok.

Otomatik değişken program kapsamında nasıl davranır? Dosya kapsamındaki statik otomatik değişkenden ne haber?

Bir işlev / yöntem gövdesi dışında anahtar kelimeye izin verilmez.

Bu anahtar kelimenin [C ++ 03'te] tamlık için var olmaktan başka herhangi bir amacı var mı?

Şaşırtıcı bir şekilde, evet. C ++ tasarım kriterleri, C ile yüksek derecede geriye dönük uyumluluk içeriyordu. C bu anahtar kelimeye sahipti ve onu yasaklamak veya C ++ 'da anlamını yeniden tanımlamak için gerçek bir neden yoktu. Yani amaç, C ile bir uyumsuzluk eksikliğiydi.

Bu anahtar kelimenin C'de tamlık için var olmaktan başka herhangi bir amacı var mı?

Yakın zamanda bir tane öğrendim: B'den eski programları taşıma kolaylığı, sözdizimi C'ye oldukça benzeyen B adlı bir dilden gelişti. Ancak, B'nin hiçbir türü yoktu. B'de bir değişkeni tanımlamanın tek yolu, depolama türünü ( autoveya extern) belirlemekti. Bunun gibi:

oto i;

Bu söz dizimi hala C'de çalışır ve eşdeğerdir

int i;

çünkü C'de, depolama sınıfı varsayılan değerine autove tür varsayılan değerine ayarlanır int. Sanırım, B'de ortaya çıkan ve C'ye taşınan her bir program o sırada tam anlamıyla autodeğişkenlerle doluydu .

C ++ 03 artık C stili örtük int'e izin vermiyor, ancak artık tam olarak kullanışlı olmayan autoanahtar kelimeyi korudu çünkü örtük int'in aksine C'nin sözdiziminde herhangi bir soruna neden olduğu bilinmiyordu.