Döngünün hangi noktasında tamsayı taşması tanımsız davranış haline gelir?

Bu, burada gönderemeyeceğim çok daha karmaşık bir kod içeren sorumu açıklamak için bir örnek.

#include <stdio.h>
int main()
{
    int a = 0;
    for (int i = 0; i < 3; i++)
    {
        printf("Hello\n");
        a = a + 1000000000;
    }
}

Bu program benim platformumda tanımsız davranış içeriyor çünkü a3. döngüde taşacak.

Bu, tüm programın tanımsız davranışa sahip olmasını mı yoksa yalnızca taşma gerçekten olduktan sonra mı? Derleyici potansiyel olduğunu işe yarayabilir a olacak o tanımsız bütün döngü beyan ve hepsi taşma önce gerçekleşmesi rağmen printfs çalıştırmak için rahatsız böylece taşması?

_{(Farklı olsalar da C ve C ++ etiketli çünkü farklılarsa her iki dil için de cevaplarla ilgilenirim.)}

Tamamen teorik bir cevapla ilgileniyorsanız, C ++ standardı tanımlanmamış davranışların "zamanda yolculuk" yapmasına izin verir:

[intro.execution]/5: İyi biçimlendirilmiş bir programı yürüten uyumlu bir uygulama, aynı program ve aynı girdiyle soyut makinenin karşılık gelen örneğinin olası yürütmelerinden biri ile aynı gözlemlenebilir davranışı üretecektir. Bununla birlikte, bu tür bir yürütme tanımlanmamış bir işlem içeriyorsa, bu Uluslararası Standart, bu programı bu girdi ile yürüten uygulamaya herhangi bir gereklilik getirmez (ilk tanımsız işlemden önceki işlemlerle ilgili olarak bile)

Bu nedenle, programınız tanımlanmamış davranış içeriyorsa, tüm programınızın davranışı tanımsızdır.

Öncelikle bu sorunun başlığını düzeltmeme izin verin:

Tanımsız Davranış, (özellikle) yürütme alanı değildir.

Tanımsız Davranış tüm adımları etkiler: derleme, bağlama, yükleme ve çalıştırma.

Bunu pekiştirmek için bazı örnekler, hiçbir bölümün ayrıntılı olmadığını unutmayın:

• derleyici, Tanımlanmamış Davranış içeren kod bölümlerinin hiçbir zaman yürütülmediğini varsayabilir ve bu nedenle bunlara yol açacak yürütme yollarının ölü kod olduğunu varsayabilir. Her C programcısının tanımlanmamış davranışlar hakkında bilmesi gerekenleri görün Chris Lattner başkası.
• bağlayıcı, zayıf bir sembolün (adıyla tanınan) birden fazla tanımının varlığında, Tek Tanım Kuralı sayesinde tüm tanımların aynı olduğunu varsayabilir
• yükleyici (dinamik kitaplıklar kullanmanız durumunda) aynı şeyi varsayabilir, böylece bulduğu ilk sembolü seçer; bu genellikle (ab) LD_PRELOADUnixlerde hileler kullanarak çağrıları yakalamak için kullanılır
• sarkan işaretçiler kullanırsanız yürütme başarısız olabilir (SIGSEV)

Tanımlanmamış Davranış hakkında bu kadar korkutucu olan budur : Vaktinden önce tam olarak hangi davranışın meydana geleceğini tahmin etmek neredeyse imkansızdır ve bu öngörü, araç zincirinin her güncellemesinde, altta yatan işletim sistemi, ...

Michael Spencer'ın (LLVM Developer) hazırladığı bu videoyu izlemenizi tavsiye ederim: CppCon 2016: My Little Optimizer: Undefined Behavior is Magic .

Bir agresif C optimize veya C ++ derleyici 16 bit hedefleyen intolacak biliyorum eklemeye davranış olduğunu 1000000000bir etmek inttürü olduğunu tanımsız .

Her iki standart tarafından da tüm programın silinmesini ve ayrılmasını da içerebilecek her şeyi yapma izni vardır int main(){}.

