Apakah #pragma pernah aman termasuk penjaga?

Saya pernah membaca bahwa ada beberapa optimasi kompiler saat menggunakan #pragma onceyang dapat menghasilkan kompilasi yang lebih cepat. Saya tahu itu tidak standar, dan karenanya bisa menimbulkan masalah kompatibilitas lintas platform.

Apakah ini sesuatu yang didukung oleh kebanyakan kompiler modern pada platform non-windows (gcc)?

Saya ingin menghindari masalah kompilasi platform, tetapi juga ingin menghindari pekerjaan ekstra dari penjaga cadangan:

#pragma once
#ifndef HEADER_H
#define HEADER_H

...

#endif // HEADER_H

Haruskah saya khawatir? Haruskah saya mengeluarkan energi mental lebih lanjut untuk ini?

Menggunakan #pragma onceharus bekerja pada kompiler modern apa pun, tapi saya tidak melihat alasan untuk tidak menggunakan standar #ifndeftermasuk penjaga. Ini bekerja dengan baik. Satu peringatan adalah bahwa GCC tidak mendukung #pragma oncesebelum versi 3.4 .

Saya juga menemukan bahwa, setidaknya pada GCC, ia mengenali standar #ifndeftermasuk penjaga dan mengoptimalkannya , jadi seharusnya tidak lebih lambat dari itu #pragma once.

#pragma once memang memiliki satu kelemahan (selain non-standar) dan itu adalah jika Anda memiliki file yang sama di lokasi yang berbeda (kami memiliki ini karena sistem build kami menyalin file di sekitar) maka kompiler akan berpikir ini adalah file yang berbeda.

Saya berharap #pragma once(atau sesuatu seperti itu) telah ada dalam standar. Menyertakan penjaga bukanlah masalah besar (tetapi mereka tampaknya agak sulit untuk dijelaskan kepada orang-orang yang belajar bahasa itu), tetapi sepertinya gangguan kecil yang bisa dihindari.

Bahkan, sejak 99,98% dari waktu, #pragma onceperilaku adalah perilaku yang diinginkan, akan lebih baik jika mencegah beberapa pemasukan header secara otomatis ditangani oleh kompiler, dengan #pragmaatau sesuatu untuk memungkinkan termasuk ganda.

