Mengapa printf ("% f", 0); berikan perilaku yang tidak terdefinisi?

Pernyataan

printf("%f\n",0.0f);

mencetak 0.

Namun demikian, pernyataan tersebut

printf("%f\n",0);

mencetak nilai acak.

Saya menyadari bahwa saya menunjukkan semacam perilaku yang tidak jelas, tetapi saya tidak tahu mengapa secara spesifik.

Nilai floating point di mana semua bitnya 0 masih valid floatdengan nilai 0.
floatdan intberukuran sama pada mesin saya (bahkan jika itu relevan).

Mengapa menggunakan literal integer alih-alih literal floating point printfmenyebabkan perilaku ini?

PS perilaku yang sama dapat dilihat jika saya menggunakan

int i = 0;
printf("%f\n", i);

The "%f"Format membutuhkan sebuah argumen tipe double. Anda memberikan argumen tipe int. Itulah mengapa perilakunya tidak terdefinisi.

Standar tidak menjamin bahwa semua-bit-nol adalah representasi yang valid 0.0(meskipun sering), atau dari doublenilai apa pun , atau itu intdan doubleberukuran sama (ingat itu double, bukanfloat ), atau, bahkan jika mereka sama size, yang diteruskan sebagai argumen ke fungsi variadic dengan cara yang sama.

Ini mungkin terjadi untuk "bekerja" di sistem Anda. Itu kemungkinan gejala terburuk dari perilaku tidak terdefinisi, karena itu menyulitkan untuk mendiagnosis kesalahan.

N1570 7.21.6.1 paragraf 9:

... Jika ada argumen yang bukan tipe yang benar untuk spesifikasi konversi yang sesuai, perilaku tidak ditentukan.

Argumen tipe floatdipromosikan double, itulah sebabnya printf("%f\n",0.0f)berhasil. Argumen jenis integer lebih sempit daripada intyang dipromosikan ke intatau ke unsigned int. Aturan promosi ini (ditentukan oleh N1570 6.5.2.2 paragraf 6) tidak membantu dalam kasus printf("%f\n", 0).