Peki ya daha büyük inte'ler? Henüz bunu yapan bir derleyici bilmiyorum (ve hiçbir şekilde C ve C ++ derleyici tasarımında uzman değilim), ancak bazen 32 bit intveya daha yüksek bir sürümü hedefleyen bir derleyicinin döngünün sonsuzdur ( ideğişmez) ve bu yüzden asonunda taşar. Yani bir kez daha çıktıyı optimize edebilir int main(){}. Burada belirtmeye çalıştığım nokta, derleyici optimizasyonları giderek daha agresif hale geldikçe, giderek daha fazla tanımlanmamış davranış yapılarının kendilerini beklenmedik şekillerde göstermeleridir.

Döngünüzün sonsuz olduğu gerçeği, döngü gövdesinde standart çıktıya yazdığınız için kendi içinde tanımsız değildir.

Teknik olarak, C ++ standardına göre, bir program tanımlanmamış davranış içeriyorsa , derleme zamanında bile (program çalıştırılmadan önce) tüm programın davranışı tanımsızdır.

Uygulamada, derleyici (optimizasyonun bir parçası olarak) taşmanın meydana gelmeyeceğini varsayabileceğinden, en azından programın döngünün üçüncü yinelemesindeki davranışı (32 bitlik bir makine varsayılarak) tanımsız olacaktır. üçüncü yinelemeden önce doğru sonuçları almanız olasıdır. Bununla birlikte, tüm programın davranışı teknik olarak tanımlanmadığı için, programın tamamen yanlış çıktı üretmesini (çıktı olmaması dahil), yürütme sırasında herhangi bir noktada çalışma zamanında çökmesini veya hatta tamamen derleyememesini (tanımsız davranış, Derleme zamanı).

Tanımlanmamış davranış, derleyiciye optimize etmek için daha fazla alan sağlar çünkü kodun ne yapması gerektiğine dair belirli varsayımları ortadan kaldırır. Bunu yaparken, tanımlanmamış davranışları içeren varsayımlara dayanan programların beklendiği gibi çalışması garanti edilmez. Bu nedenle, C ++ standardına göre tanımsız olarak kabul edilen belirli bir davranışa güvenmemelisiniz.

@TartanLlama'nın yeterince ifade ettiği gibi tanımlanmamış bir davranışın neden 'zamanda yolculuk' yapabildiğini anlamak için, 'sanki' kuralına bir göz atalım:

1.9 Program yürütme

¹ Bu Uluslararası Standarttaki anlamsal açıklamalar, parametreleştirilmiş belirleyici olmayan soyut bir makineyi tanımlar. Bu Uluslararası Standart, uyumlu uygulamaların yapısına herhangi bir gereklilik getirmez. Özellikle, soyut makinenin yapısını kopyalamaları veya taklit etmeleri gerekmez. Daha ziyade, uyumlu uygulamaların aşağıda açıklandığı gibi soyut makinenin gözlemlenebilir davranışını taklit etmesi (sadece) gereklidir.

Bununla, programı bir girdi ve çıktı içeren bir 'kara kutu' olarak görebiliriz. Giriş, kullanıcı girişi, dosyalar ve diğer birçok şey olabilir. Çıktı, standartta belirtilen 'gözlemlenebilir davranış'tır.

Standart yalnızca girdi ve çıktı arasında bir eşleme tanımlar, başka hiçbir şey yoktur. Bunu bir 'örnek kara kutuyu' tanımlayarak yapar, ancak aynı eşlemeye sahip diğer kara kutuların da eşit derecede geçerli olduğunu açıkça söyler. Bu, kara kutunun içeriğinin alakasız olduğu anlamına gelir.

Bunu akılda tutarak, tanımsız davranışın belirli bir anda meydana geldiğini söylemek mantıklı olmaz. Gelen numune kara kutu uygulanması nerede ve ne zaman olur, biz söyleyebiliriz ama gerçek artık olduğunda biz nerede ve diyemeyiz böylece kara kutu, tamamen farklı bir şey olabilir. Teorik olarak, bir derleyici örneğin tüm olası girdileri numaralandırmaya ve ortaya çıkan çıktıları önceden hesaplamaya karar verebilir. O zaman tanımlanmamış davranış, derleme sırasında meydana gelirdi.

Tanımsız davranış, girdi ve çıktı arasında bir eşlemenin olmamasıdır. Bir programın bazı girdiler için tanımlanmamış davranışları olabilir, ancak diğerleri için tanımlanmış davranışları olabilir. O zaman girdi ve çıktı arasındaki eşleştirme tamamlanmamış; Çıktıya eşlemenin olmadığı bir girdi var.
Söz konusu programın herhangi bir girdi için tanımsız davranışı vardır, bu nedenle eşleme boştur.

