What code have you written with #pragma you found useful? [closed]

Answer 1

Every pragma has its uses, or they wouldn't be there in the first place.

pragma "once" is simply less typing and tidier, if you know you won't be porting the code to a different compiler. It should be more efficient as well, as the compiler will not need to parse the header at all to determine whether or not to include its contents.

edit: To answer the comments: imagine you have a 200kB header file. With "once", the compiler loads this once and then knows that it does not need to include the header at all the next time it sees it referenced. With #if it has to load and parse the entire file every time to determine that all of the code is disabled by the if, because the if must be evaluated each time. On a large codebase this could make a significant difference, although in practical terms (especially with precompiled headers) it may not.

pragma "pack" is invaluable when you need binary compatibility for structs.

Edit: For binary formats, the bytes you supply must exactly match the required format - if your compiler adds some padding, it will screw up the data alignment and corrupt the data. So for serialisation to a binary file format or an in-memory structure that you wish to pass to/from an OS call or a TCP packet, using a struct that maps directly to the binary format is much more efficient than 'memberwise serialisation' (writing the fields one by one) - it uses less code and runs much faster (essential in embedded applications, even today).

pragma "error" and "message" are very handy, especially inside conditional compliation blocks (e.g. "error: The 'Release for ePhone' build is unimplemented", message: "extra debugging and profiling code is enabled in this build")

pragma "warning" (especially with push & pop) is very useful for temporarily disabling annoying warnings, especially when including poorly written third-party headers (that are full of warnings) - especially if you build with warning level 4.

edit: Good practice is to achieve zero warnings in the build so that when a warning occurs you notice it and fix it immediately. You should of course fix all warnings in your own code. However, some warnings simply cannot be fixed, and do not tell you anything important. Additionally, when using third party libraries, where you cannot change their code to fix the warnings, you can remove the 'spam' from your builds by disabling the library's warnings. Using push/pop allows you to selectively disable the warnings only during the library includes, so that your own code is still checked by the compiler.

Answer 2

In Visual Studio, C++ preprocessor also supports

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

Then you can collapse this region in the code editor so that it only shows the above message. This is analogous to the C# region syntax.

Answer 3

This is very similar to sbi's answer but has some additional features.

I've used the following set of macros with #pragma message on Microsoft Visual C++ for some time:

#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")

Used as:

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

which results in the following text in the build output:

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

The output matches the Visual C++ error message format, so errors, warnings, and messages show up in the Error List along with all the other compiler warnings and errors.

The "warning" macro is far more obnoxious than a simple // todo fix this in the code, and helps me to remember to come back and fix something.

The "error" macro is useful because it causes compilation to fail but does not immediately stop the compilation process like the #error directive does.

Answer 4

With VC, I have used this in the past:

#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" )

Output:

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

You can double-click on it in the output pane and the IDE takes you to the right file and line.

Answer 5

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

for projects using winsock library

Answer 6

#pragma by definition is for compiler/pre-processor directives that may be platform specific. It looks like you're talking about MSVC++ #pragmas here. You can find their full list, or the full list for gcc.

Other compilers will have completely different lists.

Back on MSVC++, though, one of my favorite pragmas is #pragma warning. I usually build code with "treat warnings as errors" enabled, and then surgically disable certain warnings that I've reviewed to make sure aren't causing problems. This allows the compiler to help me detect more problems during build.