Bir C ++ işlevinin belirli bir değişkenin değerini değiştirip değiştirmeyeceğini belirleyebilecek bir derleyici oluşturmak neden imkansızdır?

Bu satırı bir kitapta okudum:

Bir C ++ işlevinin belirli bir değişkenin değerini değiştirip değiştirmeyeceğini gerçekten belirleyebilecek bir derleyici oluşturmak imkansızdır.

Paragraf, derleyicinin sabitliği kontrol ederken neden muhafazakar olduğundan bahsediyordu.

Böyle bir derleyici oluşturmak neden imkansız?

Derleyici, bir değişkenin yeniden atanıp atanmadığını, üzerinde const olmayan bir işlevin çağrılıp çağrılmadığını veya const olmayan bir parametre olarak aktarılıp aktarılmadığını her zaman kontrol edebilir ...

Böyle bir derleyici oluşturmak neden imkansız?

Aynı nedenle, herhangi bir programın sonlanıp sonlanmayacağını belirleyecek bir program yazamazsınız. Bu, durma sorunu olarak bilinir ve hesaplanamayan şeylerden biridir.

Açık olmak gerekirse, bazı durumlarda bir işlevin değişkeni değiştirdiğini belirleyebilen bir derleyici yazabilirsiniz , ancak işlevin değişkeni değiştirip değiştirmeyeceğini (veya durdurmayacağını) güvenilir bir şekilde yazamazsınız. mümkün olan her işlev.

İşte kolay bir örnek:

void foo() {
    if (bar() == 0) this->a = 1;
}

Bir derleyici, sadece bu koda bakarak, bir daha değişip foodeğişmeyeceğini anasıl belirleyebilir? Yapıp yapmadığı, işlevin dışındaki koşullara, yani bar. Durdurma sorununun hesaplanabilir olmadığının kanıtı için bundan daha fazlası var, ancak bağlantılı Wikipedia makalesinde (ve her hesaplama teorisi ders kitabında) güzel bir şekilde açıklanmış, bu yüzden burada doğru bir şekilde açıklamaya çalışmayacağım.

Böyle bir derleyicinin var olduğunu hayal edin. Ayrıca, kolaylık sağlamak için, iletilen işlev verilen bir değişkeni değiştirirse 1 ve işlev değiştirmediğinde 0 döndüren bir kitaplık işlevi sağladığını varsayalım. O halde bu program ne yazdırmalı?

int variable = 0;

void f() {
    if (modifies_variable(f, variable)) {
        /* do nothing */
    } else {
        /* modify variable */
        variable = 1;
    }
}

int main(int argc, char **argv) {
    if (modifies_variable(f, variable)) {
        printf("Modifies variable\n");
    } else {
        printf("Does not modify variable\n");
    }

    return 0;
}

Şaşırtmak etmeyin "veya bu girdileri verilen bir değişken değiştirmez olacak" için "bir değişken değiştiren bir yürütme yolu vardır."

İlki opak yüklem belirleme olarak adlandırılır ve karar vermek önemsiz bir şekilde imkansızdır - durdurma sorununun azaltılmasının yanı sıra, girdilerin bilinmeyen bir kaynaktan (örn. Kullanıcı) gelebileceğini belirtebilirsiniz. Bu sadece C ++ değil tüm diller için geçerlidir .

İkinci açıklama ise edebilir tüm optimize derleyiciler yapmak bir şey olduğunu ayrıştırma ağaca bakarak belirlenebilir. Yaptıkları sebebi olmasıdır saf fonksiyonlar (ve referentially şeffaf için fonksiyonlar, referentially şeffaf bazı tanım ) derleme sırasında belirlenen kolayca inlinable olmak ya değerlerini olması gibi, uygulanabilir güzel optimizasyonlar her türlü var; ancak bir fonksiyonun saf olup olmadığını bilmek için , bir değişkeni değiştirip değiştiremeyeceğini bilmemiz gerekir .

Dolayısıyla, C ++ ile ilgili şaşırtıcı bir ifade gibi görünen şey aslında tüm diller hakkında önemsiz bir ifadedir.

"Bir C ++ fonksiyonunun belirli bir değişkenin değerini değiştirip değiştirmeyeceğindeki" anahtar kelime "will" dir. Bir C ++ işlevinin belirli bir değişkenin değerini değiştirmesine izin verilip verilmediğini kontrol eden bir derleyici oluşturmak kesinlikle mümkündür , değişikliğin gerçekleşeceğini kesin olarak söyleyemezsiniz:

void maybe(int& val) {
    cout << "Should I change value? [Y/N] >";
    string reply;
    cin >> reply;
    if (reply == "Y") {
        val = 42;
    }
}

Belirli bir fonksiyonun belirli bir değişkeni değiştirip değiştirmeyeceğini derleme zamanında algoritmik olarak bilemeyeceğinizi açıklamak için durdurma problemini çağırmanın gerekli olduğunu sanmıyorum.

Bunun yerine, bir işlevin davranışının genellikle derleyicinin önceden bilemeyeceği çalışma zamanı koşullarına bağlı olduğunu belirtmek yeterlidir. Örneğin