int32-bit olduğu varsayılırsa , üçüncü yinelemede tanımsız davranış gerçekleşir. Bu nedenle, örneğin, döngü yalnızca koşullu olarak erişilebilirse veya üçüncü yinelemeden önce koşullu olarak sonlandırılabiliyorsa, üçüncü yinelemeye gerçekten ulaşılmadıkça tanımsız bir davranış olmayacaktır. Bununla birlikte, tanımsız davranış durumunda, tanımsız davranışın başlatılmasına göre "geçmişte" olan çıktı da dahil olmak üzere programın tüm çıktıları tanımsızdır. Örneğin, sizin durumunuzda bu, çıktıda 3 "Merhaba" mesajı görme garantisi olmadığı anlamına gelir.

TartanLlama'nın cevabı doğru. Tanımlanmamış davranış, derleme sırasında bile herhangi bir zamanda gerçekleşebilir. Bu saçma görünebilir, ancak derleyicilerin yapmaları gereken şeyi yapmalarına izin veren önemli bir özelliktir. Derleyici olmak her zaman kolay değildir. Her seferinde şartname ne diyorsa onu yapmalısınız. Bununla birlikte, bazen belirli bir davranışın meydana geldiğini kanıtlamak korkunç derecede zor olabilir. Durma sorununu hatırlarsanız, belirli bir girdi beslendiğinde sonsuz bir döngüyü tamamlayıp tamamlamadığını kanıtlayamayacağınız bir yazılım geliştirmek oldukça önemsizdir.

Derleyicileri kötümser yapabilir ve bir sonraki talimatın sorunlar gibi bu durdurma sorunlarından biri olabileceğinden korkarak sürekli derleyebiliriz, ancak bu mantıklı değil. Bunun yerine derleyiciye bir geçiş izni veriyoruz: bu "tanımlanmamış davranış" konularında, herhangi bir sorumluluktan kurtulmuşlardır. Tanımlanmamış davranış, onları gerçekten kötü-hain durma problemlerinden ayırmakta güçlük çekecek kadar ince bir şekilde alçakça olan tüm davranışlardan oluşur.

Göndermeyi sevdiğim bir örnek var, ancak kaynağını kaybettiğimi kabul etsem de, bu yüzden başka kelimelerle ifade etmem gerekiyor. MySQL'in belirli bir sürümündendi. MySQL'de, kullanıcı tarafından sağlanan verilerle doldurulmuş dairesel bir tamponu vardı. Tabii ki, verilerin arabelleği aşmadığından emin olmak istediler, bu yüzden bir kontrolleri vardı:

if (currentPtr + numberOfNewChars > endOfBufferPtr) { doOverflowLogic(); }

Yeterince mantıklı görünüyor. Ancak, ya numberOfNewChars gerçekten büyükse ve taşıyorsa? Sonra etrafını sarar ve bundan daha küçük bir işaretçi haline gelir endOfBufferPtr, böylece taşma mantığı asla çağrılmaz. Böylece ondan önce ikinci bir çek eklediler:

if (currentPtr + numberOfNewChars < currentPtr) { detectWrapAround(); }

Arabellek taşma hatasını halletmişsiniz gibi görünüyor, değil mi? Ancak, bu tamponun Debian'ın belirli bir sürümünde taştığını belirten bir hata gönderildi! Dikkatli bir araştırma, Debian'ın bu sürümünün gcc'nin özellikle yeni bir sürümünü kullanan ilk sürüm olduğunu gösterdi. Gcc'nin bu sürümünde, derleyici currentPtr + numberOfNewChars öğesinin hiçbir zaman currentPtr'den daha küçük bir işaretçi olamayacağını fark etti çünkü işaretçiler için taşma tanımsız bir davranıştır! Bu, gcc'nin tüm denetimi optimize etmesi için yeterliydi ve kontrol etmek için kodu yazmış olsanız bile birdenbire arabellek taşmalarına karşı korunmadınız !

