C ++: sesi arkeologi spontan dan mengapa Anda tidak harus menggunakan fungsi variabel dalam gaya C

Bagaimana dengan elipsis dan va_list dikatakan dalam Standar

• Anda dapat mendeklarasikan fungsi yang mengambil sejumlah argumen sembarang. Yaitu suatu fungsi dapat memiliki lebih banyak argumen daripada parameter. Untuk melakukan ini, daftar parameternya harus diakhiri dengan elipsis, tetapi setidaknya satu parameter tetap [C11 6.9.1 / 8] juga harus ada:
  
  

   void foo(int parm1, int parm2, ...); 

• Informasi tentang jumlah dan jenis argumen yang sesuai dengan elipsis tidak diteruskan ke fungsi itu sendiri. Yaitu setelah parameter bernama terakhir ( parm2 pada contoh di atas) [C11 6.7.6.3/9] .
  
• Untuk mengakses argumen ini, Anda harus menggunakan tipe va_list dideklarasikan di header <stdarg.h> dan 4 (3 sebelum standar C11) makro: va_start , va_arg , va_end dan va_copy (dimulai dengan C11) [C11 7.16] .
  
  
  Sebagai contoh

   int add(int count, ...) { int result = 0; va_list args; va_start(args, count); for (int i = 0; i < count; ++i) { result += va_arg(args, int); } va_end(args); return result; } 

  
  Ya, fungsinya tidak tahu berapa banyak argumen yang dimilikinya. Dia perlu melewati nomor ini. Dalam hal ini, melalui argumen bernama tunggal (opsi umum lainnya adalah untuk melewati NULL sebagai argumen terakhir, seperti dalam execl , atau 0).
• Argumen yang disebutkan terakhir tidak dapat memiliki kelas penyimpanan register , tidak bisa berupa fungsi atau array. Jika tidak, perilaku tidak terdefinisi [C11 7.16.1.4/4] .
• Selain itu, untuk argumen yang disebutkan terakhir dan untuk semua yang tidak bernama, " promosi argumen default " diterapkan ( promosi argumen default ; jika ada terjemahan yang baik dari konsep ini ke dalam bahasa Rusia, saya dengan senang hati menggunakannya). Ini berarti bahwa jika argumen memiliki tipe char , short (dengan atau tanpa tanda) atau float , maka parameter yang sesuai harus diakses sebagai int , int (dengan atau tanpa tanda) atau double . Jika tidak, perilaku tidak terdefinisi [C11 7.16.1.1/2] .
• Tentang tipe va_list hanya dikatakan bahwa ia dideklarasikan dalam <stdarg.h> dan lengkap (yaitu, ukuran objek jenis ini diketahui) [C11 7.16 / 3] .

Mengapa Tetapi karena!

By the way, tidak ada cara yang dapat diterima untuk menulis fungsi portabel dari sejumlah argumen, karena Tidak ada cara portabel untuk fungsi yang dipanggil untuk mengetahui berapa banyak argumen yang diteruskan ketika dipanggil. ... printf , fungsi bahasa C paling umum dari sejumlah argumen arbitrer, ... tidak portabel dan harus diterapkan untuk setiap sistem.

 #ifndef _STADARG #define _STADARG #define _AUPBND 1 #define _ADNBND 1 typedef char* va_list #define va_arg(ap, T) \ (*(T*)(((ap) += _Bnd(T, _AUPBND)) - _Bnd(T, _ADNBND))) #define va_end(ap) \ (void)0 #define va_start(ap, A) \ (void)((ap) = (char*)&(A) + _Bnd(A, _AUPBND)) #define _Bnd(X, bnd) \ (sizeof(X) + (bnd) & ~(bnd)) #endif 

 typedef struct { unsigned int gp_offset; unsigned int fp_offset; void *overflow_arg_area; void *reg_save_area; } va_list[1]; 

Fungsi Variabel dalam C ++

• Karena C ++, tidak seperti C, memungkinkan Anda untuk mendapatkan alamat register dari variabel, maka argumen nama terakhir dari fungsi variabel dapat memiliki kelas penyimpanan ini.
  
