İşlev yanlışlıkla referans parametresini geçersiz kılar - yanlış giden ne?

Bugün sadece zaman zaman belirli platformlarda meydana gelen iğrenç bir hatanın nedenini bulduk. Kaynatılmış, kodumuz şöyle görünüyordu:

class Foo {
  map<string,string> m;

  void A(const string& key) {
    m.erase(key);
    cout << "Erased: " << key; // oops
  }

  void B() {
    while (!m.empty()) {
      auto toDelete = m.begin();
      A(toDelete->first);
    }
  }
}

Sorun bu basitleştirilmiş durumda açık görünebilir: basmaya başlamadan önce harita girişini kaldıran Banahtara anahtar Agönderir. (Bizim durumumuzda, basılmadı, ancak daha karmaşık bir şekilde kullanıldı) Bu elbette tanımsız bir davranış, çünkü keyçağrıdan sonra sarkan bir referans erase.

Bunu düzeltmek önemsizdi - biz sadece parametre türünü olarak const string&değiştirdik string. Soru şu: En başta bu böceği nasıl önleyebilirdik? Her iki fonksiyon da doğru olanı yapmış görünüyor:

• Akeyimha etmek üzere olduğu şeyi ifade ettiğini bilmenin hiçbir yolu yoktur .
• Biletmeden önce bir kopyasını almış olabilirdi A, ancak parametreleri değere mi yoksa referansa göre mi almayacağına karar vermek Callee'nin işi değil mi?

Takip edemediğimiz bazı kurallar var mı?

Akeyimha etmek üzere olduğu şeyi ifade ettiğini bilmenin hiçbir yolu yoktur .

Bu doğru olsa da A, aşağıdakileri biliyor:

1. Amacı bir şeyi yok etmektir .

2. Yok edeceği şeyin aynısı olan bir parametre alır .

Bu gerçekler göz önüne alındığında, bunun mümkün için Abir işaretçi / referans olarak parametre alırsa kendi parametreyi yok etmek. C ++ 'da bu gibi hususların ele alınması gereken tek yer burası değil.

Bu durum, bir operator=görevlendirme operatörünün niteliğinin, kendi kendine görevlendirme konusunda endişelenmeniz gerekebileceği anlamına benzer . Bu bir olasılıktır çünkü thisreferans parametresinin tipi ve tipi aynıdır.

Bunun sadece sorunlu olduğu unutulmamalıdır, çünkü Adaha keysonra girişi kaldırdıktan sonra parametreyi kullanmak niyetindedir . Olmasaydı, o zaman iyi olurdu. Tabii ki, o zaman her şey mükemmel, sonra birisi değiştirir çalışma olması kolaylaşır Akullanımı keypotansiyel tahrip edildikten sonra.

Bir yorum için iyi bir yer olurdu.

Takip edemediğimiz bazı kurallar var mı?

C ++ 'da, bir dizi kurala uymazsanız, kodunuzun% 100 güvenli olacağı varsayımı altında çalışamazsınız. Biz kuralları olamaz şeyi .

Yukarıdaki 2. maddeyi düşünün. Aanahtardan farklı türde bir parametre almış olabilir, ancak nesnenin kendisi haritada bir anahtarın alt nesnesi olabilir. C ++ 14'te, findaralarında geçerli bir karşılaştırma olduğu sürece, anahtar türünden farklı bir tür alabilir. Yani yaparsanız m.erase(m.find(key)), parametre türü anahtar tür olmasa da parametreyi yok edebilirsiniz.

Yani "parametre tipi ve anahtar tipi aynı ise, değere göre al" gibi bir kural sizi kurtarmaz. Bundan daha fazla bilgiye ihtiyacınız olacak.

Sonuç olarak, özel kullanım durumlarınıza ve egzersiz kararınıza dikkat edin, deneyimlerden haberdar olun.