int y;

int main(int argc, char *argv[]) {
   if (argc > 2) y++;
}

Derleyici y, değiştirilip değiştirilmeyeceğini nasıl kesin olarak tahmin edebilir ?

Yapılabilir ve derleyiciler bazı işlevler için bunu her zaman yapıyor , bu örneğin basit satır içi erişimciler veya birçok saf işlev için önemsiz bir optimizasyondur.

İmkansız olan, genel durumda onu bilmektir.

Ne zaman bir sistem çağrısı veya başka bir modülden gelen bir işlev çağrısı veya potansiyel olarak geçersiz kılma yöntemine bir çağrı olduğunda, bazı bilgisayar korsanlarının ilgisiz bir değişkeni değiştirmek için yığın taşmasını kullanmasından düşmanca devralma dahil her şey olabilir.

Bununla birlikte, agresif optimizasyonlar gerçekleştirirken derleyicinin hayatını kolaylaştıracak const kullanmalı, globallerden kaçınmalı, işaretleyicilere referansları tercih etmeli, değişkenleri ilgisiz görevler için yeniden kullanmaktan kaçınmalısınız.

Bunu açıklamanın birden fazla yolu vardır, bunlardan biri Duraklama Problemidir :

Hesaplanabilirlik teorisinde, durdurma problemi şu şekilde ifade edilebilir: "Rasgele bir bilgisayar programının açıklaması verildiğinde, programın çalışmasının bitip bitmediğine veya sonsuza kadar çalışmaya devam edip etmediğine karar verin". Bu, bir program ve bir girdi verildiğinde, programın o girdi ile çalıştırıldığında sonunda duracağına veya sonsuza kadar çalışıp çalışmayacağına karar verme sorununa eşdeğerdir.

Alan Turing, 1936'da, tüm olası program-girdi çiftleri için durdurma problemini çözmek için genel bir algoritmanın var olamayacağını kanıtladı.

Buna benzeyen bir program yazarsam:

do tons of complex stuff
if (condition on result of complex stuff)
{
    change value of x
}
else
{
    do not change value of x
}

Değeri xdeğişiyor mu? Bunu belirlemek için, önce do tons of complex stuffparçanın koşulun yanmasına neden olup olmadığını veya daha da basit bir şekilde durup durmadığını belirlemeniz gerekir. Bu, derleyicinin yapamayacağı bir şeydir.

Durma problemini doğrudan kullanmanın bir cevabı olmamasına gerçekten şaşırdım! Bu problemden durdurma problemine çok basit bir azalma var.

Derleyicinin, bir fonksiyonun bir değişkenin değerini değiştirip değiştirmediğini anlayabildiğini hayal edin. O zaman, programın geri kalanında x'in değerinin tüm çağrılarda izlenebileceğini varsayarak, aşağıdaki fonksiyonun y'nin değerini değiştirip değiştirmediğini kesinlikle söyleyebilir:

foo(int x){
   if(x)
       y=1;
}

Şimdi, sevdiğimiz herhangi bir program için onu şu şekilde yeniden yazalım:

int y;
main(){
    int x;
    ...
    run the program normally
    ...
    foo(x);
}

Dikkat edin, ancak ve ancak, programımız y'nin değerini değiştirirse, o zaman sonlandırır - foo (), çıkmadan önce yaptığı son şeydir. Bu, durma sorununu çözdüğümüz anlamına gelir!

Yukarıdaki indirgemenin bize gösterdiği şey, bir değişkenin değerinin değişip değişmediğini belirleme sorununun en az durma problemi kadar zor olduğudur. Durma sorununun tartışılmaz olduğu biliniyor, bu yüzden bu da olmalı.

Bir işlev, derleyicinin kaynağını "görmediği" başka bir işlevi çağırır çağırmaz, ya değişkenin değiştiğini varsaymalıdır ya da aşağıda işler ters gidebilir. Örneğin, bunun "foo.cpp" içinde olduğunu varsayalım:

 void foo(int& x)
 {
    ifstream f("f.dat", ifstream::binary);
    f.read((char *)&x, sizeof(x));
 }

ve "bar.cpp" içinde bu var:

void bar(int& x)
{
  foo(x);
}

Derleyici x, bunun değişmediğini (veya daha uygun şekilde değiştiğini) nasıl "bilebilir" bar?

Eminim daha karmaşık bir şey bulabiliriz, eğer bu yeterince karmaşık değilse.

Bu genel olarak değişken olmadığını derleyici belirlemek için mümkün değildir olacak şekilde işaret edilmiş, değiştirilemez.

Const-lik kontrol ederken, ilgilenilen soru değişken eğer gibi görünüyor olabilir bir işlev tarafından değiştirilebilir. İşaretçileri destekleyen dillerde bu bile zor. Diğer kodun bir işaretçi ile ne yaptığını kontrol edemezsiniz, hatta harici bir kaynaktan okunabilir (olası olmasa da). Belleğe erişimi kısıtlayan dillerde, bu tür garantiler mümkün olabilir ve C ++ 'dan daha agresif optimizasyona izin verir.