Bu özel bir davranıştı. Her şey yasaldı (duyduğuma göre gcc bu değişikliği bir sonraki sürümde geri aldı). Sezgisel davranış olarak düşündüğüm şey bu değil, ama hayal gücünüzü biraz uzatırsanız, bu durumun hafif bir varyasyonunun derleyici için nasıl bir durma sorunu haline gelebileceğini görmek kolaydır. Bu nedenle, spec yazarları onu "Tanımsız Davranış" yaptı ve derleyicinin kesinlikle istediği her şeyi yapabileceğini belirtti.

Teorik cevapların ötesinde, pratik bir gözlem, derleyicilerin uzun zamandır döngülerde içlerinde yapılan iş miktarını azaltmak için çeşitli dönüşümler uyguladıklarıdır. Örneğin, verilen:

for (int i=0; i<n; i++)
  foo[i] = i*scale;

bir derleyici bunu şuna dönüştürebilir:

int temp = 0;
for (int i=0; i<n; i++)
{
  foo[i] = temp;
  temp+=scale;
}

Böylece her döngü yinelemesinde bir çarpma tasarrufu sağlanır. Değişik derecelerde saldırganlıkla uyarlanan derleyicilerin ek bir optimizasyon biçimi, bunu şuna dönüştürecektir:

if (n > 0)
{
  int temp1 = n*scale;
  int *temp2 = foo;
  do
  {
    temp1 -= scale;
    *temp2++ = temp1;
  } while(temp1);
}

Taşma üzerine sessiz sarmalayan makinelerde bile, n'den küçük bir sayı varsa bu arızalanabilir ve ölçekle çarpıldığında 0 sonucunu verir. değerini beklenmedik bir şekilde değiştirdi ("ölçek" in UB'yi çağırmadan orta döngüyü değiştirebileceği her durumda, derleyicinin optimizasyonu gerçekleştirmesine izin verilmezdi).

INT_MAX + 1 ve UINT_MAX arasında bir değer elde etmek için iki kısa işaretsiz türün çarpıldığı durumlarda bu tür optimizasyonların çoğu herhangi bir sorun yaşamazken, gcc, bir döngü içinde böyle bir çarpmanın döngünün erken çıkmasına neden olabileceği bazı durumlara sahiptir. . Oluşturulan koddaki karşılaştırma talimatlarından kaynaklanan bu tür davranışları fark etmedim, ancak derleyicinin bir döngünün en fazla 4 veya daha az kez çalıştırılabileceği sonucuna varmak için taşmayı kullandığı durumlarda gözlemlenebilir; çıkarımları döngünün üst sınırının göz ardı edilmesine neden olsa bile, bazı girdilerin UB'ye neden olacağı ve diğerlerinin oluşmayacağı durumlarda varsayılan olarak uyarılar oluşturmaz.

Tanımlanmamış davranış, tanımı gereği gri bir alandır. Ne "tanımsız davranış" olduğunu - Sadece o ya yapmayacağım ne olacağını tahmin edemez araçları .

Çok eski zamanlardan beri, programcılar her zaman tanımsız bir durumdan tanımlılık kalıntılarını kurtarmaya çalıştılar. Onlar gerçekten kullanımına isteyen bazı kod var, ama onlar iddia deneyin böylece, tanımlanmamış çıkıyor ki ettik: "Ben tanımsız biliyorum ama mutlaka o, en kötü ihtimalle, şu ya da bu yapacağım; bunu yapmak asla o . " Ve bazen bu argümanlar aşağı yukarı doğrudur - ama çoğu zaman yanlıştır. Ve derleyiciler daha akıllı hale geldikçe (veya bazı insanlar daha sinsice ve daha sinsice diyebilir), sorunun sınırları değişmeye devam ediyor.

Yani gerçekten, çalışması garantili ve uzun süre çalışmaya devam edecek bir kod yazmak istiyorsanız, tek bir seçeneğiniz var: ne pahasına olursa olsun tanımlanmamış davranıştan kaçının. Gerçekten, eğer onunla ilgilenirseniz, sizi rahatsız etmek için geri gelecektir.

Örneğinizin dikkate almadığı bir şey optimizasyondur. adöngüde ayarlanır, ancak hiç kullanılmaz ve bir iyileştirici bunu çözebilir. Bu nedenle, optimizasyon uzmanının atması meşrudura uzmanının tamamen vazgeçmesi meşrudur ve bu durumda tüm tanımlanmamış davranışlar, boojum'un kurbanı gibi ortadan kaybolur.

