Mengapa membuang nilai pengembalian yang tidak terpakai ke batal?

int fn();

void whatever()
{
    (void) fn();
}

Apakah ada alasan untuk membuang nilai pengembalian yang tidak terpakai, atau apakah saya benar berpikir itu hanya membuang-buang waktu?

Mengikuti:

Sepertinya itu cukup komprehensif. Saya kira itu lebih baik daripada mengomentari nilai kembali yang tidak digunakan karena kode yang mendokumentasikan diri lebih baik daripada komentar. Secara pribadi, saya akan mematikan peringatan ini karena itu suara yang tidak perlu.

Aku akan makan kata-kataku jika serangga lolos karenanya ...

Jawaban David cukup banyak mencakup motivasi untuk ini, untuk secara eksplisit menunjukkan kepada "pengembang" lain bahwa Anda tahu fungsi ini kembali tetapi Anda secara eksplisit mengabaikannya.

Ini adalah cara untuk memastikan bahwa kode kesalahan yang diperlukan selalu ditangani.

Saya pikir untuk C ++ ini mungkin satu-satunya tempat yang saya lebih suka menggunakan cast gaya-C juga, karena menggunakan notasi cast statis penuh terasa seperti berlebihan di sini. Terakhir, jika Anda meninjau standar pengkodean atau menulisnya, ada baiknya juga untuk menyatakan secara eksplisit bahwa panggilan ke operator yang kelebihan beban (tidak menggunakan notasi panggilan fungsi) harus dikecualikan dari ini juga:

class A {};
A operator+(A const &, A const &);

