#pragma ปลอดภัยครั้งหนึ่งเคยมีผู้พิทักษ์หรือไม่

ฉันได้อ่านแล้วว่ามีการเพิ่มประสิทธิภาพคอมไพเลอร์เมื่อใช้งาน#pragma onceซึ่งอาจทำให้การรวบรวมเร็วขึ้น ฉันรู้ว่าไม่เป็นมาตรฐานและอาจก่อให้เกิดปัญหาความเข้ากันได้ข้ามแพลตฟอร์ม

นี่เป็นสิ่งที่สนับสนุนโดยคอมไพเลอร์ที่ทันสมัยที่สุดบนแพลตฟอร์มที่ไม่ใช่ windows (gcc) หรือไม่?

ฉันต้องการหลีกเลี่ยงปัญหาการรวบรวมแพลตฟอร์ม แต่ยังต้องการหลีกเลี่ยงการทำงานพิเศษของการ์ดสำรอง:

#pragma once
#ifndef HEADER_H
#define HEADER_H

...

#endif // HEADER_H

ฉันควรจะกังวลหรือไม่ ฉันควรจะใช้พลังงานทางจิตเพิ่มเติมในเรื่องนี้หรือไม่?

การใช้#pragma onceควรทำงานกับคอมไพเลอร์สมัยใหม่ แต่ฉันไม่เห็นเหตุผลที่จะไม่ใช้ตัว#ifndefป้องกันมาตรฐาน มันใช้งานได้ดี ข้อแม้หนึ่งคือ GCC ไม่สนับสนุน#pragma onceก่อนรุ่น 3.43.4

ฉันยังพบอีกว่าอย่างน้อยใน GCC จะจดจำมาตรฐาน#ifndefรวมถึงการ์ดป้องกันและปรับให้เหมาะสมดังนั้นจึงไม่ควรช้ากว่า#pragma onceนี้มากนัก

#pragma once มีหนึ่งข้อเสียเปรียบ (นอกเหนือจากที่ไม่ได้มาตรฐาน) และนั่นคือถ้าคุณมีไฟล์เดียวกันในสถานที่ที่แตกต่างกัน (เรามีสิ่งนี้เพราะระบบสร้างของเราคัดลอกไฟล์ไปรอบ ๆ ) จากนั้นคอมไพเลอร์จะคิดว่าเป็นไฟล์ที่แตกต่างกัน

ฉันหวังว่า#pragma once(หรืออะไรทำนองนั้น) จะอยู่ในมาตรฐาน การรวมเจ้าหน้าที่รักษาความปลอดภัยไม่ใช่เรื่องใหญ่จริง (แต่ดูเหมือนว่าเป็นการยากที่จะอธิบายให้ผู้คนเรียนรู้ภาษา) แต่ดูเหมือนจะเป็นเรื่องน่ารำคาญเล็กน้อยที่สามารถหลีกเลี่ยงได้

ในความเป็นจริงตั้งแต่ 99.98% ของเวลา#pragma onceพฤติกรรมเป็นพฤติกรรมที่ต้องการมันจะดีถ้าป้องกันหลายรวมของส่วนหัวได้รับการจัดการโดยอัตโนมัติโดยคอมไพเลอร์ด้วย#pragmaหรือสิ่งที่จะช่วยให้คู่รวม