Evet derdim, seni kurtaracak basit bir kural var: Tek sorumluluk ilkesi.

Şu anda, Abir öğeyi bir haritadan kaldırmak için kullandığı ve başka bir işlemden geçirilen bir parametre (yukarıda gösterildiği gibi yazdırılıyor, görünüşe göre gerçek kodda başka bir şey) geçiriliyor. Bu sorumlulukları birleştirmek bana sorunun kaynağını gösteriyor.

Biz bir o fonksiyonu varsa , sadece haritadan değerini siler ve bu başka sadece haritadan bir değerin işlemleri yapar, daha yüksek seviyeli kodundan her demelisiniz, bu yüzden böyle bir şey ile bitirmek istiyorum :

std::string &key = get_value_from_map();
destroy(key);
continue_to_use(key);

Kabul ediyorum, kullandığım isimler hiç kuşkusuz problemi gerçek isimlerden daha açık hale getiriyor, ancak isimler hiç anlamlı değilse, referansı kullanmaya devam etmeye çalıştığımızı açıkça belirtmek için neredeyse kesinler. geçersiz kılındı. Bağlamın basit bir şekilde değiştirilmesi sorunu daha açık hale getirir.

Takip edemediğimiz bazı kurallar var mı?

Evet, işlevi belgelendirmediniz .

Parametre geçiren sözleşmenin bir açıklaması olmadan (özellikle parametrenin geçerliliği ile ilgili kısım - işlev çağrısının başında mı yoksa başından beri), hatanın uygulamada olup olmadığını söylemek mümkün değildir (çağrı sözleşmesi varsa) Çağrı başladığında parametrenin geçerli olması, işlevin parametreyi geçersiz kılabilecek herhangi bir eylemi gerçekleştirmeden önce bir kopyasını alması gerekir) veya arayanda (çağrı sözleşmesi parametrenin çağrı boyunca geçerli kalması gerekiyorsa, çağrı yapamaz. değiştirilen koleksiyonun içindeki verilere bir başvuru iletin).

Örneğin, C ++ standardının kendisi şunları belirtir:

Bir işleve yapılan argüman geçersiz bir değere sahipse (işlev alanının dışındaki bir değer veya amaçlanan kullanımı için geçersiz bir işaretçi gibi), davranış tanımsızdır.

ancak bunun yalnızca aramanın yapıldığı anda mı, yoksa işlevin yürütülmesi sırasında mı uygulanacağını belirleyemez. Ancak, çoğu durumda yalnızca ikincisinin mümkün olduğu açıktır - yani, bir kopya yaparak argüman geçerli olamayacağı zaman.

Bu ayrımın devreye girdiği birkaç gerçek dünya vakası vardır. Örneğin, kendine bir eklemestd::vector<T>

Takip edemediğimiz bazı kurallar var mı?

Evet, doğru şekilde test etmediniz. Yalnız değilsin ve öğrenmek için doğru yerdesin :)

C ++ 'un Tanımsız Davranışı, Tanımsız Davranışı ince ve can sıkıcı yollarla gösterir.

Muhtemelen% 100 güvenli C ++ kodu yazamazsınız, ancak bir takım araçlar kullanarak yanlışlıkla Tanımsız Davranışı kod tabanınıza sokma olasılığını azaltabilirsiniz.

1. Derleyici uyarıları
2. Statik Analiz (uyarıların genişletilmiş versiyonu)
3. Aletli Test İkilileri
4. Sertleştirilmiş Üretim İkilileri

Sizin durumunuzda, (1) ve (2) 'nin çok yardımcı olacağından şüpheliyim, genel olarak bunları kullanmanızı tavsiye ederim. Şimdilik diğer ikisine konsantre olalım.

