vektör :: at ve vektör :: operatörü []

Bunun , / [] operatör hızında C ++ Vector veya :: std :: vector :: at () ile operatör [] << arasındaki benzer sorularda tartışılan sınır kontrolünden at()daha yavaş olduğunu biliyorum << şaşırtıcı sonuçlar !! 5 ila 10 kat daha yavaş / daha hızlı! . Sadece yöntemin ne işe yaradığını anlamıyorum .[]at()

Bunun gibi basit bir vektöre sahipsem: std::vector<int> v(10);ve bir indeksim olduğunda durum at()yerine kullanarak öğelerine erişmeye karar []verirsem ive vektörlerin sınırları içinde olup olmadığından emin değilim, beni onu try-catch ile sarmaya zorluyor blok :

try
{
    v.at(i) = 2;
}
catch (std::out_of_range& oor)
{
    ...
}

size()Dizini kendi başıma kullanarak ve kontrol ederek aynı davranışı elde edebilmeme rağmen , bu benim için daha kolay ve daha uygun görünüyor:

if (i < v.size())
    v[i] = 2;

Öyleyse sorum şu: vector :: at over vector :: operator []
kullanmanın avantajları nelerdir ? Vector :: size + vector :: operator [] yerine
ne zaman vector :: at kullanmalıyım ?

vector::at()Fırlatılan istisnaların , hemen çevreleyen kod tarafından yakalanması amaçlanmadığını söyleyebilirim . Genellikle kodunuzdaki hataları yakalamak için kullanışlıdırlar. Çalışma zamanında sınır kontrolü yapmanız gerekiyorsa, örneğin indeks kullanıcı girdisinden geliyorsa, gerçekten en iyisi bir ififadedir. Özetle, kodunuzu vector::at()asla bir istisna atmayacak şekilde tasarlayın , öyle ki öyle olursa ve programınız iptal edilirse, bu bir hatanın işaretidir. (tıpkı bir gibi assert())

beni try-catch bloğu ile sarmalamaya zorluyor

Hayır değil (dene / yakala bloğu yukarı yönde olabilir). Tanımlanmamış davranış alanına girmek için programınız yerine bir istisna atılmasını istediğinizde kullanışlıdır.

Vektörlere sınır dışı erişimlerin çoğunun bir programcının hatası olduğunu kabul ediyorum (bu durumda assertbu hataları daha kolay bulmak için kullanmanız gerekir; standart kitaplıkların çoğu hata ayıklama sürümü bunu sizin için otomatik olarak yapar). Programcı hatalarını bildirmek için yukarı akışta yutulabilecek istisnaları kullanmak istemezsiniz: hatayı düzeltebilmek istersiniz .

Bir vektöre sınır dışı erişimin normal program akışının bir parçası olması olası olmadığından (bu durumda haklısınız: sizeistisna kabarcıklarının artmasına izin vermek yerine önceden kontrol edin ), teşhisinize katılıyorum: ataslında işe yaramaz.

Vector :: at over vector :: operator [] kullanmanın avantajları nelerdir? Vector :: size + vector :: operator [] yerine ne zaman vector :: at kullanmalıyım?

Buradaki önemli nokta, istisnaların normal kod akışının hata işleme mantığından ayrılmasına izin vermesidir ve tek bir yakalama bloğu, işlev çağrılarının derinliklerine dağılmış olsa bile sayısız fırlatma sitelerinden herhangi birinden üretilen sorunları idare edebilir. Bu nedenle, at()tek bir kullanım için bu çok daha kolay değildir , ancak doğrulamak için çok fazla indekslemeniz olduğunda bazen daha kolay hale gelir ve normal durum mantığını daha az karıştırır.

Bazı kod türlerinde, bir dizinin karmaşık şekillerde artırılması ve sürekli olarak bir dizi aramak için kullanılması da dikkate değerdir. Bu gibi durumlarda, kullanarak doğru kontrolleri sağlamak çok daha kolaydır at().

Gerçek dünya örneği olarak, C ++ 'yı sözcüksel öğelere, ardından bir dizini simge vektörü üzerinde hareket ettiren başka bir koda dönüştüren bir koda sahibim. Karşılaşılan şeye bağlı olarak, aşağıdaki gibi bir sonraki öğeyi artırmak ve kontrol etmek isteyebilirim:

if (token.at(i) == Token::Keyword_Enum)
{
    ASSERT_EQ(tokens.at(++i), Token::Idn);
    if (tokens.at(++i) == Left_Brace)
        ...
    or whatever

Bu tür bir durumda, girdinin sonuna uygunsuz bir şekilde ulaşıp ulaşmadığınızı kontrol etmek çok zordur çünkü bu karşılaşılan tam belirteçlere çok bağlıdır. Her kullanım noktasında açık kontrol acı vericidir ve ön / son artışlar, kullanım noktasındaki sapmalar, daha önceki bazı testlerin devam eden geçerliliği hakkında hatalı muhakeme vb. Başladığı için programcı hatası için çok daha fazla yer vardır.

at vektöre bir işaretçiniz varsa daha net olabilir:

return pVector->at(n);
return (*pVector)[n];
return pVector->operator[](n);

Performans bir yana, bunlardan ilki daha basit ve daha net koddur.

Hata ayıklama yapılarında, at()bundan daha yavaş olacağı garanti edilmez operator[]; Yaklaşık aynı hızda olmalarını beklerdim. Aradaki fark, at()bir sınır hatası (bir istisna) olduğunda tam olarak ne olacağını belirtmesidir; burada olduğu gibi operator[], bu tanımsız bir davranıştır - kullandığım tüm sistemlerde (g ++ ve VC ++) bir çökme, en azından ne zaman normal hata ayıklama bayrakları kullanılır. (Diğer bir fark, kodumdan emin olduğumda operator[], hata ayıklamayı kapatarak önemli bir hız artışı elde edebilirim . Performans gerektiriyorsa - gerekmedikçe yapmam.)

Uygulamada at()nadiren uygundur. Bağlam, dizinin geçersiz olabileceğini bildiğiniz şekildeyse, muhtemelen açık testi istersiniz (örneğin, bir varsayılan değer veya başka bir şey döndürmek için) ve geçersiz olamayacağını biliyorsanız, iptal etmek istersiniz (ve eğer geçersiz olup olmayacağını bilmiyorsanız, fonksiyonunuzun arayüzünü daha kesin olarak belirlemenizi öneririm). Bununla birlikte, geçersiz dizinin kullanıcı verilerinin ayrıştırılmasından kaynaklanabileceği ve hatanın tüm isteğin iptal edilmesine (ancak sunucuyu kapatmamasına) neden olması gereken birkaç istisna vardır; bu gibi durumlarda, bir istisna uygundur ve at()bunu sizin için yapar.

İstisnaları kullanmanın tüm amacı, hata işleme kodunuzun daha uzakta olabileceğidir.

Bu özel durumda, kullanıcı girdisi gerçekten iyi bir örnektir. Dahili olarak depoladığınız bir tür kaynağa başvurmak için indeksleri kullanan bir XML veri yapısını anlamsal olarak analiz etmek istediğinizi hayal edin std::vector. Şimdi XML ağacı bir ağaçtır, bu yüzden muhtemelen onu analiz etmek için özyinelemeyi kullanmak istersiniz. Özyinelemenin derinliklerinde, XML dosyasının yazarı tarafından bir erişim ihlali olabilir. Bu durumda, genellikle tüm özyineleme düzeylerinden çıkıp tüm dosyayı (veya herhangi bir "daha kaba" yapıyı) reddetmek istersiniz. İşte burada işe yarıyor. Analiz kodunu, dosya geçerliymiş gibi yazabilirsiniz. Kütüphane kodu, hata tespitini halleder ve hatayı sadece kaba seviyede yakalayabilirsiniz.

Ayrıca, gibi diğer kapsayıcılar std::mapda : at std::map::atöğesinden biraz farklı anlamlara sahip olanlara std::map::operator[]sahipken sabit bir haritada kullanılabilirken kullanılamaz operator[]. Şimdi ya da ele alabileceği bir şey gibi, yazma konteyner agnostik kodu istiyorsa const std::vector<T>&ya const std::map<std::size_t, T>&, ContainerType::atseçtiğiniz silah olacaktır.

Bununla birlikte, tüm bu durumlar genellikle bir tür doğrulanmamış veri girişi işlenirken ortaya çıkar. Eğer geçerli aralık yaklaşık eminseniz genellikle olması gerektiği gibi, genellikle kullanabilirsiniz operator[], ancak daha iyisi, ile yineleyiciler begin()ve end().

Bu makaleye göre , performans bir yana, kullanımda herhangi bir fark yaratmaz atveya operator[]sadece erişimin vektör boyutu içinde olması garanti edilirse. Aksi takdirde, erişim sadece vektörün kapasitesine bağlıysa, kullanımı daha güvenlidir at.

Not: Görünüşe göre bazı yeni insanlar neyin yanlış olduğunu söyleme nezaketine sahip olmadan bu yanıta olumsuz oy veriyor. Cevap Aşağıda doğrudur ve doğrulanabilir burada .

Gerçekten tek bir fark var: atsınırlar kontrol edilirken kontrol operator[]edilmiyor. Bu, hata ayıklama yapılarının yanı sıra sürüm yapıları için de geçerlidir ve bu, standartlar tarafından çok iyi belirtilmiştir. Bu kadar basit.

Bu, atdaha yavaş bir yöntemdir, ancak aynı zamanda kullanmamak için gerçekten kötü bir tavsiye at. Göreli sayılara değil, mutlak sayılara bakmalısınız. Kodunuzun çoğunun daha pahalı işlemler yaptığına güvenle bahse girebilirim at. Şahsen kullanmaya çalışıyorum atçünkü kötü bir hatanın tanımsız davranışlar yaratmasını ve üretime gizlice girmesini istemiyorum.