Bir C ++ programcısının bilmesi gereken yaygın tanımsız davranışlar nelerdir? [kapalı]

Bir C ++ programcısının bilmesi gereken yaygın tanımsız davranışlar nelerdir?

De ki:

a[i] = i++;

Işaretçi

• NULLİşaretçinin kaydının silinmesi
• Sıfır boyutta "yeni" bir ayırma ile döndürülen bir işaretçinin kaydı silme
• Ömrü sona eren nesnelere işaretçi kullanma (örneğin, ayrılmış nesneleri veya silinmiş nesneleri yığınlama)
• Henüz tamamen başlatılmamış bir işaretçiyi kaydı silme
• Bir dizinin sınırları dışında (üstünde veya altında) sonuç veren işaretçi aritmetiği gerçekleştirmek.
• İşaretçiyi dizinin sonunun ötesinde bir yerde kaydı silme.
• İşaretçileri uyumsuz türdeki nesnelere dönüştürme
• memcpyÇakışan arabellekleri kopyalamak için kullanma .

Arabellek taşmaları

• Negatif olan veya bir nesnenin boyutunun ötesinde (yığın / yığın taşması) bir nesnede veya dizide okuma veya yazma

Tamsayı Taşmaları

• İmzalı tamsayı taşması
• Matematiksel olarak tanımlanmamış bir ifadeyi değerlendirme
• Negatif bir miktara göre sola kaydırma değerleri (negatif miktarlara göre sağa kaydırma uygulamaları tanımlanmıştır)
• Değerleri sayıdaki bit sayısından büyük veya ona eşit bir miktarda kaydırma (ör int64_t i = 1; i <<= 72. Tanımsız)

Türleri, Döküm ve İnş

• Hedef türle temsil edilemeyen bir değere sayısal bir değer atama (doğrudan veya static_cast aracılığıyla)
• Kesin olarak atanmadan önce otomatik bir değişken kullanma (ör. int i; i++; cout << i;)
• Bir sinyalin alındığı volatileveya sig_atomic_talındığı herhangi bir türde nesnenin değerini kullanma
• Bir dize hazır bilgisini veya başka herhangi bir const nesnesini kullanım ömrü boyunca değiştirmeye çalışmak
• Ön işleme sırasında dar bir alanı geniş bir dize değişmeziyle birleştirmek

İşlev ve Şablon