Hem gcc hem de Clang -fsanitize, derlediğiniz programları çeşitli sorunları kontrol etmek için hangi enstrümanlara yerleştiren bir bayrağa sahiptir. -fsanitize=undefinedörneğin, işaretli tamsayı akış / taşma, çok yüksek miktar, vb. ile kayma yakalar ... Özel durumunuzda -fsanitize=addressve -fsanitize=memoryişlevi çağırmak için bir test yaptırmanız şartıyla, sorunun üstesinden gelebilir. Tamamlanması için, -fsanitize=threadçok iş parçacıklı bir kod tabanınız varsa kullanmaya değer. İkili dosyayı uygulayamıyorsanız (örneğin, kaynakları olmadan 3. taraf kütüphaneleriniz var), valgrindgenel olarak daha yavaş olmasına rağmen kullanabilirsiniz .

Son derleyicilerde ayrıca zenginleştirme olanakları bulunur . Aletli ikili sistemlerle temel fark, sertleştirme kontrollerinin performans üzerinde düşük bir etkiye sahip olacak şekilde tasarlanmaları (<% 1), genel olarak üretim koduna uygun olmalarıdır. En iyi bilinen, yığın çökmesini önleme saldırılarını ve sanal işaretçi hi-jackingini kontrol akışını düşürmenin diğer yollarının arasına yerleştirmek için tasarlanmış CFI kontrolleridir (Kontrol Akışı Bütünlüğü).

Hem (3) hem de (4) ' ün amacı aralıklı bir arızayı belirli bir arızanın içine dönüştürmektir : her ikisi de arızalı hızlı prensibini izler . Bu şu demek:

• mayına bastığınızda her zaman başarısız olur
• hemen başarısızlığa uğrar , hatayı rasgele bozmak yerine sizi hatayı işaret eder, vb.

İyi bir test kapsamı ile (3) birleştirmek, üretime başlamadan önce çoğu sorunu yakalamalıdır. Üretimde (4) kullanımı can sıkıcı bir hata ve bir istismar arasındaki fark olabilir.

@ not: bu yayın sadece Ben Voigt'in cevabının üstüne daha fazla argüman ekler .

Soru şu: En başta bu böceği nasıl önleyebilirdik? Her iki fonksiyon da doğru olanı yapmış gibi görünüyor:

• Bir anahtarın, imha etmek üzere olduğu şeyi ifade ettiğini bilmenin bir yolu yoktur.
• B, A'ya geçmeden önce bir kopya yapmış olabilir, ancak parametrelerin değere mi yoksa referansa göre mi alınacağına karar vermek, çalışanın işi değil mi?

Her iki fonksiyon da doğru olanı yaptı.

Sorun, A çağrısının yan etkilerini dikkate almayan müşteri kodunda .

C ++ 'ın dilde yan etkileri belirtmenin doğrudan bir yolu yoktur.

Bu, yan etkiler gibi şeylerin kodda (dokümantasyon olarak) görünür olduğundan ve kodla korunulduğundan (muhtemelen ön koşulları, post-koşullarını ve değişmezleri belgelemeyi düşünmelisiniz) aynı zamanda görünürlük nedenleriyle de).

Kod değişikliği:

class Foo {
  map<string,string> m;

  /// \sideeffect invalidates iterators
  void A(const string& key) {
    m.erase(key);
    cout << "Erased: " << key; // oops
  }
  ...

Bu noktadan sonra, size bunun için bir birim testi yaptırmanız gerektiğini söyleyen API'nin üzerinde bir şey vardır; Ayrıca, API'nin nasıl kullanılacağını (ve kullanılmayacağını) da söyler.

İlk başta bu böceği nasıl önleyebilirdik?

Hatalardan kaçınmanın tek bir yolu var: kod yazmayı bırakın. Her şey bir şekilde başarısız oldu.

Bununla birlikte, kodun çeşitli düzeylerde test edilmesi (birim testleri, fonksiyonel testler, entegrasyon testleri, kabul testleri, vb.) Yalnızca kod kalitesini iyileştirmez, aynı zamanda hataları azaltır.