Ancak elbette bunun kendisi tanımsızdır, çünkü optimizasyon tanımsızdır. :)

Bu soru çift etiketli C ve C ++ olduğundan ikisini de deneyeceğim ve ele alacağım. C ve C ++ burada farklı yaklaşımlar alır.

C'de uygulama, tüm programı tanımlanmamış davranışa sahipmiş gibi ele almak için tanımlanmamış davranışın çağrılacağını kanıtlayabilmelidir. OPs örneğinde, derleyicinin bunu kanıtlaması önemsiz görünebilir ve bu nedenle tüm program tanımsızmış gibi.

Bunu, özünde şu soruyu soran Kusur Raporu 109'dan görebiliriz :

Bununla birlikte, C Standardı "tanımlanmamış değerlerin" ayrı varlığını kabul ederse (yalnızca yaratılışı tamamen "tanımlanmamış davranış" içermeyen), derleyici testi yapan bir kişi aşağıdaki gibi bir test senaryosu yazabilir ve aynı zamanda (veya muhtemelen talep) uygun bir uygulamanın, en azından bu kodu "hata" olmadan derlemesi (ve muhtemelen yürütülmesine de izin vermesi).

int array1[5];
int array2[5];
int *p1 = &array1[0];
int *p2 = &array2[0];

int foo()
{
int i;
i = (p1 > p2); /* Must this be "successfully translated"? */
1/0; /* Must this be "successfully translated"? */
return 0;
}

Yani asıl soru şudur: Yukarıdaki kod "başarılı bir şekilde tercüme edilmeli" mi (bu ne anlama geliyorsa)? (5.1.1.3 alt maddesine ekli dipnota bakın.)

ve yanıt şuydu:

C Standardı, "tanımlanmamış değer" değil, "belirsiz olarak değerli" terimini kullanır. Belirsiz değerli bir nesnenin kullanılması, tanımsız davranışa neden olur. 5.1.1.3 alt maddesinin dipnotu, geçerli bir program hala doğru bir şekilde çevrildiği sürece, bir uygulamanın herhangi bir sayıda tanılama üretmekte özgür olduğuna işaret etmektedir. Değerlendirilmesi tanımlanmamış davranışla sonuçlanacak bir ifade, sabit bir ifadenin gerekli olduğu bir bağlamda ortaya çıkarsa, içeren program tam olarak uyumlu değildir. Ayrıca, belirli bir programın olası her yürütülmesi, tanımsız davranışla sonuçlanacaksa, verilen program kesinlikle uyumlu değildir. Uygun bir uygulama, tam olarak uyumlu bir programı çevirmekte başarısız olmamalıdır, çünkü o programın olası bir şekilde yürütülmesi tanımlanmamış davranışa neden olabilir. Foo hiçbir zaman çağrılamayabileceğinden, verilen örnek uygun bir uygulama ile başarıyla çevrilmelidir.

C ++ 'da yaklaşım daha rahat görünür ve uygulamanın statik olarak kanıtlayıp ispatlayamadığına bakılmaksızın bir programın tanımsız davranışa sahip olduğunu gösterir.

Elimizde [intro.abstrac] p5 var:

İyi biçimlendirilmiş bir programı yürüten uyumlu bir uygulama, aynı program ve aynı girdiyle soyut makinenin karşılık gelen örneğinin olası yürütmelerinden biri ile aynı gözlemlenebilir davranışı üretecektir. Bununla birlikte, bu tür bir yürütme tanımlanmamış bir işlem içeriyorsa, bu belge, bu programın bu girdi ile çalıştırılmasına ilişkin herhangi bir gereksinim getirmez (ilk tanımsız işlemden önceki işlemlerle ilgili olarak bile).

En iyi cevap yanlış (ancak yaygın) bir yanlış anlamadır:

Tanımsız davranış, bir çalışma zamanı özelliğidir *. Bu DEĞİL CAN "zaman yolculuğu"!

Bazı operasyonlar (standart olarak) yan etkilere sahip olacak şekilde tanımlanır ve optimize edilemez. G / Ç yapan veya volatiledeğişkenlere erişen işlemler bu kategoriye girer.

Ancak , bir uyarı var: UB, önceki işlemleri geri alan davranış da dahil olmak üzere herhangi bir davranış olabilir . Bu, bazı durumlarda, önceki kodu optimize etmeye benzer sonuçlar doğurabilir.