• Karena tautan yang muncul di C ++ melanggar aturan fungsi variabel C yang tidak tertulis - ukuran parameter harus cocok dengan ukuran tipe yang dideklarasikan - maka argumen yang disebutkan terakhir tidak boleh berupa tautan. Jika tidak, perilaku yang tidak jelas.
  
• Karena di C ++ tidak ada konsep " meningkatkan jenis argumen secara default ", lalu frasa
  

  Jika parameter parmN dideklarasikan dengan ... tipe yang tidak kompatibel dengan tipe yang dihasilkan setelah aplikasi promosi argumen default, perilaku tidak terdefinisi

  harus diganti oleh

  Jika parameter parmN dideklarasikan dengan ... tipe yang tidak kompatibel dengan tipe yang dihasilkan ketika melewati argumen yang tidak ada parameter, perilaku tidak terdefinisi

Cara menggunakan fungsi variabel dengan mudah dan salah

1. Tidak benar untuk mendeklarasikan argumen yang disebutkan terakhir dengan tipe yang dipromosikan, mis. char , char signed char , unsigned char , singed short , unsigned short atau float . Hasil menurut Standar akan menjadi perilaku yang tidak terdefinisi.
   
   
   Kode tidak valid

    void foo(float n, ...) { va_list va; va_start(va, n); std::cout << va_arg(va, int) << std::endl; va_end(va); } 

   
   
   
   Dari semua kompiler yang saya miliki (gcc, dentang, MSVC), hanya dentang mengeluarkan peringatan.
   
   
   Peringatan dentang

    ./test.cpp:7:18: warning: passing an object that undergoes default argument promotion to 'va_start' has undefined behavior [-Wvarargs] va_start(va, n); ^ 

   
   Dan meskipun dalam semua kasus kode yang dikompilasi berperilaku dengan benar, Anda tidak harus mengandalkannya.
   
   
   Itu akan benar

    void foo(double n, ...) { va_list va; va_start(va, n); std::cout << va_arg(va, int) << std::endl; va_end(va); } 

   
   
2. Tidak benar untuk menyatakan argumen yang disebutkan terakhir sebagai referensi. Tautan apa saja. Standar dalam hal ini juga menjanjikan perilaku yang tidak terdefinisi.
   
   
   Kode tidak valid

    void foo(int& n, ...) { va_list va; va_start(va, n); std::cout << va_arg(va, int) << std::endl; va_end(va); } 

   
   gcc 7.3.0 menyusun kode ini tanpa satu komentar. lang 6.0.0 mengeluarkan peringatan, tetapi masih menyusunnya.
   
   
   Peringatan dentang

    ./test.cpp:7:18: warning: passing an object of reference type to 'va_start' has undefined behavior [-Wvarargs] va_start(va, n); ^ 

   
   Dalam kedua kasus, program bekerja dengan benar (beruntung, Anda tidak dapat mengandalkannya). Tetapi MSVC 19.15.26730 membedakan dirinya - ia menolak untuk mengkompilasi kode, karena Argumen va_start tidak boleh menjadi referensi.
   
   
   Kesalahan dari MSVC

    c:\program files (x86)\microsoft visual studio\2017\community\vc\tools\msvc\14.15.26726\include\vadefs.h(151): error C2338: va_start argument must not have reference type and must not be parenthesized 

   
   
   Nah, opsi yang benar terlihat, misalnya, seperti ini

    void foo(int* n, ...) { va_list va; va_start(va, n); std::cout << va_arg(va, int) << std::endl; va_end(va); } 

   
   
