Mengapa tidak mungkin membuat kompiler yang dapat menentukan apakah fungsi C ++ akan mengubah nilai variabel tertentu?

Saya membaca baris ini di sebuah buku:

Sangat tidak mungkin untuk membuat kompilator yang benar-benar dapat menentukan apakah fungsi C ++ akan mengubah nilai variabel tertentu atau tidak.

Paragraf tersebut membahas tentang mengapa kompilator bersikap konservatif saat memeriksa keonstanan.

Mengapa tidak mungkin membangun kompiler seperti itu?

Kompilator selalu dapat memeriksa apakah suatu variabel ditetapkan ulang, fungsi non-const sedang dipanggil di dalamnya, atau jika ia diteruskan sebagai parameter non-konst ...

Mengapa tidak mungkin membangun kompiler seperti itu?

Untuk alasan yang sama bahwa Anda tidak dapat menulis program yang akan menentukan apakah program tertentu akan dihentikan. Ini dikenal sebagai masalah terputus - putus , dan itu salah satu hal yang tidak dapat dihitung.

Untuk lebih jelasnya, Anda dapat menulis kompilator yang dapat menentukan bahwa suatu fungsi memang mengubah variabel dalam beberapa kasus , tetapi Anda tidak dapat menulis kompiler yang dapat dipercaya memberi tahu Anda bahwa fungsi tersebut akan atau tidak akan mengubah variabel (atau berhenti) untuk setiap fungsi yang memungkinkan.

Berikut contoh mudahnya:

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

Bagaimana kompilator menentukan, hanya dengan melihat kode itu, apakah fooakan berubah a? Apakah itu terjadi atau tidak tergantung pada kondisi di luar fungsi, yaitu penerapan bar. Ada lebih dari itu untuk membuktikan bahwa masalah berhenti tidak dapat dihitung, tetapi sudah dijelaskan dengan baik di artikel Wikipedia yang ditautkan (dan di setiap buku teks teori komputasi), jadi saya tidak akan mencoba menjelaskannya dengan benar di sini.

Bayangkan kompiler seperti itu ada. Mari asumsikan juga bahwa untuk kenyamanan ia menyediakan fungsi pustaka yang mengembalikan 1 jika fungsi yang diteruskan mengubah variabel tertentu dan 0 jika fungsi tidak. Lalu apa yang harus dicetak oleh program ini?

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;
}

Jangan bingung "akan atau tidak akan mengubah variabel dengan masukan ini" karena "memiliki jalur eksekusi yang mengubah variabel."

Yang pertama disebut penentuan predikat buram , dan sangat tidak mungkin untuk diputuskan - selain pengurangan dari masalah penghentian, Anda bisa menunjukkan bahwa masukan mungkin berasal dari sumber yang tidak dikenal (misalnya pengguna). Ini berlaku untuk semua bahasa, tidak hanya C ++.

Pernyataan terakhir, bagaimanapun, dapat ditentukan dengan melihat pohon parse, yang merupakan sesuatu yang dilakukan oleh semua kompiler pengoptimalan. Alasan mereka melakukannya adalah karena fungsi murni (dan fungsi transparan referensial , untuk beberapa definisi transparan secara referensial ) memiliki semua jenis pengoptimalan bagus yang dapat diterapkan, seperti mudah menjadi inlinable atau nilainya ditentukan pada waktu kompilasi; tetapi untuk mengetahui apakah suatu fungsi murni, kita perlu mengetahui apakah fungsi tersebut dapat memodifikasi variabel.

Jadi, apa yang tampak sebagai pernyataan mengejutkan tentang C ++ sebenarnya adalah pernyataan sepele tentang semua bahasa.

Saya pikir kata kunci dalam "apakah fungsi C ++ atau tidak akan mengubah nilai variabel tertentu" adalah "akan". Sangat mungkin untuk membangun kompilator yang memeriksa apakah fungsi C ++ diizinkan atau tidak untuk mengubah nilai variabel tertentu, Anda tidak dapat mengatakan dengan pasti bahwa perubahan akan terjadi:

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

Saya rasa tidak perlu memanggil masalah terputus-putus untuk menjelaskan bahwa Anda tidak dapat mengetahui secara algoritme pada waktu kompilasi apakah suatu fungsi akan mengubah variabel tertentu atau tidak.

Sebaliknya, cukup untuk menunjukkan bahwa perilaku fungsi sering kali bergantung pada kondisi waktu proses, yang tidak dapat diketahui kompilator sebelumnya. Misalnya

int y;

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

Bagaimana kompilator dapat memprediksi dengan pasti apakah yakan dimodifikasi?

