Чи є #pragma один раз безпечним включенням охоронця?

Я читав, що існує деяка оптимізація компілятора при використанні, #pragma onceщо може призвести до більш швидкої компіляції. Я усвідомлюю, що це нестандартно, і, таким чином, може виникнути проблема сумісності між платформами.

Це щось, що підтримується більшістю сучасних компіляторів на не-windows платформах (gcc)?

Я хочу уникати проблем зі збиранням платформи, але також хочу уникати зайвої роботи резервних охоронців:

#pragma once
#ifndef HEADER_H
#define HEADER_H

...

#endif // HEADER_H

Чи варто мене турбувати? Чи варто витрачати на це подальшу розумову енергію?

Використання #pragma onceповинно працювати на будь-якому сучасному компіляторі, але я не бачу причин, щоб не використовувати стандартний #ifndefвключати вартості. Це працює просто чудово. Один нюанс в тому , що GCC не підтримує , #pragma onceперш ніж версія 3.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 та include Guard не буде нічого порівняно з повільністю розбору граматики C ++. У цьому справжня проблема. Спробуйте скласти однакову кількість файлів і рядків, наприклад, компілятором C #, щоб побачити різницю.

Зрештою, використання охоронця чи прагми не матиме значення взагалі.

Використання ' #pragma once' може не мати ніякого ефекту (воно не підтримується скрізь - хоча воно все більше підтримується), тому вам все одно потрібно використовувати умовний код компіляції, і в такому випадку, навіщо турбуватися з ' #pragma once'? Компілятор, ймовірно, оптимізує його у будь-якому випадку. Однак це залежить від вашої цільової платформи. Якщо всі ваші цілі підтримують його, то йдіть вперед і використовуйте його - але це повинно бути свідомим рішенням, тому що все пекло вийде з ладу, якщо ви лише використовуєте прагму, а потім перенесите на компілятор, який не підтримує її.

Перевага від продуктивності полягає в тому, що не потрібно знову відкривати файл після того, як #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 є прекрасним прикладом двох файлів, які повинні бути включені, але помилково вважається ідентичними через однакові часові позначки та вміст (не однакове ім'я файлу) .

Використовуючи gcc 3.4 та 4.1 на дуже великих деревах (іноді використовуючи distcc ), я ще не бачу швидкості при використанні #pragma один раз, або в поєднанні зі стандартними включенням охоронців.

Я дійсно не бачу, як варто потенційно плутати старіші версії gcc або навіть інших компіляторів, оскільки реальних заощаджень немає. Я не пробував усіх різних лінерів, але я готовий зробити ставку, що це переплутає багатьох з них.

Я теж бажаю, щоб він був прийнятий на початку, але я можу побачити аргумент "Навіщо нам це потрібно, якщо ifndef працює прекрасно?". Враховуючи безліч темних куточків С та складності, включити охоронців є однією з найпростіших речей, що пояснюються самостійно. Якщо у вас є навіть невеликі знання про те, як працює препроцесор, вони повинні бути самостійними.

Якщо ви помітили значну швидкість прискорення, будь ласка, оновіть своє запитання.

Сьогодні охоронець старої школи такий же швидкий, як колись #прагма. Навіть якщо компілятор не звертається до них спеціально, він все одно зупиниться, коли він побачить #ifndef ЩО БЕЗКОШТОВНО і ЩО БЕЗ визначено. Відкриття файлу сьогодні є дешевим брудом. Навіть якби було покращення, це було б у порядку мілісекунд.

Я просто не використовую #pragma один раз, оскільки це не має ніякої користі. Щоб уникнути зіткнення з іншими включеннями охоронців, я використовую щось на зразок: CI_APP_MODULE_FILE_H -> CI = Початкові дані компанії; APP = назва програми; решта - сама роз'яснення.

Основна відмінність полягає в тому, що компілятору довелося відкрити файл заголовка, щоб прочитати захист включення. Для порівняння, прагма один раз змушує компілятор відслідковувати файл і не робити жодного файлу вводу-виводу, коли він стикається з іншим включенням для цього ж файлу. Незважаючи на те, що це може здаватися незначним, він може легко розширювати масштабні проекти, особливо такі, що не мають гарного заголовка.

Однак, компілятори (включаючи GCC) в наші дні досить розумні, щоб з ними можна було ставитись до охоронців, як колись прагма. тобто вони не відкривають файл і уникають штрафу за IO файлу.

У компіляторах, які не підтримують прагму, я бачив ручні реалізації, які трохи громіздкі ..

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

Мені особисто подобається #pragma один раз підходити, оскільки це дозволяє уникнути клопоту іменувати зіткнення та потенційні помилки друку. Це також більш елегантний код у порівнянні. Однак, для портативного коду не повинно зашкодити мати обоє, якщо компілятор не скаржиться на це.

Якщо ми використовуємо msvc або Qt (до Qt 4.5), оскільки GCC (до 3.4), msvc обидві підтримують #pragma once, я не бачу причин не використовувати #pragma once.

Ім'я вихідного файлу, як правило, однакове ім’я класу, і ми знаємо, що колись нам потрібен рефактор , щоб перейменувати ім’я класу, тоді нам довелося також змінити #include XXXX, тому я думаю, що керівництво підтримувати #include xxxxxце не розумна робота. навіть із розширенням Visual Assist X, підтримка "xxxx" не є необхідною роботою.

Додаткова примітка людям, які думають, що завжди бажано автоматичне включення одноразових файлів заголовків: я створюю генератори коду, використовуючи подвійне або багаторазове включення файлів заголовків з десятиліть. Спеціально для генерації заглушок бібліотеки протоколів мені дуже зручно мати надзвичайно портативний та потужний генератор коду без додаткових інструментів та мов. Я не єдиний розробник, що використовує цю схему, як показують ці блоги X-Macros . Це неможливо зробити без відсутньої автоматичної охорони.