3. Salah meminta va_arg menaikkan tipe - char , short atau float .
   
   
   Kode tidak valid

    #include <cstdarg> #include <iostream> void foo(int n, ...) { va_list va; va_start(va, n); std::cout << va_arg(va, int) << std::endl; std::cout << va_arg(va, float) << std::endl; std::cout << va_arg(va, int) << std::endl; va_end(va); } int main() { foo(0, 1, 2.0f, 3); return 0; } 

   
   Lebih menarik di sini. gcc pada saat kompilasi memberikan peringatan bahwa perlu menggunakan double daripada float , dan jika kode ini masih dijalankan, program akan berakhir dengan kesalahan.
   
   
   Peringatan gcc

    ./test.cpp:9:15: warning: 'float' is promoted to 'double' when passed through '...' std::cout << va_arg(va, float) << std::endl; ^~~~~~ ./test.cpp:9:15: note: (so you should pass 'double' not 'float' to 'va_arg') ./test.cpp:9:15: note: if this code is reached, the program will abort 

   
   Memang, program macet dengan keluhan tentang instruksi yang tidak valid.
   Analisis dump menunjukkan bahwa program menerima sinyal SIGILL. Dan itu juga menunjukkan struktur va_list . Untuk 32 bit ini
   
   

    va = 0xfffc6918 "" 

   
   yaitu va_list hanya char* . Untuk 64 bit:
   
   

    va = {{gp_offset = 16, fp_offset = 48, overflow_arg_area = 0x7ffef147e7e0, reg_save_area = 0x7ffef147e720}} 

   
   yaitu persis apa yang dijelaskan dalam SystemV ABI AMD64.
   
   dentang pada kompilasi memperingatkan perilaku tidak terdefinisi dan juga menyarankan mengganti float dengan double .
   
   
   Peringatan dentang

    ./test.cpp:9:26: warning: second argument to 'va_arg' is of promotable type 'float'; this va_arg has undefined behavior because arguments will be promoted to 'double' [-Wvarargs] std::cout << va_arg(va, float) << std::endl; ^~~~~ 

   
   Tetapi program tidak lagi crash, versi 32-bit menghasilkan:
   
   

    1 0 1073741824 

   
   64 bit:
   
   

    1 0 3 

   
   MSVC menghasilkan hasil yang persis sama, hanya tanpa peringatan, bahkan dengan /Wall .
   
   Di sini dapat diasumsikan bahwa perbedaan antara 32 dan 64 bit disebabkan oleh fakta bahwa dalam kasus pertama, ABI melewati semua argumen melalui stack ke fungsi yang disebut, dan pada yang kedua, empat (Windows) atau enam (Linux) argumen pertama melalui register prosesor, sisanya melalui susun [ wiki ]. Tetapi tidak, jika Anda memanggil foo bukan dengan 4 argumen, tetapi dengan 19, dan mengeluarkannya dengan cara yang sama, hasilnya akan sama: kekacauan penuh dalam versi 32-bit, dan nol untuk semua float di 64-bit. Yaitu intinya tentu saja di ABI, tetapi tidak dalam penggunaan register untuk mengajukan argumen.
   
   
   Ya, tentu saja, itu benar

    void foo(int n, ...) { va_list va; va_start(va, n); std::cout << va_arg(va, int) << std::endl; std::cout << va_arg(va, double) << std::endl; std::cout << va_arg(va, int) << std::endl; va_end(va); } 

   
   