แต่เรามีสิ่งที่เรามี (ยกเว้นว่าคุณอาจไม่มี#pragma once)

ฉันไม่รู้เกี่ยวกับประโยชน์ด้านประสิทธิภาพใด ๆ แต่มันก็ใช้งานได้ดี ฉันใช้มันในทุกโครงการ C ++ ของฉัน (อนุญาตให้ฉันใช้คอมไพเลอร์ MS) ฉันคิดว่ามันมีประสิทธิภาพมากกว่าการใช้

#ifndef HEADERNAME_H
#define HEADERNAME_H
...
#endif

มันทำงานเดียวกันและไม่ได้เติมพรีโพรเซสเซอร์ด้วยมาโครเพิ่มเติม

GCC สนับสนุน#pragma onceอย่างเป็นทางการในฐานะของรุ่น 3.4

GCC รองรับ#pragma onceตั้งแต่ 3.4 ดูhttp://en.wikipedia.org/wiki/Pragma_onceสำหรับการสนับสนุนคอมไพเลอร์เพิ่มเติม

ข้อเสียใหญ่ที่ฉันเห็นในการใช้#pragma onceเมื่อเทียบกับยามรวมคือการหลีกเลี่ยงข้อผิดพลาดการคัดลอก / วาง

ลองดูสิ: พวกเราส่วนใหญ่แทบจะไม่เริ่มต้นไฟล์ส่วนหัวใหม่ตั้งแต่ต้น แต่เพียงแค่คัดลอกไฟล์ที่มีอยู่แล้วแก้ไขตามความต้องการของเรา มันง่ายกว่ามากในการสร้างเทมเพลตที่ใช้งานได้โดยใช้#pragma onceแทนที่จะรวมการ์ด ยิ่งฉันต้องแก้ไขเทมเพลตน้อยฉันก็มีแนวโน้มที่จะพบข้อผิดพลาดน้อยลง การมีตัวป้องกันรวมอยู่ในไฟล์ที่แตกต่างกันนำไปสู่ข้อผิดพลาดของคอมไพเลอร์ที่แปลกและใช้เวลาพอสมควรในการพิจารณาว่าเกิดข้อผิดพลาดอะไร

TL; DR: #pragma onceใช้งานง่ายกว่า

ฉันใช้มันและฉันมีความสุขกับมันเพราะฉันต้องพิมพ์ให้น้อยลงเพื่อสร้างส่วนหัวใหม่ มันทำงานได้ดีสำหรับฉันในสามแพลตฟอร์ม: Windows, Mac และ Linux

ฉันไม่มีข้อมูลประสิทธิภาพใด ๆ แต่ฉันเชื่อว่าความแตกต่างระหว่าง #pragma และการป้องกันรวมจะไม่มีอะไรเทียบกับความช้าของการแยกวิเคราะห์ไวยากรณ์ C ++ นั่นคือปัญหาที่แท้จริง ลองคอมไพล์ไฟล์และบรรทัดจำนวนเดียวกันด้วยคอมไพเลอร์ C # เพื่อดูความแตกต่าง

ในท้ายที่สุดการใช้ยามหรือ pragma ไม่สำคัญเลย

การใช้ ' #pragma once' อาจไม่มีผลใด ๆ (ไม่รองรับทุกที่ - แม้ว่าจะได้รับการสนับสนุนอย่างกว้างขวางมากขึ้น) ดังนั้นคุณต้องใช้รหัสการรวบรวมแบบมีเงื่อนไขอย่างไรก็ตามในกรณีใดทำไมต้องกังวลกับ ' #pragma once' คอมไพเลอร์อาจปรับมันให้เหมาะสมอยู่ดี แต่ขึ้นอยู่กับแพลตฟอร์มเป้าหมายของคุณ หากเป้าหมายทั้งหมดของคุณรองรับคุณควรใช้มันต่อไป แต่มันควรเป็นการตัดสินใจที่มีสติเพราะนรกทั้งหมดจะพังถ้าคุณใช้ pragma และพอร์ตไปยังคอมไพเลอร์ที่ไม่สนับสนุน

ประโยชน์ด้านประสิทธิภาพมาจากการไม่ต้องเปิดไฟล์อีกครั้งเมื่อ #pragma เคยอ่านแล้ว คอมไพเลอร์จะต้องเปิดไฟล์ (ซึ่งอาจเสียเวลา) เพื่อรับข้อมูลที่ไม่ควรรวมเนื้อหานั้นอีก

นั่นเป็นเพียงทฤษฎีเท่านั้นเพราะคอมไพเลอร์บางตัวจะไม่เปิดไฟล์ที่ไม่มีโค้ดอ่านใด ๆ โดยอัตโนมัติสำหรับชุดรวบรวมแต่ละชุด

อย่างไรก็ตามมันไม่ใช่กรณีของคอมไพเลอร์ทั้งหมดดังนั้น #pragma ที่ควรหลีกเลี่ยงสำหรับโค้ดข้ามแพลตฟอร์มเพราะมันไม่ได้เป็นมาตรฐานเลย / ไม่มีคำจำกัดความและเอฟเฟกต์มาตรฐาน อย่างไรก็ตามในทางปฏิบัติมันดีกว่าการ์ดจริงๆ

ในที่สุดคำแนะนำที่ดีกว่าคุณจะต้องแน่ใจว่าได้ความเร็วสูงสุดจากคอมไพเลอร์ของคุณโดยไม่ต้องตรวจสอบพฤติกรรมของคอมไพเลอร์แต่ละตัวในกรณีนี้คือใช้ทั้ง pragma เพียงครั้งเดียวและการ์ด

#ifndef NR_TEST_H
#define NR_TEST_H
#pragma once

#include "Thing.h"

namespace MyApp
{
 // ...
}

#endif

ด้วยวิธีนี้คุณจะได้รับสิ่งที่ดีที่สุดทั้งสองอย่าง (ข้ามแพลตฟอร์มและช่วยรวบรวมความเร็ว)

เนื่องจากใช้เวลาพิมพ์นานกว่าฉันจึงใช้เครื่องมือเพื่อช่วยสร้างทุกอย่างด้วยวิธีที่รวดเร็ว (Visual Assist X)

ไม่เสมอ.

http://gcc.gnu.org/bugzilla/show_bug.cgi?id=52566มีตัวอย่างที่ดีของไฟล์สองไฟล์ที่มีความหมายทั้งสองอย่างรวมอยู่ แต่คิดว่าผิดพลาดเหมือนกันเพราะ timestamps และเนื้อหาที่เหมือนกัน (ไม่ใช่ชื่อไฟล์ที่เหมือนกัน) .

ใช้ gcc 3.4 และ 4.1 บนต้นไม้ขนาดใหญ่มาก (บางครั้งใช้distcc ) ฉันยังไม่เห็นความเร็วใด ๆ เมื่อใช้ #pragma เพียงครั้งเดียวแทนหรือใช้ร่วมกับการ์ดมาตรฐาน

ฉันไม่เห็นว่ามันมีความคุ้มค่าที่อาจทำให้สับสน gcc รุ่นเก่าหรือแม้แต่คอมไพเลอร์อื่น ๆ เนื่องจากไม่มีการประหยัดที่แท้จริง ฉันไม่ได้ลอง de-linters ที่หลากหลายทั้งหมด แต่ฉันยินดีที่จะเดิมพันมันจะทำให้พวกเขาสับสนมาก

ฉันก็หวังว่ามันจะถูกนำมาใช้ในช่วงต้น แต่ฉันสามารถเห็นการโต้แย้ง "ทำไมเราต้องใช้เมื่อ ifndef ทำงานได้อย่างสมบูรณ์แบบ?" เมื่อพิจารณามุมและความซับซ้อนที่มืดมิดของ C รวมถึงยามเป็นหนึ่งในสิ่งที่อธิบายตนเองได้ง่ายที่สุด หากคุณมีความรู้เพียงเล็กน้อยเกี่ยวกับวิธีการทำงานของโปรเซสเซอร์ล่วงหน้าพวกเขาควรอธิบายตนเอง

อย่างไรก็ตามหากคุณสังเกตเห็นความเร็วที่สำคัญโปรดอัปเดตคำถามของคุณ

วันนี้โรงเรียนเก่ามีเจ้าหน้าที่รักษาความปลอดภัยเร็วเท่ากับ # pragma หนึ่งครั้ง แม้ว่าคอมไพเลอร์จะไม่จัดการกับมันเป็นพิเศษ แต่ก็ยังคงหยุดทำงานเมื่อเห็น #ifndef WHATEVER และ WHATEVER ถูกกำหนดไว้ วันนี้การเปิดไฟล์สกปรกราคาถูก แม้ว่าจะต้องมีการปรับปรุงมันก็จะอยู่ในลำดับของการ miliseconds

ฉันเพียงแค่ไม่ใช้ #pragma เพียงครั้งเดียวเนื่องจากไม่มีประโยชน์ เพื่อหลีกเลี่ยงการปะทะกันกับยามรวมอื่น ๆ ฉันใช้สิ่งที่ชอบ: CI_APP_MODULE_FILE_H -> CI = ชื่อย่อ บริษัท APP = ชื่อแอปพลิเคชัน; ส่วนที่เหลืออธิบายด้วยตนเอง

ข้อแตกต่างที่สำคัญคือคอมไพเลอร์ต้องเปิดไฟล์ส่วนหัวเพื่ออ่านการ์ดป้องกัน ในการเปรียบเทียบ pragma ทำให้คอมไพเลอร์ติดตามไฟล์และไม่ทำไฟล์ใด ๆ ของ IO เมื่อเจอไฟล์อื่นรวมถึงไฟล์เดียวกัน แม้ว่ามันอาจฟังดูไม่สำคัญ แต่ก็สามารถขยายโครงการขนาดใหญ่ได้อย่างง่ายดายโดยเฉพาะโครงการที่ไม่มีส่วนหัวที่ดีรวมถึงสาขาวิชา

ที่กล่าวว่าคอมไพเลอร์ในสมัยนี้ (รวมถึง GCC) นั้นฉลาดพอที่จะรักษารวมถึงยามเช่น pragma เพียงครั้งเดียว เช่นพวกเขาไม่เปิดไฟล์และหลีกเลี่ยงโทษ IO ไฟล์

ในคอมไพเลอร์ที่ไม่รองรับ pragma ฉันเห็นการใช้งานด้วยตนเองที่ยุ่งยากเล็กน้อย ..

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

ฉันชอบ #pragma เมื่อเข้าใกล้เพราะหลีกเลี่ยงความยุ่งยากในการตั้งชื่อการชนและข้อผิดพลาดการพิมพ์ผิด มันเป็นโค้ดที่หรูหรากว่าเมื่อเปรียบเทียบ ที่กล่าวว่าสำหรับรหัสพกพามันไม่ควรเจ็บที่จะมีทั้งคู่เว้นแต่คอมไพเลอร์บ่นเกี่ยวกับมัน

ถ้าเราใช้ msvc หรือ Qt (ถึง Qt 4.5) เนื่องจาก GCC (ไม่เกิน 3.4) MSVC สนับสนุนทั้งฉันสามารถดูเหตุผลที่ไม่ได้ใช้ไม่มี#pragma once#pragma once

ชื่อไฟล์ต้นฉบับมักจะเป็นชื่อคลาสที่เท่ากันและเรารู้ว่าบางครั้งเราต้องการrefactorเพื่อเปลี่ยนชื่อคลาสจากนั้นเราต้องเปลี่ยนมัน#include XXXXด้วยดังนั้นฉันคิดว่าการดูแลรักษาด้วยตนเอง#include xxxxxไม่ใช่งานที่ฉลาด แม้ว่าจะมีส่วนขยาย Visual Assist X แต่การบำรุงรักษา "xxxx" ไม่ใช่งานที่จำเป็น

หมายเหตุเพิ่มเติมสำหรับผู้ที่คิดว่าต้องการรวมไฟล์ส่วนหัวอัตโนมัติเพียงครั้งเดียวเท่านั้น: ฉันสร้างตัวสร้างโค้ดโดยใช้ไฟล์ส่วนหัวสองหรือหลายไฟล์รวมกันนับทศวรรษ โดยเฉพาะอย่างยิ่งสำหรับการสร้างโครงร่างห้องสมุดโปรโตคอลฉันพบว่ามันสะดวกสบายมากที่จะมีตัวสร้างโค้ดแบบพกพาที่ทรงพลังและไม่มีเครื่องมือและภาษาเพิ่มเติม ฉันไม่ใช่นักพัฒนาเพียงคนเดียวที่ใช้รูปแบบนี้เนื่องจากX-Macros บล็อกนี้แสดง สิ่งนี้จะเป็นไปไม่ได้หากไม่มีการป้องกันโดยอัตโนมัติ