Soruyu daha spesifik hale getirmek için, kitabın yazarının aklında olabilecek aşağıdaki kısıtlamaların olabileceğini öneriyorum:

1. Derleyicinin, bir değişkenin sabitliğine göre belirli bir fonksiyonun davranışını incelediğini varsayın. Doğruluk için, bir derleyicinin (aşağıda açıklandığı gibi takma ad nedeniyle) işlev başka bir işlevi çağırması durumunda değişkenin değiştiğini varsayması gerekir, bu nedenle 1 numaralı varsayım yalnızca işlev çağrıları yapmayan kod parçaları için geçerlidir.
2. Değişkenin eşzamansız veya eşzamanlı bir etkinlik tarafından değiştirilmediğini varsayın.
3. Derleyicinin, değişkenin değiştirilip değiştirilmeyeceğini değil, yalnızca değiştirilip değiştirilemeyeceğini belirlediğini varsayın. Başka bir deyişle, derleyici yalnızca statik analiz gerçekleştiriyor.
4. Derleyicinin yalnızca doğru işleyen kodu düşündüğünü varsayın (dizi taşmaları / yetersizlikleri, kötü işaretçileri vb. Dikkate almıyor)

Derleyici tasarımı bağlamında, kod üretme doğruluğu ve / veya kod optimizasyonu bağlamında bir derleyici yazarının görüşünde 1,3,4 varsayımlarının mükemmel bir anlam ifade ettiğini düşünüyorum. Varsayım 2, uçucu anahtar kelimenin yokluğunda anlamlıdır. Ve bu varsayımlar aynı zamanda, önerilen bir cevabı yargılamayı çok daha kesin hale getirmek için soruyu yeterince odaklıyor :-)

Bu varsayımlar göz önüne alındığında, sabitliğin kabul edilememesinin temel nedeni, değişken takma addır. Derleyici, başka bir değişkenin const değişkenine işaret edip etmediğini bilemez. Aliasing, aynı derleme birimindeki başka bir işlevden kaynaklanıyor olabilir, bu durumda derleyici işlevlere bakabilir ve örtüşmenin oluşabileceğini statik olarak belirlemek için bir çağrı ağacı kullanabilir. Ancak, takma ad bir kitaplıktan veya başka bir yabancı koddan kaynaklanıyorsa, derleyicinin işlev girişi üzerine değişkenlerin adının olup olmadığını bilmesinin bir yolu yoktur.

Bir değişken / bağımsız değişken sabit olarak işaretlenmişse, takma ad ile değiştirilmemesi gerektiğini, ancak bir derleyici yazarı için bu oldukça riskli olduğunu iddia edebilirsiniz. Bir insan programcının, bir değişken sabitini, örneğin tüm sistemin, işletim sisteminin veya bir kütüphanenin davranışını bilmediği büyük bir projenin, kazanılan bir değişkeni gerçekten bilmesinin bir parçası olarak bildirmesi bile riskli olabilir. t değiş.

Bir değişken bildirilmiş olsa bile const, kötü yazılmış bir kodun üzerine yazabileceği anlamına gelmez.

//   g++ -o foo foo.cc

#include <iostream>
void const_func(const int&a, int* b)
{
   b[0] = 2;
   b[1] = 2;
}

int main() {
   int a = 1;
   int b = 3;

   std::cout << a << std::endl;
   const_func(a,&b);
   std::cout << a << std::endl;
}

çıktı:

1
2

Yorumlarımı genişletmek gerekirse, o kitabın metni belirsizdir, bu da konuyu gizlemektedir.

Yorumladığım gibi, bu kitap şöyle demeye çalışıyor: "Haydi, yazılabilecek akla gelebilecek her C ++ işlevini yazmak için sonsuz sayıda maymun bulalım. Bir değişken seçersek (maymunların yazdığı belirli bir işlev) durumlar olacaktır. kullanırsa, fonksiyonun bu değişkeni değiştirip değiştirmeyeceğini çözemeyiz. "

Elbette, herhangi bir uygulamadaki bazı (hatta birçok) işlev için bu, derleyici tarafından ve çok kolay bir şekilde belirlenebilir. Ama hepsi için değil (veya zorunlu olarak çoğu).

Bu işlev kolayca analiz edilebilir:

static int global;

void foo()
{
}

"foo" açıkça "global" i değiştirmez. Hiçbir şeyi değiştirmez ve bir derleyici bunu kolayca çözebilir.

Bu işlev bu şekilde analiz edilemez:

static int global;

int foo()
{
    if ((rand() % 100) > 50)
    {
        global = 1;
    }
    return 1;

"Foo" 'nun eylemleri çalışma zamanında değişebilen bir değere bağlı olduğundan , derleme zamanında "global" i değiştirip değiştirmeyeceği açık bir şekilde belirlenemez .

Tüm bu kavramı anlamak, bilgisayar bilimcilerinin sandığından çok daha basit. İşlev, çalışma zamanında değişen şeylere bağlı olarak farklı bir şey yapabilirse, çalışana kadar ne yapacağını hesaplayamazsınız ve her çalıştığında farklı bir şey yapabilir. Kesin olarak imkansız olsun ya da olmasın, açıkça imkansız.