4. Tidak benar untuk melewatkan instance kelas dengan konstruktor nontrivial atau destruktor sebagai argumen yang tidak disebutkan namanya. Kecuali, tentu saja, nasib kode ini menggairahkan Anda setidaknya sedikit lebih dari "kompilasi dan jalankan di sini dan sekarang."
   
   
   Kode tidak valid

    #include <cstdarg> #include <iostream> struct Bar { Bar() { std::cout << "Bar default ctor" << std::endl; } Bar(const Bar&) { std::cout << "Bar copy ctor" << std::endl; } ~Bar() { std::cout << "Bar dtor" << std::endl; } }; struct Cafe { Cafe() { std::cout << "Cafe default ctor" << std::endl; } Cafe(const Cafe&) { std::cout << "Cafe copy ctor" << std::endl; } ~Cafe() { std::cout << "Cafe dtor" << std::endl; } }; void foo(int n, ...) { va_list va; va_start(va, n); std::cout << "Before va_arg" << std::endl; const auto b = va_arg(va, Bar); va_end(va); } int main() { Bar b; Cafe c; foo(1, b, c); return 0; } 

   
   Dentang lebih keras dari semua. Dia hanya menolak untuk mengkompilasi kode ini karena argumen kedua, va_arg bukan tipe POD, dan memperingatkan bahwa program akan va_arg saat startup.
   
   
   Peringatan dentang

    ./test.cpp:23:31: error: second argument to 'va_arg' is of non-POD type 'Bar' [-Wnon-pod-varargs] const auto b = va_arg(va, Bar); ^~~ ./test.cpp:31:12: error: cannot pass object of non-trivial type 'Bar' through variadic function; call will abort at runtime [-Wnon-pod-varargs] foo(1, b, c); ^ 

   
   Jadi, jika Anda masih mengkompilasi dengan -Wno-non-pod-varargs .
   
   MSVC memperingatkan bahwa penggunaan tipe dengan konstruktor non-sepele dalam hal ini tidak portabel.
   
   
   Peringatan dari MSVC

    d:\my documents\visual studio 2017\projects\test\test\main.cpp(31): warning C4840:    "Bar"          

   
   Tetapi kode mengkompilasi dan berjalan dengan benar. Berikut ini diperoleh di konsol:
   
   
   Peluncuran hasil

    Bar default ctor Cafe default ctor Before va_arg Bar copy ctor Bar dtor Cafe dtor Bar dtor 

   
   Yaitu salinan dibuat hanya pada saat memanggil va_arg , dan argumennya, ternyata, dilewatkan dengan referensi. Entah bagaimana itu tidak jelas, tetapi Standar mengizinkan.
   
   gcc 6.3.0 mengkompilasi tanpa satu komentar. Outputnya sama:
   
   
   Peluncuran hasil

    Bar default ctor Cafe default ctor Before va_arg Bar copy ctor Bar dtor Cafe dtor Bar dtor 

   
   gcc 7.3.0 juga tidak memperingatkan tentang apa pun, tetapi perilaku berubah:
   
   
   Peluncuran hasil

    Bar default ctor Cafe default ctor Cafe copy ctor Bar copy ctor Before va_arg Bar copy ctor Bar dtor Bar dtor Cafe dtor Cafe dtor Bar dtor 

   
   Yaitu versi kompiler ini meneruskan argumen dengan nilai, dan ketika dipanggil, va_arg membuat salinan lain. Akan menyenangkan untuk mencari perbedaan ini ketika beralih dari versi ke-6 ke gcc jika konstruktor / destruktor memiliki efek samping.
   
   Omong-omong, jika Anda secara eksplisit lulus dan meminta referensi ke kelas:
   
   
   Kode salah lain

    void foo(int n, ...) { va_list va; va_start(va, n); std::cout << "Before va_arg" << std::endl; const auto& b = va_arg(va, Bar&); va_end(va); } int main() { Bar b; Cafe c; foo(1, std::ref(b), c); return 0; } 

   
   maka semua kompiler akan melakukan kesalahan. Seperti yang disyaratkan oleh Standar.
   
   Secara umum, jika Anda benar-benar ingin, lebih baik memberikan argumen dengan pointer.
   
   
   Seperti ini

    void foo(int n, ...) { va_list va; va_start(va, n); std::cout << "Before va_arg" << std::endl; const auto* b = va_arg(va, Bar*); va_end(va); } int main() { Bar b; Cafe c; foo(1, &b, &c); return 0; } 

   
   

Resolusi Kelebihan dan Fungsi Variabel

 #include <iostream> void foo(...) { std::cout << "C variadic function" << std::endl; } void foo(int) { std::cout << "Ordinary function" << std::endl; } int main() { foo(1); foo(1ul); foo(); return 0; } 

 $ ./test Ordinary function Ordinary function C variadic function 

 #include <iostream> void foo(...) { std::cout << "C variadic function" << std::endl; } void foo() { std::cout << "Ordinary function without arguments" << std::endl; } int main() { foo(1); foo(); return 0; } 

 ./test.cpp:16:9: error: call of overloaded 'foo()' is ambiguous foo(); ^ ./test.cpp:3:6: note: candidate: void foo(...) void foo(...) ^~~ ./test.cpp:8:6: note: candidate: void foo() void foo() ^~~ 

