Какой код Вы написали с #pragma, который Вы нашли полезным? [закрытый]

В VC я использовал это в прошлом:

#define STRINGIFY( L )       #L
#define MAKESTRING( M, L )   M(L)
#define SHOWORIGIN           __FILE__ "("MAKESTRING( STRINGIFY, __LINE__) "): "

// then, later...

#pragma message( SHOWORIGIN "we need to look at this code" )
// ...
#pragma message( SHOWORIGIN "and at this, too" )

Вывод:

c:\...\test.cpp(8): we need to look at this code
c:\...\test.cpp(10): and at this, too

Вы можете дважды щелкнуть по нему в панели вывода, и IDE перейдет к нужному файлу и строке.

#pragma по определению предназначен для директив компилятора / препроцессора, которые могут зависеть от платформы. Похоже, вы здесь говорите о MSVC ++ #pragmas. Вы можете найти их полный список или полный список для gcc .

У других компиляторов будут совершенно другие списки.

Вернемся к MSVC ++, но одна из моих любимых прагм - #pragma warning . Обычно я создаю код с включенной функцией «рассматривать предупреждения как ошибки», а затем хирургическим путем отключаю определенные предупреждения, которые я просмотрел, чтобы убедиться, что они не вызывают проблем. Это позволяет компилятору помочь мне обнаружить больше проблем во время сборки.

В Visual Studio препроцессор C ++ также поддерживает

#pragma region Some Message Goes Here
...
#pragma endregion

Затем вы можете свернуть эту область в редакторе кода, чтобы отображалось только указанное выше сообщение. Это аналогично синтаксису региона C #.

#pragma comment(lib, "WS2_32.lib")

для проектов, использующих библиотеку winsock

Это очень похоже на ответ sbi , но имеет некоторые дополнительные функции.

Я использовал следующий набор макросов с #pragma message в Microsoft Visual C ++ в течение некоторого времени:

#define EMIT_COMPILER_WARNING_STRINGIFY0(x) #x
#define EMIT_COMPILER_WARNING_STRINGIFY1(x) EMIT_COMPILER_WARNING_STRINGIFY0(x)
#define EMIT_COMPILER_MESSAGE_PREFACE(type) \
    __FILE__ "(" EMIT_COMPILER_WARNING_STRINGIFY1(__LINE__) "): " type ": "

#define EMIT_COMPILER_MESSAGE EMIT_COMPILER_MESSAGE_PREFACE("message")
#define EMIT_COMPILER_WARNING EMIT_COMPILER_MESSAGE_PREFACE("warning")
#define EMIT_COMPILER_ERROR   EMIT_COMPILER_MESSAGE_PREFACE("error")

Используется как:

#pragma message(EMIT_COMPILER_WARNING "This code sucks; come back and fix it")

, что приводит к следующему тексту в выходных данных сборки:

1>z:\sandbox\test.cpp(163): warning : This code sucks; come back and fix it

Вывод соответствует формату сообщения об ошибке Visual C ++, поэтому ошибки, предупреждения и сообщения отображаются в списке ошибок вместе со всеми другими предупреждениями и ошибками компилятора.

Макрос «предупреждение» гораздо более неприятен, чем простой // задача исправить это в коде, и помогает мне не забыть вернуться и что-то исправить.

Макрос «error» полезен, потому что он вызывает сбой компиляции, но не останавливает процесс компиляции немедленно, как это делает директива #error .

По возможности избегайте #pragma. Директивы компилятора #pragma всегда специфичны для компилятора и поэтому не переносимы. Их следует рассматривать как последнее средство.

Более того, ISO требует поведения для компилятора, который встречает нераспознанную прагму, - просто игнорировать ее. Это может происходить незаметно, без предупреждения, поэтому, если директива необходима для правильной работы вашего кода, она может скомпилироваться, но не сможет работать должным образом при компиляции с другим компилятором. GCC для примеров использует очень мало прагм, и в основном только для целевого поведения конкретного компилятора или совместимости с некоторыми другими компиляторами. Следовательно, если вы хотите обеспечить переносимость, вы получите такие конструкции, как:

#if _MSC_VER
  #pragma PACK(push,1)
#elif   __GNUC__
  // nothing to do here
#else
  #error "Unsupported compiler"
#endif
  struct sPackedExample
  {
      // Packed structure members
#if _MSC_VER
  } ;                              // End of MSVC++ pragma packed structure
  #pragma pack (pop)
#elif   __GNUC__
  }__attribute__((__packed__)) ;   // End of GNU attribute packed structure
#endif

Это беспорядок, вы быстро не видите леса за деревьями, и проблема усугубляется, когда вы добавляете поддержку большего количества компиляторов (что, в свою очередь, требует знания предопределенные макросы , идентифицирующие компилятор.

[примечание:] GCC 4.x на самом деле поддерживает пакет #pragma для совместимости с MS, поэтому приведенный выше пример несколько надуманный, но это не относится к более ранним версиям GCC, которые все еще могут использоваться, или к другим компиляторам.

'# pragma once' особенно проблематичен, поскольку для компилятора, который его не поддерживает , код во всех случаях, кроме самых тривиальных, ломается при предварительной обработке. Следует отдавать предпочтение более подробному, но переносимому решению. Приложение Visual C ++ и «мастера» генерации кода могут его использовать, но часто такой код в любом случае непереносим.При использовании такого кода вы должны знать, что вы по сути блокируете свой проект в инструментах Microsoft. Возможно, это не проблема, но я бы не рекомендовал использовать директиву в вашем собственном коде.

Чтобы ответить на ваш исходный вопрос: « Какой код вы написали с помощью #pragma, который вы сочли полезным? »; Возможно, вам лучше рассмотреть полезные способы избежания прагм?

Возможно, это не должно быть вопросом « полезности », а скорее « необходимости ». Например, ряд компиляторов встроенных систем, которые я использовал, используют директивы #pragma, чтобы указать, что функция является подпрограммой обслуживания прерывания и, следовательно, имеет другой код входа / выхода и во многих случаях работает с другим стеком. Избежание такой прагмы потребует знания целевого языка ассемблера и будет менее эффективным, когда код C вызывается для обработки прерывания.

Как вы упомянули, я встречал прагмы в Visual C ++, которые говорят ему связываться с определенной библиотекой во время компоновки. Удобно для библиотеки, которой нужны библиотеки winsock. Таким образом, вам не нужно изменять настройки проекта, чтобы связать его. пример: #pragma comment (lib, "wsock32.lib") . Мне это нравится, потому что он связывает с ним код, которому нужен .lib, плюс, как только вы поместите его в файл, вы не сможете его забыть, если повторно используете этот код в другом проекте.

Кроме того, прагмы для упаковки структур данных часто полезны, в частности, с системным и сетевым программированием, где имеют значение смещения элементов данных. пример:

#pragma pack(push, 1) // packing is now 1
struct T {
char a;
int b;
};
#pragma pack(pop) // packing is back to what it was

// sizeof(T) == sizeof(char) + sizeof(int), normally there would be padding between a and b