Aslında, bu en üstteki cevapla tutarlıdır (vurgu benim):

İyi biçimlendirilmiş bir programı yürüten uygun bir uygulama, aynı program ve aynı girdiyle soyut makinenin karşılık gelen örneğinin olası yürütmelerinden biri ile aynı gözlemlenebilir davranışı üretecektir.
Bununla birlikte, bu tür bir yürütme tanımlanmamış bir işlem içeriyorsa, bu Uluslararası Standart, bu programı bu girdi ile yürüten uygulamaya herhangi bir gereklilik getirmez (ilk tanımsız işlemden önceki işlemlerle ilgili olarak bile).

Evet, bu alıntı yapar demek "bile ilk tanımsız operasyonundan önceki operasyonlar kapsamında" bu özellikle ediliyor yaklaşık kod olduğunu, ancak haber yürütülen , sadece derlenmiş değil.
Sonuçta, gerçekte ulaşılmayan tanımsız davranış hiçbir şey yapmaz ve UB içeren satıra gerçekten ulaşılması için, ondan önce gelen kod önce yürütülmelidir!

Yani evet, UB yürütüldüğünde , önceki işlemlerin herhangi bir etkisi tanımsız hale gelir. Ancak bu gerçekleşene kadar, programın yürütülmesi iyi tanımlanmıştır.

Bununla birlikte, programın bunun gerçekleşmesine neden olan tüm yürütmelerinin, önceki işlemleri gerçekleştiren ancak daha sonra etkilerini kaldıranlar da dahil olmak üzere eşdeğer programlara optimize edilebileceğini unutmayın . Sonuç olarak, önceki kod, etkilerinin geri alınmasına eşdeğer olduğu her durumda optimize edilebilir ; aksi takdirde olamaz. Örnek için aşağıya bakın.

* Not: Bu, derleme zamanında meydana gelen UB ile tutarsız değildir . Derleyici aslında UB kodu kanıtlayabilirsek olacak her zaman tüm girişler için yürütülecek, daha sonra UB derleme zaman uzatabilirsiniz. Bununla birlikte, bu, önceki tüm kodun sonunda geri döneceğini bilmeyi gerektirir , bu da güçlü bir gerekliliktir. Yine, bir örnek / açıklama için aşağıya bakın.

Bunu somut hale getirmek için, aşağıdaki kodun onu izleyen tanımsız davranışlardan bağımsız olarak yazdırıp girdinizi beklemesi gerektiğini unutmayın foo:

printf("foo");
getchar();
*(char*)1 = 1;

Bununla birlikte, fooUB oluştuktan sonra ekranda kalacağına veya yazdığınız karakterin artık giriş arabelleğinde olmayacağına dair bir garanti olmadığını da unutmayın ; bu işlemlerin her ikisi de "geri alınabilir", bu da UB "zaman yolculuğuna" benzer bir etkiye sahiptir.

Eğer getchar()çizgi yoktu, o olur hatları uzakta optimize edilmesi için yasal yalnızca ve eğer olurdu farksız çıkışının fooardından ve onu "un-yapıyor".

İkisinin ayırt edilemez olup olmayacağı tamamen uygulamaya bağlıdır (yani derleyicinize ve standart kitaplığınıza). Örneğin, başka bir programın çıktıyı okumasını beklerken iş parçacığınızı burada printf bloke edebilir mi? Yoksa hemen geri mi dönecek?

• Burada engelleyebiliyorsa, başka bir program tam çıktısını okumayı reddedebilir ve asla geri dönmeyebilir ve sonuç olarak UB asla gerçekleşmeyebilir.

• Hemen buraya dönebilirse, o zaman geri dönmesi gerektiğini biliyoruz ve bu nedenle onu optimize etmek, onu çalıştırmaktan ve sonra etkilerini yapmaktan tamamen ayırt edilemez.

Elbette, derleyici kendi özel sürümü için hangi davranışa izin verildiğini bildiğinden printf, buna göre optimize edebilir ve sonuç printfolarak bazı durumlarda optimize edilirken bazılarında optimize edilemez. Ancak, yine, gerekçe, bunun UB'nin önceki işlemlerini yapmamasından ayırt edilemez olması, önceki kodun UB nedeniyle "zehirlenmiş" olması değil.