Namun kapan layak menggunakan fungsi variabel

• Kasus yang paling umum dan jelas adalah kompatibilitas ke belakang. Di sini saya akan menyertakan penggunaan perpustakaan C pihak ketiga (kasus saya dengan JNI) dan penyediaan API C untuk implementasi C ++.
  
• SFINAE . Di sini, sangat berguna bahwa dalam C ++ fungsi variabel tidak harus memiliki nama argumen, dan ketika menyelesaikan fungsi yang kelebihan beban, fungsi variabel dianggap sebagai yang terakhir (jika ada setidaknya satu argumen). Dan seperti fungsi lainnya, fungsi variabel hanya dapat dideklarasikan, tetapi tidak pernah dipanggil.
  
  
  Contoh

   template <class T> struct HasFoo { private: template <class U, class = decltype(std::declval<U>().foo())> static void detect(const U&); static int detect(...); public: static constexpr bool value = std::is_same<void, decltype(detect(std::declval<T>()))>::value; }; 

  
  Meskipun dalam C ++ 14 Anda dapat melakukan sedikit berbeda.
  
  
  Contoh lain

   template <class T> struct HasFoo { private: template <class U, class = decltype(std::declval<U>().foo())> static constexpr bool detect(const U*) { return true; } template <class U> static constexpr bool detect(...) { return false; } public: static constexpr bool value = detect<T>(nullptr); }; 

  
  Dan dalam hal ini sudah perlu untuk menonton dengan apa argumen detect(...) dapat dipanggil. Saya lebih suka mengubah beberapa baris dan menggunakan alternatif modern untuk fungsi variabel, tanpa semua kekurangannya.
  

Templat varian atau cara membuat fungsi dari sejumlah argumen arbitrer di C ++ modern

• parameter Template paket ( Template parameter pack ) - adalah template parameter, bukannya yang dimungkinkan untuk mentransfer (termasuk 0) jumlah argumen template;
  
• paket parameter fungsi ( paket parameter fungsi ) - karenanya, ini adalah parameter fungsi yang mengambil (termasuk 0) jumlah argumen fungsi;
  
• dan perluasan paket ( ekspansi paket ) adalah satu-satunya hal yang dapat dilakukan dengan paket parameter.
  

 template <class ... Args> void foo(const std::string& format, Args ... args) { printf(format.c_str(), args...); } 

• paket parameter fungsi dapat diperluas ke daftar argumen fungsi lain

   template <class ... Args> void bar(const std::string& format, Args ... args) { foo<Args...>(format.c_str(), args...); } 

  
  
• atau ke daftar inisialisasi

   template <class ... Args> void foo(const std::string& format, Args ... args) { const auto list = {args...}; } 

  
  
• atau ke daftar tangkap lambda

   template <class ... Args> void foo(const std::string& format, Args ... args) { auto lambda = [&format, args...] () { printf(format.c_str(), args...); }; lambda(); } 

  
  
• paket parameter fungsi lain dapat diperluas dalam ekspresi konvolusi

   template <class ... Args> int foo(Args ... args) { return (0 + ... + args); } 

  
  Konvolusi muncul di C ++ 14 dan bisa unary dan binary, kanan dan kiri. Deskripsi paling lengkap, seperti biasa, ada dalam Standar [C ++ 17 8.1.6] .
  
• kedua jenis paket parameter dapat diperluas menjadi sizeof ... operator

   template <class ... Args> void foo(Args ... args) { const auto size1 = sizeof...(Args); const auto size2 = sizeof...(args); } 

  
  

 template <class ... Args> void foo() { using OneTuple = std::tuple<std::tuple<Args>...>; using NestTuple = std::tuple<std::tuple<Args...>>; } 