Ini dapat dilakukan dan compiler melakukannya sepanjang waktu untuk beberapa fungsi , ini misalnya pengoptimalan yang sepele untuk pengakses inline sederhana atau banyak fungsi murni.

Apa yang tidak mungkin adalah mengetahuinya dalam kasus umum.

Setiap kali ada panggilan sistem atau panggilan fungsi yang datang dari modul lain, atau panggilan ke metode yang berpotensi diganti, apa pun dapat terjadi, termasuk pengambilalihan yang tidak bersahabat dari penggunaan stack overflow oleh beberapa peretas untuk mengubah variabel yang tidak terkait.

Bagaimanapun Anda harus menggunakan const, menghindari global, lebih memilih referensi daripada pointer, menghindari penggunaan kembali variabel untuk tugas yang tidak terkait, dll. Yang akan membuat hidup compiler lebih mudah saat melakukan pengoptimalan agresif.

Ada beberapa cara untuk menjelaskan hal ini, salah satunya adalah Masalah Menghentikan :

Dalam teori komputabilitas, masalah penghentian dapat dinyatakan sebagai berikut: "Diberikan deskripsi program komputer yang sewenang-wenang, putuskan apakah program selesai berjalan atau terus berjalan selamanya". Ini sama dengan masalah memutuskan, diberikan program dan masukan, apakah program pada akhirnya akan berhenti ketika dijalankan dengan masukan itu, atau akan berjalan selamanya.

Alan Turing membuktikan pada tahun 1936 bahwa algoritme umum untuk memecahkan masalah terputus-putus untuk semua kemungkinan pasangan masukan program tidak ada.

Jika saya menulis program yang terlihat seperti ini:

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

Apakah nilai xberubah? Untuk menentukan ini, pertama-tama Anda harus menentukan apakah do tons of complex stuffbagian tersebut menyebabkan kondisi menyala - atau bahkan lebih mendasar, apakah berhenti. Itu adalah sesuatu yang tidak bisa dilakukan oleh kompilator.

Sangat terkejut bahwa tidak ada jawaban yang menggunakan masalah terputus-putus secara langsung! Ada pengurangan yang sangat jelas dari masalah ini ke masalah penghentian.

Bayangkan bahwa kompilator dapat mengetahui apakah suatu fungsi mengubah nilai variabel atau tidak. Maka pasti akan dapat mengetahui apakah fungsi berikut mengubah nilai y atau tidak, dengan asumsi bahwa nilai x dapat dilacak di semua panggilan di seluruh program:

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

Sekarang, untuk program apa pun yang kita suka, mari kita tulis ulang sebagai:

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

Perhatikan bahwa, jika, dan hanya jika, program kita mengubah nilai y, apakah ia kemudian menghentikan - foo () adalah hal terakhir yang dilakukannya sebelum keluar. Ini berarti kami telah menyelesaikan masalah terputus-putus!

Apa yang ditunjukkan oleh pengurangan di atas kepada kita adalah bahwa masalah menentukan apakah nilai variabel berubah setidaknya sekeras masalah penghentian. Masalah tersendat-sendat dikenal tidak dapat dihitung, jadi yang ini harus juga.

Segera setelah suatu fungsi memanggil fungsi lain yang sumbernya tidak "dilihat" oleh compiler, ia juga harus berasumsi bahwa variabel telah diubah, atau mungkin ada yang salah di bawah ini. Misalnya, kita memiliki ini di "foo.cpp":

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

dan kami memiliki ini di "bar.cpp":

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

Bagaimana kompiler "tahu" yang xtidak berubah (atau IS berubah, lebih tepat) bar?

Saya yakin kita bisa menemukan sesuatu yang lebih kompleks, jika ini tidak cukup rumit.

Secara umum tidak mungkin bagi kompilator untuk menentukan apakah variabel akan diubah, seperti yang telah ditunjukkan.

Saat memeriksa konstanta, pertanyaan yang menarik tampaknya adalah apakah variabel dapat diubah oleh suatu fungsi. Bahkan ini sulit dalam bahasa yang mendukung petunjuk. Anda tidak dapat mengontrol apa yang dilakukan kode lain dengan pointer, bahkan bisa dibaca dari sumber eksternal (meskipun tidak mungkin). Dalam bahasa yang membatasi akses ke memori, jenis jaminan ini dapat dimungkinkan dan memungkinkan pengoptimalan yang lebih agresif daripada C ++.

Untuk membuat pertanyaan lebih spesifik, saya menyarankan rangkaian kendala berikut mungkin ada dalam pikiran penulis buku:

