# Pragma once and # ifdef

Resolution # pragma command

Among all the pre-processing commands, the # pragma command may be the most complex. It is used to set the compiler status or to instruct the compiler to complete some specific actions. # The Pragma command provides a method for each compiler to provide the unique features of the host or operating system while maintaining full compatibility with C and C ++ languages. According to the definition, the compilation instructions are proprietary to machines or operating systems and are different for each compiler.

The format is generally: # pragma para

Here, para is a parameter. Below are some common parameters.

(1) Message parameter. The message parameter is one of my favorite parameters. It can be used in the compilation information output window.

Output the corresponding information.Source codeInformation control is very important. The usage is as follows:

# Pragma message ("message text ")

When the compiler encounters this instruction, it prints the message text in the compilation output window.

When weProgramDefines many macros to control the sourceCodeIn versions, we may forget whether these macros are correctly set. In this case, we can use this command to check the macros during compilation. Suppose we want to determine whether we have defined the _ x86 macro in the source code. The following method can be used:

# Ifdef _ x86

# Pragma message ("_ x86 macro activated !")

# Endif

After we define the _ x86 macro, the application will display "_

X86 macro activated !". We won't be scratching our heads because we don't remember some specific macros we defined.

.

(2) The other Pragma parameter that is used more frequently is code_seg. Format:

# Pragma code_seg (["section-name" [, "section-class"])

It can set the code segment where function code is stored in the program. It is used when we develop the driver.

(3) # pragma once (commonly used)

You only need to add this command at the beginning of the header file to ensure that the header file is compiled once. This command is actually available in vc6, but it is not widely used in consideration of compatibility.

(4) # pragma hdrstop indicates that the pre-compiled header file ends here, and the subsequent header files are not pre-compiled. BCB can pre-compile the header file to speed up the link, but if all header files are pre-compiled, it may occupy too much disk space. Therefore, this option is used to exclude some header files.

Sometimes there is a dependency between units. For example, unit a depends on unit B. Therefore, Unit B must be compiled before unit. You can use # pragma startup to specify the compilation priority. If # pragma package (smart_init) is used, BCB will be compiled based on the priority.

(5) # pragma resource "*. DFM" indicates adding resources in the *. DFM file to the project. * DFM includes the form

The definition of the appearance.

(6) # pragma warning (Disable: 4507 34; once: 4385; error: 164)

It is equivalent:

# Pragma warning (Disable: 4507 34) // do not display the 4507 and 34 Warnings

# Pragma warning (once: 4385) // only one warning message is reported once

# Pragma warning (error: 164) // the error message 164 is used as an error.

This pragma warning also supports the following formats:

# Pragma warning (push [, N])

# Pragma warning (POP)

Here N represents a warning level (1---4 ).

# Pragma warning (push) saves the existing warning status of all warning information.

# Pragma warning (push, n) saves the existing warning status of all warning information, and sets global warning

The level is set to n.

# Pragma warning (POP) pops up the last warning message to the stack.

All changes are canceled. For example:

# Pragma warning (push)

# Pragma warning (Disable: 4705)

# Pragma warning (Disable: 4706)

# Pragma warning (Disable: 4707)

//.......

# Pragma warning (POP)

At the end of the Code, save all warning information (including 4707, and ).

(7) Pragma comment (...)

This command puts a comment record into an object file or executable file.

Common lib keywords can help us to connect to a library file.

(8) # pragma pack ()

We know that in VC, VC uses the 8-byte Alignment Method for the type like struct. If we don't want to use the 8-byte alignment (this is often required when the network is changed ), we can add

# Pragma pack (1)

Struct

{

......

}

# Pragma pack ()

The following is another reprint:

In the era of vc6, header files generally use ifndef define endif

In the era of vc7, header files are generally Pragma once

I wonder if anyone has gotten into it.

Why is there such code so that the header file is not repeatedly referenced and the compiler is wrong? Are there any differences between the two methods?

For example, there may be several libraries, and each library may have a file named public. h.

Ifndef public_h

Define public_h

...

Endif

When a file references two such libraries at the same time, the files in the Latter Library will not be compiled, and Pragma once can ensure that the file is compiled only once.

It seems that Pragma once is better than ifndef define endif, so ifndef define endif

Pragma once. I met another example today. For example, you have a zlib. H is used in several databases. For convenience, zlib is copied to every directory, because this file is not modified and is complete. If Pragma once is used, the definition will be repeated. It seems that ifndef define endif is useful again.

Therefore, for public or interface files, use ifndef define endif and Pragma once for internal files.

# Difference between Pragma once and # ifndef # define # endif

For # pragma once, according to The msdn explanation, it can prevent a file from being contained multiple times. Compared with file protection in the form of # ifndef # define # endif, the former is platform-related and has poor portability, but is more efficient because it does not need to open the contained files, you can determine whether the file is contained. Of course, this work is done by the system for us.

The latter has the advantage that it is a language-related feature, so it has good portability. However, when a file is contained, you only need to open the file and determine whether the file has been included based on whether the file's protection macro has been defined. Relatively low efficiency. Of course, when # I nclude is used, the programmer can determine whether the protection macro of the file to be included has been defined to determine whether to include the file. Similar to the following code:

# Ifndef file_h _

# I nclude "file. H"

# Endif

In this way, high efficiency can be achieved and portability can be ensured. However, the dependency between files is high. If a file's Macro Protection changes, all files that use the above form to include this file must be modified. It is against the idea of modularization.

This article from the csdn blog, reproduced please indicate the source: http://blog.csdn.net/roger_it/archive/2007/02/09/1506249.aspx