Contoh implementasi printf menggunakan templat variabel

 void printf(const char* s) { while (*s) { if (*s == '%' && *++s != '%') throw std::runtime_error("invalid format string: missing arguments"); std::cout << *s++; } } template <typename T, typename ... Args> void printf(const char* s, T value, Args ... args) { while (*s) { if (*s == '%' && *++s != '%') { std::cout << value; return printf(++s, args...); } std::cout << *s++; } throw std::runtime_error("extra arguments provided to printf"); } 

 template <typename ... Args> void printf(const std::string& fmt, const Args& ... args) { size_t fmtIndex = 0; size_t placeHolders = 0; auto printFmt = [&fmt, &fmtIndex, &placeHolders]() { for (; fmtIndex < fmt.size(); ++fmtIndex) { if (fmt[fmtIndex] != '%') std::cout << fmt[fmtIndex]; else if (++fmtIndex < fmt.size()) { if (fmt[fmtIndex] == '%') std::cout << '%'; else { ++fmtIndex; ++placeHolders; break; } } } }; ((printFmt(), std::cout << args), ..., (printFmt())); if (placeHolders < sizeof...(args)) throw std::runtime_error("extra arguments provided to printf"); if (placeHolders > sizeof...(args)) throw std::runtime_error("invalid format string: missing arguments"); } 

Resolusi Kelebihan dan Fungsi Templat Variabel

 #include <iostream> void foo(int) { std::cout << "Ordinary function" << std::endl; } void foo() { std::cout << "Ordinary function without arguments" << std::endl; } template <class T> void foo(T) { std::cout << "Template function" << std::endl; } template <class ... Args> void foo(Args ...) { std::cout << "Template variadic function" << std::endl; } int main() { foo(1); foo(); foo(2.0); foo(1, 2); return 0; } 

 $ ./test Ordinary function Ordinary function without arguments Template function Template variadic function 

 #include <iostream> void foo(...) { std::cout << "C variadic function" << std::endl; } template <class ... Args> void foo(Args ...) { std::cout << "Template variadic function" << std::endl; } int main() { foo(1); foo(); return 0; } 

 $ ./test Template variadic function C variadic function 

Catatan singkat tentang kecepatan fungsi templat variabel

Ringkasan dan kesimpulan singkat

• Mereka tidak tahu jumlah argumen mereka atau tipenya. Pengembang harus menggunakan bagian dari argumen ke fungsi untuk meneruskan informasi tentang sisanya.
  
• Secara implisit meningkatkan jenis argumen yang tidak disebutkan namanya (dan yang terakhir disebutkan). Jika Anda melupakannya, Anda mendapatkan perilaku yang tidak jelas.
  
• Mereka mempertahankan kompatibilitas ke belakang dengan C murni dan karena itu tidak mendukung lewat argumen dengan referensi.
  
• Sebelum C ++ 11, argumen bukan dari tipe POD tidak didukung , dan karena C ++ 11, dukungan untuk tipe non-sepele diserahkan kepada kebijaksanaan kompilator. Yaitu Perilaku kode tergantung pada kompiler dan versinya.
  

• Ketahui jumlah dan jenis semua argumen mereka.
  
• Ketik aman, jangan mengubah jenis argumen mereka.
  
• Mereka mendukung lewat argumen dalam bentuk apa pun - dengan nilai, dengan pointer, dengan referensi, dengan tautan universal.
  
• Seperti fungsi C ++ lainnya, tidak ada batasan pada tipe argumen.
  
• ( C ), .
  

Sastra dan Sumber

• PJ Plauger, Perpustakaan C Standar
  
• Brian W. Kernighan dan Dennis M. Ritchie, Bahasa Pemrograman C, Edisi 1
  
• Brian W. Kernighan dan Dennis M. Ritchie, Bahasa Pemrograman C, Edisi ke-2
  
• Standar C11, konsep N1570
  
• Standar C ++ 98
  
• Standar C ++ 03
  
• C ++ 11 Standar, konsep N3337
  
• Standar C ++ 14, konsep N4296
  
• C ++ 17 Standar, konsep N4659
  

PS