1. Asumsikan kompilator memeriksa perilaku fungsi tertentu sehubungan dengan konstanta variabel. Untuk kebenaran, kompilator harus mengasumsikan (karena aliasing seperti dijelaskan di bawah) jika fungsi memanggil fungsi lain, variabel diubah, jadi asumsi # 1 hanya berlaku untuk fragmen kode yang tidak melakukan panggilan fungsi.
2. Asumsikan variabel tidak diubah oleh aktivitas asinkron atau bersamaan.
3. Asumsikan compiler hanya menentukan apakah variabel dapat dimodifikasi, bukan apakah akan dimodifikasi. Dengan kata lain, kompilator hanya melakukan analisis statis.
4. Asumsikan kompilator hanya mempertimbangkan kode yang berfungsi dengan benar (tidak mempertimbangkan overruns / underruns array, pointer buruk, dll.)

Dalam konteks desain kompilator, saya pikir asumsi 1,3,4 sangat masuk akal dalam pandangan penulis kompilator dalam konteks kebenaran gen kode dan / atau pengoptimalan kode. Asumsi 2 masuk akal jika tidak ada kata kunci yang mudah menguap. Dan asumsi ini juga cukup memfokuskan pertanyaan untuk membuat penilaian terhadap jawaban yang diajukan jauh lebih pasti :-)

Dengan asumsi tersebut, alasan utama mengapa konstanta tidak dapat diasumsikan adalah karena variabel aliasing. Kompiler tidak dapat mengetahui apakah variabel lain menunjuk ke variabel const. Aliasing dapat disebabkan oleh fungsi lain dalam unit kompilasi yang sama, dalam hal ini kompilator dapat melihat seluruh fungsi dan menggunakan pohon panggilan untuk menentukan secara statis bahwa aliasing dapat terjadi. Tetapi jika aliasing disebabkan oleh sebuah pustaka atau kode asing lainnya, maka kompilator tidak memiliki cara untuk mengetahui pada entri fungsi apakah variabel adalah alias.

Anda dapat berargumen bahwa jika sebuah variabel / argumen ditandai dengan const maka itu tidak boleh berubah melalui aliasing, tetapi untuk penulis kompilator itu cukup berisiko. Bahkan dapat berisiko bagi pemrogram manusia untuk mendeklarasikan variabel const sebagai bagian dari, katakanlah proyek besar di mana dia tidak mengetahui perilaku seluruh sistem, atau OS, atau perpustakaan, untuk benar-benar mengetahui variabel menang ' t berubah.

Bahkan jika sebuah variabel dideklarasikan const, tidak berarti beberapa kode yang ditulis dengan buruk dapat menimpanya.

//   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;
}

keluaran:

1
2

Untuk memperluas komentar saya, teks buku itu tidak jelas yang mengaburkan masalah.

Saat saya berkomentar, buku itu mencoba mengatakan, "mari kita dapatkan monyet dalam jumlah tak terbatas untuk menulis setiap fungsi C ++ yang mungkin dapat ditulis. Akan ada kasus di mana jika kita memilih variabel yang (beberapa fungsi tertentu yang ditulis monyet) menggunakan, kami tidak dapat mengetahui apakah fungsi akan mengubah variabel itu. "

Tentu saja untuk beberapa (bahkan banyak) fungsi dalam aplikasi tertentu, ini dapat ditentukan oleh kompilator, dan dengan sangat mudah. Tetapi tidak untuk semua (atau sebagian besar).

Fungsi ini dapat dengan mudah dianalisis:

static int global;

void foo()
{
}

"foo" jelas tidak mengubah "global". Itu tidak mengubah apa pun sama sekali, dan kompiler dapat mengerjakannya dengan sangat mudah.

Fungsi ini tidak bisa begitu saja dianalisis:

static int global;

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

Karena tindakan "foo" bergantung pada nilai yang dapat berubah saat runtime , ia tidak dapat ditentukan pada waktu kompilasi apakah ia akan memodifikasi "global".

Keseluruhan konsep ini jauh lebih sederhana untuk dipahami daripada yang dibayangkan oleh para ilmuwan komputer. Jika fungsi dapat melakukan sesuatu yang berbeda berdasarkan hal-hal yang dapat berubah saat runtime, maka Anda tidak dapat menentukan apa yang akan dilakukannya hingga berfungsi, dan setiap kali dijalankan, fungsi tersebut dapat melakukan sesuatu yang berbeda. Apakah itu terbukti tidak mungkin atau tidak, itu jelas tidak mungkin.