Perhatikan bahwa jika Anda meneruskan konstanta 0ke fungsi non-variadic yang mengharapkan doubleargumen, perilakunya didefinisikan dengan baik, dengan asumsi prototipe fungsi terlihat. Misalnya, sqrt(0)(setelah #include <math.h>) secara implisit mengonversi argumen 0dari intmenjadi double- karena kompilator dapat melihat dari deklarasi sqrtbahwa ia mengharapkan doubleargumen. Tidak ada informasi seperti itu untuk printf. Fungsi variadik seperti printfitu istimewa, dan membutuhkan lebih banyak perhatian dalam menulis panggilan kepada mereka.

Off pertama, seperti yang disinggung di beberapa jawaban yang lain tetapi tidak, pikiran saya, terbilang cukup jelas: Ini tidak bekerja untuk memberikan sebuah integer dalam kebanyakan konteks di mana fungsi perpustakaan membutuhkan doubleatau floatargumen. Kompilator secara otomatis akan memasukkan konversi. Misalnya, sqrt(0)terdefinisi dengan baik dan akan berperilaku persis seperti sqrt((double)0), dan hal yang sama berlaku untuk ekspresi tipe bilangan bulat lainnya yang digunakan di sana.

printfberbeda. Ini berbeda karena membutuhkan sejumlah variabel argumen. Prototipe fungsinya adalah

extern int printf(const char *fmt, ...);

Karena itu, saat Anda menulis

printf(message, 0);

kompilator tidak mempunyai informasi apapun tentang tipe apa yang printf mengharapkan argumen kedua itu. Ini hanya memiliki tipe ekspresi argumen, yaitu int, untuk dilalui. Oleh karena itu, tidak seperti kebanyakan fungsi perpustakaan, Anda, programmer, untuk memastikan daftar argumen sesuai dengan harapan format string.

(Kompiler modern dapat melihat ke dalam string format dan memberi tahu Anda bahwa Anda memiliki jenis ketidakcocokan, tetapi mereka tidak akan mulai memasukkan konversi untuk mencapai apa yang Anda maksud, karena lebih baik kode Anda harus rusak sekarang, ketika Anda akan melihatnya , dibandingkan beberapa tahun kemudian ketika dibangun kembali dengan kompilator yang kurang membantu.)

Sekarang, separuh pertanyaan lainnya adalah: Mengingat bahwa (int) 0 dan (float) 0.0, pada kebanyakan sistem modern, keduanya direpresentasikan sebagai 32 bit yang semuanya nol, mengapa tetap tidak berfungsi, secara tidak sengaja? Standar C hanya mengatakan "ini tidak diharuskan untuk bekerja, Anda sendiri", tapi izinkan saya menjelaskan dua alasan paling umum mengapa ini tidak akan berhasil; yang mungkin akan membantu Anda memahami mengapa hal itu tidak diwajibkan.

Pertama, karena alasan historis, ketika Anda melewati floatmelalui daftar argumen variabel itu akan dipromosikan untuk double, yang, pada kebanyakan sistem modern, adalah 64 bit lebar. Jadi printf("%f", 0)hanya mengirimkan 32 bit nol ke callee mengharapkan 64 dari mereka.

Kedua, alasan yang sama penting adalah bahwa argumen fungsi floating-point dapat dilewatkan di berbagai tempat dari argumen integer. Misalnya, sebagian besar CPU memiliki file register terpisah untuk bilangan bulat dan nilai floating-point, jadi mungkin ada aturan bahwa argumen 0 hingga 4 masuk dalam register r0 hingga r4 jika bilangan bulat, tetapi f0 hingga f4 jika berupa floating-point. Jadi printf("%f", 0)lihat di register f1 untuk nol itu, tapi tidak ada sama sekali.

Biasanya ketika Anda memanggil fungsi yang mengharapkan a double, tetapi Anda menyediakannya int, kompilator akan secara otomatis mengonversi menjadi doubleuntuk Anda. Itu tidak terjadi dengan printf, karena jenis argumen tidak ditentukan dalam prototipe fungsi - kompilator tidak tahu bahwa konversi harus diterapkan.

Mengapa menggunakan literal integer alih-alih literal float menyebabkan perilaku ini?

Karena printf()tidak ada parameter yang diketik selain const char* formatstringsebagai yang pertama. Ini menggunakan elipsis gaya-c (... ) untuk yang lainnya.

Ini hanya memutuskan bagaimana menafsirkan nilai yang diteruskan di sana sesuai dengan jenis pemformatan yang diberikan dalam format string.

Anda akan memiliki jenis perilaku tidak terdefinisi yang sama seperti saat mencoba

 int i = 0;
 const double* pf = (const double*)(&i);
 printf("%f\n",*pf); // dereferencing the pointer is UB

Menggunakan mis-matched printf()specifier "%f"dan ketik (int) 0mengarah ke perilaku undefined.

Jika spesifikasi konversi tidak valid, perilakunya tidak ditentukan. C11dr §7.21.6.1 9

Kandidat penyebab UB.

1. Ini adalah UB per spesifikasi dan kompilasi rumit - 'kata nuf.

2. doubledan intmemiliki ukuran yang berbeda.

3. doubledan intdapat meneruskan nilainya menggunakan tumpukan yang berbeda (tumpukan umum vs. FPU .)

4. A double 0.0 mungkin tidak ditentukan oleh semua pola bit nol. (langka)

Ini adalah salah satu peluang bagus untuk belajar dari peringatan kompiler Anda.

$ gcc -Wall -Wextra -pedantic fnord.c 
fnord.c: In function ‘main’:
fnord.c:8:2: warning: format ‘%f’ expects argument of type ‘double’, but argument 2 has type ‘int’ [-Wformat=]
  printf("%f\n",0);
  ^

atau

$ clang -Weverything -pedantic fnord.c 
fnord.c:8:16: warning: format specifies type 'double' but the argument has type 'int' [-Wformat]
        printf("%f\n",0);
                ~~    ^
                %d
1 warning generated.

Jadi, printfmenghasilkan perilaku tidak terdefinisi karena Anda meneruskannya dengan jenis argumen yang tidak kompatibel.

Saya tidak yakin apa yang membingungkan.

String format Anda mengharapkan a double; Anda memberikan sebagai gantinyaint .

Apakah kedua jenis memiliki lebar bit yang sama sama sekali tidak relevan, kecuali hal itu dapat membantu Anda menghindari pengecualian pelanggaran memori keras dari kode rusak seperti ini.

"%f\n"menjamin hasil yang dapat diprediksi hanya jika printf()parameter kedua memiliki tipe double. Selanjutnya, argumen tambahan dari fungsi variadic adalah subjek dari promosi argumen default. Argumen bilangan bulat termasuk dalam promosi bilangan bulat, yang tidak pernah menghasilkan nilai tipe floating-point. Dan floatparameter dipromosikan menjadidouble .

Untuk melengkapi: standar memungkinkan argumen kedua menjadi atau floatatau doubledan tidak ada yang lain.

Mengapa secara formal UB kini telah dibahas dalam beberapa jawaban.

Alasan mengapa Anda secara khusus mendapatkan perilaku ini bergantung pada platform, tetapi mungkin adalah sebagai berikut:

• printfmengharapkan argumennya sesuai dengan propagasi vararg standar. Itu berarti floatwasiat menjadi a doubledan apa pun yang lebih kecil dari intwasiat menjadi int.
• Anda melewati intdimana fungsi mengharapkan a double. Anda intmungkin 32 bit, double64 bit Anda. Itu berarti bahwa empat byte tumpukan dimulai dari tempat argumen seharusnya berada 0, tetapi empat byte berikut memiliki konten yang berubah-ubah. Itulah yang digunakan untuk membangun nilai yang ditampilkan.

Penyebab utama dari masalah "nilai tidak ditentukan" ini berdiri di cast penunjuk pada intnilai yang diteruskan ke bagian printfparameter variabel ke penunjuk pada doublejenis yang va_argdijalankan makro.

Hal ini menyebabkan referensi ke area memori yang tidak sepenuhnya diinisialisasi dengan nilai yang diteruskan sebagai parameter ke printf, karena doubleukuran area buffer memori lebih besar dari intukuran.

Oleh karena itu, ketika penunjuk ini didereferensi, ia mengembalikan nilai yang belum ditentukan, atau lebih baik "nilai" yang berisi sebagian nilai yang diteruskan sebagai parameter ke printf, dan untuk bagian yang tersisa dapat berasal dari area buffer tumpukan lain atau bahkan area kode ( meningkatkan pengecualian kesalahan memori), buffer overflow nyata .


Itu dapat mempertimbangkan bagian spesifik dari implementasi kode semplificated dari "printf" dan "va_arg" ...

printf

va_list arg;
....
case('%f')
      va_arg ( arg, double ); //va_arg is a macro, and so you can pass it the "type" that will be used for casting the int pointer argument of printf..
.... 

implementasi nyata di vprintf (mempertimbangkan gnu impl.) dari manajemen kasus kode parameter nilai ganda adalah:

if (__ldbl_is_dbl)
{
   args_value[cnt].pa_double = va_arg (ap_save, double);
   ...
}

va_arg

char *p = (double *) &arg + sizeof arg;  //printf parameters area pointer

double i2 = *((double *)p); //casting to double because va_arg(arg, double)
   p += sizeof (double);

referensi

1. implementasi gnu project glibc dari "printf" (vprintf))
2. contoh kode semplifikasi printf
3. contoh kode semplifikasi va_arg