Tetapi kami memiliki apa yang kami miliki (kecuali bahwa Anda mungkin tidak memiliki #pragma once).

Saya tidak tahu tentang manfaat kinerja tetapi pasti berhasil. Saya menggunakannya di semua proyek C ++ saya (diberikan saya menggunakan kompiler MS). Saya merasa ini lebih efektif daripada menggunakan

#ifndef HEADERNAME_H
#define HEADERNAME_H
...
#endif

Itu melakukan pekerjaan yang sama dan tidak mengisi preprocessor dengan makro tambahan.

GCC mendukung #pragma oncesecara resmi pada versi 3.4 .

GCC mendukung #pragma oncesejak 3.4, lihat http://en.wikipedia.org/wiki/Pragma_once untuk dukungan kompiler lebih lanjut.

Keuntungan besar yang saya lihat tentang penggunaan #pragma oncesebagai lawan untuk menyertakan penjaga adalah untuk menghindari kesalahan salin / tempel.

Mari kita hadapi itu: kebanyakan dari kita hampir tidak memulai file header baru dari awal, melainkan hanya menyalin yang sudah ada dan memodifikasinya sesuai kebutuhan kita. Jauh lebih mudah untuk membuat templat yang berfungsi menggunakan #pragma oncealih-alih menyertakan penjaga. Semakin sedikit saya harus memodifikasi template, semakin sedikit kemungkinan saya mengalami kesalahan. Memiliki penjaga yang sama termasuk dalam file yang berbeda mengarah ke kesalahan kompiler aneh dan butuh beberapa waktu untuk mencari tahu apa yang salah.

TL; DR: #pragma oncelebih mudah digunakan.

Saya menggunakannya dan saya senang dengan itu, karena saya harus mengetik jauh lebih sedikit untuk membuat header baru. Ini bekerja dengan baik untuk saya dalam tiga platform: Windows, Mac dan Linux.

Saya tidak memiliki informasi kinerja, tetapi saya percaya bahwa perbedaan antara #pragma dan penjaga menyertakan tidak akan ada artinya dibandingkan dengan lambatnya penguraian tata bahasa C ++. Itulah masalah sebenarnya. Cobalah untuk mengkompilasi jumlah file dan baris yang sama dengan kompiler C # misalnya, untuk melihat perbedaannya.

Pada akhirnya, menggunakan penjaga atau pragma, tidak masalah sama sekali.

Menggunakan ' #pragma once' mungkin tidak memiliki efek apa pun (tidak didukung di mana-mana - meskipun semakin banyak didukung), jadi Anda harus tetap menggunakan kode kompilasi bersyarat, dalam hal ini, mengapa repot-repot dengan ' #pragma once'? Kompilator mungkin mengoptimalkannya. Itu tergantung pada platform target Anda. Jika semua target Anda mendukungnya, maka maju dan gunakan itu - tetapi itu harus menjadi keputusan sadar karena semua akan hancur jika Anda hanya menggunakan pragma dan kemudian port ke kompiler yang tidak mendukungnya.

Manfaat kinerja adalah dari tidak harus membuka kembali file setelah #pragma pernah dibaca. Dengan penjaga, kompiler harus membuka file (yang dapat memakan waktu) untuk mendapatkan informasi yang seharusnya tidak termasuk konten lagi.

Itu adalah teori hanya karena beberapa kompiler secara otomatis tidak akan membuka file yang tidak memiliki kode baca, untuk setiap unit kompilasi.

Pokoknya, ini bukan kasus untuk semua kompiler, jadi idealnya #pragma harus dihindari untuk kode lintas-platform yang bukan standar sama sekali / tidak memiliki definisi dan efek standar. Namun, secara praktis, ini benar-benar lebih baik daripada penjaga.

Pada akhirnya, saran terbaik yang bisa Anda dapatkan untuk memastikan memiliki kecepatan terbaik dari kompiler Anda tanpa harus memeriksa perilaku masing-masing kompiler dalam hal ini, adalah menggunakan pragma sekaligus dan penjaga.

#ifndef NR_TEST_H
#define NR_TEST_H
#pragma once

#include "Thing.h"

namespace MyApp
{
 // ...
}

#endif

Dengan begitu Anda mendapatkan yang terbaik dari keduanya (cross-platform dan membantu kecepatan kompilasi).

Karena lebih lama untuk mengetik, saya pribadi menggunakan alat untuk membantu menghasilkan semua itu dengan cara yang sangat sumbu (Visual Assist X).

Tidak selalu.

http://gcc.gnu.org/bugzilla/show_bug.cgi?id=52566 memiliki contoh yang bagus tentang dua file yang dimaksudkan untuk disertakan, tetapi secara keliru dianggap identik karena cap waktu dan konten yang identik (bukan nama file yang identik) .

Menggunakan gcc 3.4 dan 4.1 pada pohon yang sangat besar (kadang-kadang memanfaatkan distcc ), saya belum melihat kecepatan ketika menggunakan #pragma sekali sebagai pengganti, atau dalam kombinasi dengan standar termasuk penjaga.

Saya benar-benar tidak melihat bagaimana nilainya berpotensi membingungkan versi gcc lama, atau bahkan kompiler lain karena tidak ada penghematan nyata. Saya belum mencoba semua de-linter, tetapi saya berani bertaruh itu akan membingungkan banyak dari mereka.

Saya juga berharap itu telah diadopsi sejak awal, tetapi saya dapat melihat argumen "Mengapa kita membutuhkan itu jika ifndef bekerja dengan baik?". Mengingat banyak sudut dan kompleksitas C yang gelap, termasuk penjaga adalah salah satu hal yang paling mudah dan menjelaskan sendiri. Jika Anda bahkan memiliki sedikit pengetahuan tentang cara kerja preprosesor, mereka harus jelas.

Namun, jika Anda mengamati peningkatan yang signifikan, perbarui pertanyaan Anda.

Hari ini sekolah tua termasuk penjaga secepat pragma sekali. Bahkan jika kompilator tidak memperlakukan mereka secara khusus, itu akan tetap berhenti ketika melihat # jika andHATI APA dan APA yang didefinisikan. Membuka file sangat murah hari ini. Bahkan jika ada perbaikan, itu akan berada dalam urutan milidetik.

Saya hanya tidak menggunakan #pragma sekali, karena tidak memiliki manfaat. Untuk menghindari bentrok dengan penjaga menyertakan lainnya saya menggunakan sesuatu seperti: CI_APP_MODULE_FILE_H -> CI = Inisial Perusahaan; APP = Nama aplikasi; sisanya jelas.

Perbedaan utama adalah bahwa kompiler harus membuka file header untuk membaca guard include. Sebagai perbandingan, pragma pernah menyebabkan kompiler untuk melacak file dan tidak melakukan file IO ketika menemukan file lain termasuk untuk file yang sama. Meskipun itu kedengarannya dapat diabaikan, ia dapat dengan mudah ditingkatkan dengan proyek-proyek besar, terutama yang tanpa header yang baik termasuk disiplin ilmu.

Yang mengatakan, hari ini kompiler (termasuk GCC) cukup pintar untuk memperlakukan termasuk penjaga seperti pragma sekali. yaitu mereka tidak membuka file dan menghindari hukuman file IO.

Dalam kompiler yang tidak mendukung pragma saya telah melihat implementasi manual yang sedikit rumit ..

#ifdef FOO_H
#include "foo.h"
#endif

Saya pribadi suka pendekatan #pragma sekali karena menghindari kerumitan penamaan tabrakan dan kesalahan ketik potensial. Ini juga kode yang lebih elegan dengan perbandingan. Yang mengatakan, untuk kode portabel, tidak ada salahnya untuk memiliki keduanya kecuali jika kompiler mengeluh tentang hal itu.

Jika kita menggunakan msvc atau Qt (hingga Qt 4.5), karena GCC (hingga 3.4), msvc keduanya mendukung #pragma once, saya tidak dapat melihat alasan untuk tidak menggunakan #pragma once.

Nama file sumber biasanya sama dengan nama kelas, dan kami tahu, kadang-kadang kami perlu refactor , untuk mengganti nama kelas, maka kami harus mengubah #include XXXXjuga, jadi saya pikir pemeliharaan manual #include xxxxxbukanlah pekerjaan yang cerdas. bahkan dengan ekstensi Visual Assist X, mempertahankan "xxxx" bukanlah pekerjaan yang diperlukan.

Catatan tambahan untuk orang-orang yang berpikir bahwa pemasukan file header secara otomatis satu kali saja selalu diinginkan: Saya membuat generator kode menggunakan inklusi file header ganda atau ganda sejak beberapa dekade. Khusus untuk pembuatan rintisan pustaka protokol saya merasa sangat nyaman untuk memiliki generator kode yang sangat portabel dan kuat tanpa alat dan bahasa tambahan. Saya bukan satu-satunya pengembang yang menggunakan skema ini karena blog ini menunjukkan X-Macros . Ini tidak akan mungkin dilakukan tanpa penjagaan otomatis yang hilang.