• Değer döndürme işlevinden değer döndürmeme (doğrudan veya bir try-block'tan akarak)
• Aynı varlık için birden fazla farklı tanım (sınıf, şablon, numaralandırma, satır içi işlev, statik üye işlevi, vb.)
• Şablonların somutlaştırılmasında sonsuz özyineleme
• Bir işlevi farklı parametreler kullanarak veya işlevin kullanım olarak tanımlandığı parametrelerle bağlantıyla çağırma.

OOP

• Statik depolama süresine sahip nesnelerin basamaklı yıkımları
• Kısmen çakışan nesnelere atamanın sonucu
• Statik nesnelerinin başlatılması sırasında bir işlevi tekrar tekrar girme
• Bir nesnenin yapıcısından veya yıkıcısından saf sanal işlevlerine sanal işlev çağrıları yapma
• İnşa edilmemiş veya zaten tahrip edilmiş nesnelerin statik olmayan üyelerine atıfta bulunmak

Kaynak dosya ve Önişleme

• Yeni satırla bitmeyen veya ters eğik çizgi ile biten boş olmayan bir kaynak dosya (C ++ 11'den önce)
• Bir ters eğik çizgi ve ardından bir karakter veya dize sabitinde belirtilen çıkış kodlarının parçası olmayan bir karakter (bu, C ++ 11'de uygulama tarafından tanımlanır).
• Uygulama sınırlarını aşma (iç içe blok sayısı, bir programdaki işlev sayısı, kullanılabilir yığın alanı ...)
• İle temsil edilemeyen önişlemci sayısal değerleri long int
• İşlev benzeri bir makro tanımının sol tarafındaki önişleme yönergesi
• Bir #ififadede tanımlanmış belirteci dinamik olarak oluşturma

Sınıflandırılacak

• Statik depolama süresi olan bir programın imhası sırasında çıkış çağrısı

İşlev parametrelerinin değerlendirilme sırası belirtilmemiş davranıştır . (Bu, programınızın tanımlanamayan davranışların aksine çökmesini, patlamasını veya pizza siparişi vermez .)

Tek gereksinim, işlev çağrılmadan önce tüm parametrelerin tam olarak değerlendirilmesi gerektiğidir.

Bu:

// The simple obvious one.
callFunc(getA(),getB());

Buna eşdeğer olabilir:

int a = getA();
int b = getB();
callFunc(a,b);

Veya bu:

int b = getB();
int a = getA();
callFunc(a,b);

İkisinden biri olabilir; derleyiciye kalmış. Sonuç, yan etkilere bağlı olarak önemli olabilir.

Derleyici, bir ifadenin değerlendirme bölümlerini yeniden sıralamakta serbesttir (anlamın değişmediği varsayılarak).

Orijinal sorudan:

a[i] = i++;

// This expression has three parts:
(a) a[i]
(b) i++
(c) Assign (b) to (a)

// (c) is guaranteed to happen after (a) and (b)
// But (a) and (b) can be done in either order.
// See n2521 Section 5.17
// (b) increments i but returns the original value.
// See n2521 Section 5.2.6
// Thus this expression can be written as:

int rhs  = i++;
int lhs& = a[i];
lhs = rhs;

// or
int lhs& = a[i];
int rhs  = i++;
lhs = rhs;

Çift Kontrollü kilitleme. Yapması kolay bir hata.

A* a = new A("plop");

// Looks simple enough.
// But this can be split into three parts.
(a) allocate Memory
(b) Call constructor
(c) Assign value to 'a'

// No problem here:
// The compiler is allowed to do this:
(a) allocate Memory
(c) Assign value to 'a'
(b) Call constructor.
// This is because the whole thing is between two sequence points.

// So what is the big deal.
// Simple Double checked lock. (I know there are many other problems with this).
if (a == null) // (Point B)
{
    Lock   lock(mutex);
    if (a == null)
    {
        a = new A("Plop");  // (Point A).
    }
}
a->doStuff();

// Think of this situation.
// Thread 1: Reaches point A. Executes (a)(c)
// Thread 1: Is about to do (b) and gets unscheduled.
// Thread 2: Reaches point B. It can now skip the if block
//           Remember (c) has been done thus 'a' is not NULL.
//           But the memory has not been initialized.
//           Thread 2 now executes doStuff() on an uninitialized variable.

// The solution to this problem is to move the assignment of 'a'
// To the other side of the sequence point.
if (a == null) // (Point B)
{
    Lock   lock(mutex);
    if (a == null)
    {
        A* tmp = new A("Plop");  // (Point A).
        a = tmp;
    }
}
a->doStuff();

// Of course there are still other problems because of C++ support for
// threads. But hopefully these are addresses in the next standard.

Benim favorim "Şablonların somutlaştırılmasında sonsuz özyineleme" dir çünkü tanımlanmamış davranışın derleme zamanında gerçekleştiği tek şey olduğuna inanıyorum.

constKullanarak sıyırma işleminden sonra bir sabite atama const_cast<>:

const int i = 10; 
int *p =  const_cast<int*>( &i );
*p = 1234; //Undefined

Tanımlanmamış davranışların yanı sıra , aynı derecede kötü uygulama tanımlı davranış da vardır .

Tanımsız davranış, bir program sonucu standart tarafından belirtilmeyen bir şey yaptığında oluşur.

Uygulama tanımlı davranış, sonucu standart tarafından tanımlanmayan, ancak uygulamanın belgelendirilmesi gereken bir programın eylemidir. Yığın Taşması sorusundan bir örnek "Çokbaytlı karakter değişmezleri", bunu derleyemeyen bir C derleyicisi var mı? .

Uygulama tanımlı davranış yalnızca taşımaya başladığınızda sizi ısırır (ancak derleyicinin yeni sürümüne yükseltmek de taşır!)

Değişkenler bir ifadede yalnızca bir kez güncellenebilir (teknik olarak sıra noktaları arasında bir kez).

int i =1;
i = ++i;

// Undefined. Assignment to 'i' twice in the same expression.

Çeşitli çevresel sınırların temel anlayışı. Tam liste C spesifikasyonunun 5.2.4.1 bölümünde bulunmaktadır. Burda biraz var;

• Bir fonksiyon tanımında 127 parametre
• Bir işlev çağrısında 127 bağımsız değişken
• Bir makro tanımında 127 parametre
• Bir makro çağrısında 127 bağımsız değişken
• Mantıksal bir kaynak satırında 4095 karakter
• Bir karakter dizesi değişmezinde veya geniş dize değişmezinde (birleştirme işleminden sonra) 4095 karakter
• Bir nesnede 65535 bayt (yalnızca barındırılan bir ortamda)
• #İncluded dosyalar için 15 düzey
• Bir anahtar ifadesi için 1023 vaka etiketleri (anonsested anahtar ifadeleri hariç)

Aslında bir anahtar ifadesi için 1023 vaka etiketleri sınırında biraz şaşırdım, üretilen kod / lex / parsers için oldukça kolay bir şekilde aşıldığını görebilirsiniz.

Bu sınırlar aşılırsa, tanımlanmamış davranışınız (çökmeler, güvenlik kusurları, vb.) Vardır.

Doğru, bunun C belirtiminden olduğunu biliyorum, ancak C ++ bu temel destekleri paylaşıyor.

memcpyÇakışan bellek bölgeleri arasında kopyalama yapmak için kullanılır . Örneğin:

char a[256] = {};
memcpy(a, a, sizeof(a));

Davranış, C ++ 03 Standardı tarafından toplanan C Standardına göre tanımlanmamıştır.

7.21.2.1 Memcpy işlevi

özet

1 / #incid void * memcpy (void * kısıtlama s1, sabit boşluk * kısıtlama s2, boyut_t n);

Açıklama

2 / Memcpy işlevi s2 ile gösterilen nesneden n1 ile gösterilen nesneye n karakter kopyalar. Kopyalama çakışan nesneler arasında gerçekleşirse, davranış tanımsızdır. 3 döndürür Memcpy işlevi s1 değerini döndürür.

7.21.2.2 Memmove işlevi

özet

1 # void * memmove (void * s1, const void * s2, size_t n) ekleyin;

Açıklama

2 Memmove işlevi, s2 ile gösterilen nesneden n1 ile gösterilen nesneye n karakter kopyalar. Kopyalama, s2 ile gösterilen nesneden gelen n karakter, ilk olarak s1 ve s2 ile gösterilen nesnelerle çakışmayan geçici bir n karakter dizisine kopyalanır ve daha sonra geçici diziden n karakter kopyalanır nesne s1 ile işaret etti. İadeler

3 Memmove işlevi s1 değerini döndürür.

C ++ 'ın bir boyutu garanti ettiği tek türdür char. Ve boyut 1'dir. Diğer tüm türlerin boyutu platforma bağlıdır.

Farklı derleme birimlerindeki ad alanı düzeyindeki nesneler, başlatma sırası hiçbir zaman birbirine bağlı olmamalıdır, çünkü başlatma sıraları tanımlanmamıştır.