int main () {
  A a;
  a + a;                 // Not a problem
  (void)operator+(a,a);  // Using function call notation - so add the cast.

Di tempat kerja kami menggunakannya untuk mengetahui bahwa fungsi tersebut memiliki nilai kembali tetapi pengembang telah menegaskan bahwa aman untuk mengabaikannya. Karena Anda menandai pertanyaan sebagai C ++, Anda harus menggunakan static_cast :

static_cast<void>(fn());

Sejauh kompiler pergi mentransmisikan nilai kembali ke void memiliki sedikit arti.

Alasan sebenarnya untuk melakukan ini berasal dari alat yang digunakan pada kode C, yang disebut lint .

Ini menganalisis kode untuk mencari kemungkinan masalah dan mengeluarkan peringatan dan saran. Jika suatu fungsi mengembalikan nilai yang kemudian tidak diperiksa, lintakan memperingatkan jika ini tidak disengaja. Untuk menonaktifkan lintperingatan ini, Anda melakukan panggilan ke (void).

Mentransmisikan ke voiddigunakan untuk menyembunyikan peringatan compiler untuk variabel yang tidak digunakan dan nilai atau ekspresi yang dikembalikan yang belum disimpan.

The Standard (2003) mengatakan dalam §5.2.9 / 4 mengatakan,

Ekspresi apa pun dapat secara eksplisit dikonversi ke jenis "cv void". Nilai ekspresi dibuang .

Jadi Anda bisa menulis:

//suppressing unused variable warnings
static_cast<void>(unusedVar);
static_cast<const void>(unusedVar);
static_cast<volatile void>(unusedVar);

//suppressing return value warnings
static_cast<void>(fn());
static_cast<const void>(fn());
static_cast<volatile void>(fn());

//suppressing unsaved expressions
static_cast<void>(a + b * 10);
static_cast<const void>( x &&y || z);
static_cast<volatile void>( m | n + fn());

Semua formulir valid. Saya biasanya membuatnya lebih pendek seperti:

//suppressing  expressions
(void)(unusedVar);
(void)(fn());
(void)(x &&y || z);

Ini juga oke.

Sejak c ++ 17 kami memiliki [[maybe_unused]]atribut yang dapat digunakan sebagai pengganti voidcast.

Transmisi ke void tidak memerlukan biaya. Ini hanya informasi untuk kompilator bagaimana memperlakukannya.

Untuk fungsionalitas program Anda, casting to void tidak ada artinya. Saya juga berpendapat bahwa Anda tidak boleh menggunakannya untuk memberi isyarat kepada orang yang membaca kode tersebut, seperti yang disarankan dalam jawaban David. Jika Anda ingin mengkomunikasikan sesuatu tentang niat Anda, lebih baik menggunakan komentar. Menambahkan pemeran seperti ini hanya akan terlihat aneh dan menimbulkan pertanyaan tentang kemungkinan alasannya. Hanya pendapat saya ...

Juga saat memverifikasi kode Anda sesuai dengan standar MISTA (atau lainnya), alat otomatis seperti LDRA tidak akan mengizinkan Anda memanggil fungsi yang memiliki tipe kembalian tanpa membuatnya mengembalikan nilai kecuali Anda secara eksplisit memasukkan nilai yang dikembalikan ke (void)

C ++ 17 [[nodiscard]]

C ++ 17 menstandarkan "bisnis yang diabaikan nilai pengembaliannya" dengan atribut.

Oleh karena itu, saya berharap penerapan yang sesuai akan selalu memberi peringatan hanya jika nodiscard diberikan, dan tidak pernah memperingatkan sebaliknya.

Contoh:

main.cpp

[[nodiscard]] int f() {
    return 1;
}

int main() {
    f();
}

menyusun:

g++ -std=c++17 -ggdb3 -O0 -Wall -Wextra -pedantic -o main.out main.cpp

hasil:

main.cpp: In function ‘int main()’:
main.cpp:6:6: warning: ignoring return value of ‘int f()’, declared with attribute nodiscard [-Wunused-result]
    6 |     f();
      |     ~^~
main.cpp:1:19: note: declared here
    1 | [[nodiscard]] int f() {
      | 

Berikut semua hindari peringatan:

(void)f();
[[maybe_unused]] int i = f();

Saya tidak dapat menggunakan maybe_unusedlangsung pada f()panggilan:

[[maybe_unused]] f();

memberikan:

main.cpp: In function ‘int main()’:
main.cpp:6:5: warning: attributes at the beginning of statement are ignored [-Wattributes]
    6 |     [[maybe_unused]] f();
      |     ^~~~~~~~~~~~~~~~

Pekerjaan (void)pemeran tampaknya tidak wajib tetapi "didorong" dalam standar: Bagaimana saya bisa dengan sengaja membuang nilai kembalian [[nodiscard]]?

Juga terlihat dari pesan peringatan, salah satu "solusi" untuk peringatan tersebut adalah dengan menambahkan -Wno-unused-result:

g++ -std=c++17 -ggdb3 -O0 -Wall -Wextra -pedantic -Wno-unused-result -o main.out main.cpp

meskipun saya tentu saja tidak akan merekomendasikan mengabaikan peringatan secara global seperti ini.

C ++ 20 juga memungkinkan Anda untuk menambahkan alasan untuk nodiscardseperti dalam [[nodiscard("reason")]]seperti yang disebutkan di: https://en.cppreference.com/w/cpp/language/attributes/nodiscard

GCC warn_unused_resultAtribut

Sebelum standarisasi [[nodiscard]], dan untuk C sebelum mereka akhirnya memutuskan untuk menstandarkan atribut, GCC mengimplementasikan fungsi yang sama persis dengan warn_unused_result:

int f() __attribute__ ((warn_unused_result));

int f() {
    return 1;
}

int main() {
    f();
}

pemberian yang mana:

main.cpp: In function ‘int main()’:
main.cpp:8:6: warning: ignoring return value of ‘int f()’, declared with attribute warn_unused_result [-Wunused-result]
    8 |     f();
      |     ~^~

Perlu dicatat kemudian bahwa karena ANSI C tidak memiliki standar untuk ini, ANSI C tidak menentukan fungsi perpustakaan standar C mana yang memiliki atribut atau tidak dan oleh karena itu implementasi telah membuat keputusan sendiri tentang apa yang harus atau tidak ditandai dengan warn_unuesd_result, yang mana itulah sebabnya secara umum Anda harus menggunakan (void)cast untuk mengabaikan pengembalian panggilan apa pun ke fungsi library standar untuk sepenuhnya menghindari peringatan dalam implementasi apa pun.

Diuji di GCC 9.2.1, Ubuntu 19.10.