HP aC++/HP C A.06.
© Copyright 2011 Hewlett-Packard Development Company, L.P. Confidential computer software. Valid license from HP required for possession, use or copying. Consistent with FAR 12.211 and 12.212, Commercial Computer Software, Computer Software Documentation, and Technical Data for Commercial Items are licensed to the U.S. Government under vendor's standard commercial license. The information contained herein is subject to change without notice.
Contents About This Document ...............................................................................................................20 Intended Audience.................................................................................................20 What’s in This Document.........................................................................................20 Typographical Conventions.................................................................................
HP aC++..........................................................................................................32 HP C................................................................................................................32 Setting up Floating Installation.............................................................................33 2 Command-Line Options..........................................................................................................
Extensions to the Language......................................................................................47 -ext..................................................................................................................47 +e...................................................................................................................48 Floating-Point Processing Options..............................................................................48 +O[no]cxlimitedrange......................
-s.....................................................................................................................61 -usymbol...........................................................................................................61 +ild.................................................................................................................61 +ildrelink..........................................................................................................
+opts..........................................................................................................74 +O[no]parminit............................................................................................74 +O[no]parmsoverlap.....................................................................................75 +O[no]procelim............................................................................................75 +O[no]promote_indirect_calls..............................................
-P.....................................................................................................................89 -Uname............................................................................................................90 Profiling Code Options............................................................................................90 -G....................................................................................................................90 -p.................................
-Bhidden.........................................................................................................108 -Bhidden_def...................................................................................................109 -Bprotected.....................................................................................................109 -Bprotected_data.............................................................................................109 -Bprotected_def....................................
FLOAT_TRAPS_ON Pragma...............................................................................126 [NO]INLINE Pragma........................................................................................126 NO_INLINE Pragma........................................................................................127 IVDEP Pragma.................................................................................................127 NODEPCHK Pragma...............................................................
OMP TASK Pragma..........................................................................................139 OMP TASKWAIT Pragma..................................................................................139 OMP THREADPRIVATE Pragma..........................................................................139 OpenMP Clauses.................................................................................................139 private..........................................................................
Example 2.............................................................................................153 Using Constants and Inline Functions Instead of Macros...................................153 Example................................................................................................153 Predefined Macros......................................................................................154 Assertions (#assert, #unassert)....................................................................
Function Template...................................................................................165 Command-Line Option Instantiation....................................................................166 Compile-Time Instantiation................................................................................166 Why Use Compile-Time Instantiation..............................................................166 Scope........................................................................................
Usage.......................................................................................................185 Example....................................................................................................185 typename Keyword..........................................................................................185 Usage.......................................................................................................186 Example............................................................
Rogue Wave Standard C++ Library 1.2.1 and Tools.h++ 7.0.6..............................203 Using Locks.....................................................................................................203 Required Command-line Options.......................................................................204 Rogue Wave Standard C++ Library 2.2.1.......................................................204 Rogue Wave Standard C++ Library 1.2.1 and Tools.h++ 7.0.6.........................204 Limitations........
omp_get_wtime..........................................................................................217 omp_get_wtick...........................................................................................217 9 Tools and Libraries...............................................................................................................218 HP Specific Features of lex and yacc.......................................................................218 Creating and Using Libraries.....................
Linker Options to Manage Shared Libraries....................................................229 Version Control for Shared Libraries...............................................................229 Adding New Versions to a Shared Library......................................................229 Standard HP-UX Libraries and Header Files.........................................................230 Location of Standard HP-UX Header Files.......................................................
Getting Started with Migration..........................................................................247 Writing Code for both Compilers.......................................................................248 Explicit Loading and Unloading of Shared Libraries .............................................248 Memory Allocation..........................................................................................248 Command-Line Differences...............................................................
Dangling Comma in enum...........................................................................267 Static Member Definition Required................................................................267 Declaring friend Classes..............................................................................268 Incorrect Syntax for Calls to operator new......................................................268 Using :: in Class Definitions..........................................................................
About This Document This manual presents programming information on the C++ programming language, as implemented on Itanium®- based systems. The document printing date and part number indicate the document’s current edition. The printing date will change when a new edition is printed. Minor changes may be made at reprint without changing the printing date. The document part number will change when extensive changes are made.
Chapter 5 Using HP aC++ Templates Gives you an overview of template processing and describes the instantiation coding methods available in HP aC++. Chapter 6 Standardizing Your Code Discusses HP aC++ keywords, Standard Exception Classes, and exceptions thrown by the Standard C++ library, and lists unsupported functionality. Chapter 7 Optimizing HP aC++ Programs Gives you information about optimizing your programs.
From the HP-UX command line, you can enter “man audit” or “man 5 audit” to view the manpage. See man(1). Book Title The title of a book. On the Web and on the Instant Information CD, it may be a hot link to the book itself. KeyCap The name of a keyboard key. Emphasis Emphasized text. Bold Strongly emphasized text. Bold The defined use of an important word or phrase. ComputerOut Text displayed by the computer. UserInput Commands and other text that you type.
Publishing History Edition Release Date Product Version 11 September 2011 HP aC++ v A.06.26 10 March 2010 HP aC++ v A.06.25 9 September 2009 HP aC++ v A.06.20 8 September 2007 HP aC++ v A.06.15 7 November 2006 HP aC++ v A.06.12 6 May 2006 HP aC++ v A.06.10 5 September 2005 HP aC++ v A.06.05 4 December 2004 HP aC++ v A.06.00/A.05.60 3 September 2004 HP aC++ v A.05.55.02 2 March 2004 HP aC++ v A.05.55 1 August 2003 HP aC++ v A.05.
1 Getting Started with HP aC++ The information in this document applies to the release of HP aC++ and HP ANSI C compilers version A.06.26 for the HP-UX 11i v3 operating system. The HP ANSI C compiler supports ANSI programming language C standard ISO 9899:1999. HP aC++ compiler supports the ISO/IEC 14882 Standard for the C++ Programming Language (the international standard for C++). Version A.06.
/usr/lib/hpux64/libstd.so (64-bit shared version) /usr/lib/hpux64/libstd.a (64-bit archive version) HP aC++ Runtime Support Library /usr/lib/hpux##/libCsup.so /usr/lib/hpux##/libstd.so and libstd_v2.so /usr/lib/hpux##/libstd_v2.so and librwtool_v2.so /usr/lib/hpux##/libstream.so Libraries in /usr/include/hpux## (where ## is 32 or 64 provided as part of the HP-UX core system) Standard C++ Library /usr/lib/hpux32/libstream.so /usr/lib/hpux32/libstream.a /usr/lib/hpux64/libstream.so /usr/lib/hpux64/libstream.
Debugging Programs You can use programming and debugging aides. HP Code Advisor HP Code Advisor is a code checking tool that can be used to detect programming errors in C/C++ source code. Use "/opt/cadvise/bin/cadvise" to invoke the tool. A brief description is available with the -help option. $ /opt/cadvise/bin/cadvise -help Additional information is available at: http://www.hp.com/go/cadvise/.
Examples of the aCC Command Following are some examples of the aCC command: Compiling and Renaming an Output File aCC -o prog prog.C This command compiles prog.C and puts the executable code in the file prog, rather than in the default file a.out. Compiling and Debugging aCC -g prog.C This command compiles prog.C and includes information that allows you to debug the program with the HP WDB debugger, wdb. Compiling Without Linking aCC -c prog.C This command compiles prog.
Files on the aCC Command Line Files containing source or object code to be compiled or linked by HP aC++ can be any of these files: • A C++ Source File (.C file) • Preprocessed Source Files (.i Files) • Assembly Language Source Files (.s Files) • Object Files (.o Files) • Library Files (.a and .so Files) • Configuration Files (.
Object Files (.o Files) Files with .o extensions are assumed to be relocatable object files that have to be included in the linking. The compiler invokes the linker to link the object files and create an executable file. Use the -c option to compile a C++ source file into a .o file. Library Files (.a and .so Files) Files ending with .a are assumed to be archive libraries. Files ending with .so are assumed to be shared libraries.
Environment Variables This section describes the following environment variables that you can use to control the HP aC++ or HP C compiler: • “aCC_FULL_PATHNAMES Environment Variable” (page 30) • “aCC_MAXERR Environment Variable” (page 30) • “CXXOPTS Environment Variable” (page 30) • “CCLIBDIR Environment Variable” (page 31) • “CCROOTDIR Environment Variable” (page 31) • “TMPDIR Environment Variable” (page 32) aCC_FULL_PATHNAMES Environment Variable Exporting the aCC_FULL_PATHNAMES variable cause
The above command causes the -v and -l options to be passed to the aCC command each time you execute it. When CXXOPTS is set as above, the following two commands are equivalent: aCC -g prog.C aCC -v -g prog.C -lm CCLIBDIR Environment Variable The CCLIBDIR environment variable causes the aCC command to search for libraries in an alternate directory before searching in the default directories.
In this example, HP aC++ searches the directories under /mnt/CXX2.1 (/mnt/CXX2.1/ bin and /mnt/CXX2.1/lbin) for subprocesses rather than their respective default directories. TMPDIR Environment Variable The TMPDIR environment variable allows you to change the location of temporary files created by the compiler. The default directory is /var/tmp.
NOTE: Do not use floating installation with the following: • CCROOTDIR environment variable • -tc,name command line option Setting up Floating Installation You may want to install the most recent compiler version and keep the prior version on one system. If there are problems with the most recent version, you can easily switch to the prior one. Following is an example of how to set up the floating installation feature for this purpose.
2 Command-Line Options You can specify command-line options to the aCC command. They allow you to override the default actions of the compiler. Each option begins with either a - or a + sign. Any number of options can be interspersed anywhere in the aCC command and they are typically separated by blanks. Unless specified otherwise, all options are supported by C and C++ compilers. Default options can be set using option configuration files. See “Configuration Files (.conf Files)” (page 29).
• “Standards Related Options” (page 100) • “Subprocesses of the Compiler” (page 105) • “Symbol Binding Options” (page 107) • “Template Options” (page 110) • “Trigraph Processing Suppression Option” (page 112) • “Verbose Compile and Link Information” (page 113) • “Concatenating Options” (page 115) Options to Control Code Generation The following options allow you to control the kind of code that the compiler generates: • -c • +DOosname • +DDdata_model • +DSmodel • -S -c You can use th
Example: The following example generates code for the HP-UX 11.22 (or later) operating system. Binary incompatible features introduced in later OS versions are inhibited. aCC +DO11.22 +O3 app.C +DDdata_model The +DDdata_model option specifies the data model for the compiler. data_model can be one of the following: • 32 (This value generates ILP32 code and is the default.) • 64 (This value generates LP64 code.) This option specifies the data model for the compiler.
montecito Tune for the Montecito® processor. native Tune for the processor on which the compiler is running. The default is blended. Object code with scheduling tuned for a particular model will execute on other HP-UX systems, although possibly less efficiently. Using +DS to Specify Instruction Scheduling Instruction scheduling is different on different implementations of Itanium®-based architectures.
inter-process communication. In addition, misaligned data addresses can cause bus errors when an attempt is made to dereference the address. For information on unaligned data access, See “Handling Unaligned Data” (page 122).
Table 3 Size and Alignment of HP Compiler Data Types (continued) Data Type Size (in bytes) Alignment *** struct and union alignment are same and follow strict alignment of any member. Padding is done to a multiple of the alignment size. -fshort-enums cc -Agcc -Wc,--fshort-enums foo.c aCC -Ag++ -Wc,--fshort-enums foo.
+expand_types_in_diag The +expand_types_in_diag option expands typedefs in diagnostics so that both the original and final types are present. -g The -g option causes the compiler to generate minimal information for the debugger. It uses an algorithm that attempts to reduce duplication of debug information. To suppress expansion of inline functions, use the +d option. -g0 The -g0 option causes the compiler to generate full debug information for the debugger.
-g, -g1 Algorithm In general, the compiler looks for the first non-inline, non-pure (non-zero) virtual function in order to emit debug information for a class.If there are no virtual member functions, the compiler looks for the first non-inline member function. If there are no non-inline member functions, debug information is always generated. A problem occurs if all functions are inline; in this case, no debug information is generated.
+pathtrace +pathtrace[=kind] The +pathtrace option provides a mechanism to record program execution control flow into global and/or local path tables. The saved information can be used by the HP WDB debugger to assist with crash path recovery from the core file, or to assist when debugging the program by showing the executed branches. Currently only if, else, switch-case-default, and try-catch execution paths are recorded in the path table.
global_fixed_size Generates a fixed-size (65536 items) global path table and records basic block-execution information in it at runtime. This form differs from+pathtrace=global because the size of the table cannot be configured at runtime, and the contents cannot be dumped to a file. The fixed-size global path table has better runtime performance than the configurable global path table. The performance difference varies depending on the optimization level and how the program is written.
-w The -w option disables all warnings except those that are explicitly enabled with a +Wwargs option or a subsequent +w-prefix option. By default, the compiler reports all errors and warnings. HP recommends against using the -w option. In addition to disabling messages currently output by the compiler, it will also disable any new messages added to the compiler in the future that could identify problem areas in user code. HP recommends using the +Wargs option to disable a message.
+Wargs +Warg1[,arg2,..argn] The +Wargs option selectively suppresses any specified warning messages. Arguments arg1 through argn are valid compiler warning message numbers. Example: aCC +W600 app.C +Wcontext_limit +Wcontext_limit=num The +Wcontext_limi option limits the number of instantiation contexts output by the compiler for diagnostics involving template instantiations. At most num outermost contexts and num innermost contexts are shown.
+Wwargs +Wwarg1[,arg2,..,argn] The +Wwargs option selectively treats compiler remarks or discretionary errors as warnings. arg1 through argn are valid compiler message numbers. Conflicts between +W, +Ww, and +We are resolved based on their severity. +We is the highest and +W is the lowest. +wlint This option enables several warnings in the compiler that provide lint like functionality. Checks are made for memory leaks, out-of-scope memory access, null pointer dereference, and out-of-bounds access.
part of the user-specified optimization level. If +wsecurity is used in addition to -ipo or +O4, the generated code is not affected and the compile time does not significantly increase. This option can optionally take an argument to control how verbosely the security messages are emitted: +wsecurity[={1|2|3|4}] The higher the check level, the more warnings can be generated. Note that this may also generate more false positives. The default level is 2.
When this option is used with -AC89 or -AC99, it defines the following macros: • -D__STDC_EXT__ • -D_HPUX_SOURCE (unless -Aa is used) NOTE: When using -ext, specify it at both compile and link time. For example: aCC -ext foo.C compiles foo.C which contains a long long declaration. #include int main(){ long long ll = 1; cout << ll << endl; } +e The +e option is equivalent to the -ext option.
-fpeval -fpeval=precision The -fpeval option specifies the minimum precision to use for floating-point expression evaluation. This option does not affect the precision of parameters, return types, or assignments. The defined values for precision are: float Evaluates floating-point expressions and constants in their semantic type. double Evaluates float operations and constants using the range and precision of double, and evaluates all other floating-point expressions and constants in their semantic type.
For more information on using Decimal FP, see the HP aC++/HP ANSI C Release Notes section "Decimal floating-point arithmetic supported" under "New Features in the A.06.20 Release." +FP +FP[flags] The +FP option specifies how the runtime environment for floating-point operations should be initialized at program startup and used at link time. The default is that all trapping behaviors are disabled. The following flags are supported. Uppercase enables the flag, lowercase disables the flag.
+Oprefetch_latency +Oprefetch_latency=cycles The +Oprefetch_latency option applies to loops for which the compiler generates data prefetch instructions. cycles represents the number of cycles for a data cache miss. For a given loop, the compiler divides cycles by the estimated loop length to arrive at the number of loop iterations for which to generate advanced prefetches. cycles must be in the range of 0 to 10000.
Header File Options Following are the command-line options you can use for header files: -H cc -H file The -H option causes HP aC++/HP C to print the order and hierarchy of included files. The -H option dumps the include heirarchy to stderr so that the preprocessed compiler output indicates the include file nesting. +hdr_create aCC progname -c +hdr_create headername This option extracts the header from a program file and saves it as a precompiled header file. Example: aCC ApplicTemplate.
NOTE: The current directory is not searched when angle brackets (< >) are used with #include. Example: The following example directs the compiler to search in the directory include for #include files. aCC -I include file.C -I[-Idirs] -I- [-Idirs] [-Idirs] indicates an optional list of -Idirectory specifications in which a directory name cannot begin with a hyphen (-) character. The -I- option allows you to override the default -Idirectory search-path. This feature is called view-pathing.
Examples: With view-pathing off, the following example obtains all the quoted include files from dir1 only if they are not found in the directory of a.C and from dir2 only if they are not found in dir1. Finally, if necessary, the standard include directories are searched. Angle-bracketed include files are searched for in dir1, then dir2, followed by the standard include directories. aCC -Idir1 -Idir2 -c a.
NOTE: Some of the compiler’s header files are included using double quotes. Since the -I- option redefines the search order of such includes, if any standard headers are used, it is your responsibility to supply the standard include directories (/opt/aCC/ include* and /usr/include) in the correct order in your -I- command line.
If $DISPLAY is set, the default web browser is used. If the display variable is not set, a message is displayed.
num Description 2.0 < num < 9.0 Increasing levels of inliner aggressiveness. 9 Attempts to inline all functions other than recursive functions or those with a variable number of arguments. The default level depends on +Olevel as shown in the following table: level num 0 1 1 1 2 2 3 2 4 2 The +O[no]inline option controls the high-level optimizer that recognizes other opportunities in the same source file (+O3) or amongst all source files (+O4). For example, aCC +inline_level 3 app.
-exec -exec The -exec option indicates that any object file created will be used to create an executable file. Constants with a protected or hidden export class are placed in the read-only data section. This option also implies -Bprotected_def. It makes all defined functions and data (even tentatively defined data) protected by default (unless otherwise specified by another binding option or pragma).
The -L option must precede any -lname option entry on the command line; otherwise -L is ignored. This option is passed directly to the linker. Example: The following example compiles and links prog.C and directs the linker to search the directories and /project/libs for any libraries that prog.C uses (in this case, mylib1 and mylib2). aCC -L/project/libs prog.
-n -n The -n option causes the program file produced by the linker to be marked as sharable. For details and system defaults, refer to the description of ld in the HP-UX Reference Manual or the ld(1) manpage for more information. -N -N The -N option causes the program file produced by the linker to be marked as unsharable. For details and system defaults, refer to the description of ld in the HP-UX Reference Manual or the ld(1) manpage for more information.
-s -s Using the -s option causes the executable program file created by the linker to be stripped of symbol table information. Specifying this option prevents using a symbolic debugger on the resulting program. For details and system defaults, refer to the description of ld in the HP-UX Reference Manual or the ld(1) manpage for more information. -usymbol -usymbol Enter symbol as an undefined symbol in ld’s symbol table.
-o -o outfile The outfile parameter is the name of the file containing the output of the compilation. This option causes the output of the compilation to be placed in outfile. Without this option the default name is a.out. When compiling a single source file with the -c option, you can use the -o option to specify the name and location of the object file. -.suffix -.suffix The suffix parameter represents the character or characters to be used as the output file name suffix.
The -z option disallows dereferencing of null pointers at run time. Fatal errors result if null pointers are dereferenced. If you attempt to dereference a null pointer, a SIGSEGV error occurs at run time. Example: aCC -z file.C The above command compiles file.C and generates code to disallow dereferencing of null pointers. For more information, see signal(2) and signal(5) manpages. -Z -Z The -Z option allows dereferencing of null pointers at run time. This is the default.
HP recommends a setting of 0x100000000, or 4 GB (the default for this parameter is 0x100000000, or 4 GB) for maxdsiz_64bit in such cases. Updating the maxdsiz_64bit tunable will ensure that the compiler does not run out of virtual memory when compiling large files or functions. In addition, maxssiz_64bit should be set to 128 MB for very large or complex input files. (Normally a maxssiz_64bit setting of 64 MB will be sufficient.
The +O2 option performs level 2 optimization. This includes level 1 optimizations plus optimizations performed over entire functions in a single file. NOTE: Compiling with this optimization setting may require additional memory resources. Refer to the memory resource discussion above. Example: This command compiles prog.C and optimizes at level 2: aCC +O2 prog.C +O3 +O3 The +O3 option performs level 3 optimization.
If you run out of memory when compiling at +O4 optimization, there are several things you can do: • Compile at +O4 only those modules that need to be compiled at optimization level 4, and compile the remaining modules at a lower level. • If you still run out of memory, increase the per-process data size limit. Run the System Administrator Manager (SAM) to increase the maxdsiz_64bit process parameter to more than 4GB. This procedure provides the process with additional data space.
Object Files Generated with -ipo Object files generated by the compiler with +O4 or -ipo, called intermediate object files, are intended to be temporary files. These object files contain an intermediate representation of the user code in a format that is designed for advanced optimizations. The size of these intermediate object files can typically be 3 to 10 times as large as normal object files. Hewlett-Packard reserves the right to change the format of these files without prior notice.
+O[no]aggressive +O[no]aggressive The +Oaggressive option enables aggressive optimizations. The +Onoaggressive option disables aggressive optimizations. By default, aggressive optimizations are turned off. The +Oaggressive option is approximately equivalent to +Osignedpointers +Onoinitcheck +Ofltacc=relaxed. NOTE: This option is deprecated and may not be supported in future releases. Instead you can use +Ofastoption.
and function-scoped statics) will not be read or written through pointers. The default is +Onoptrs_to_globals. +O[no]size +O[no]size While most optimizations reduce code size, the +Osize option suppresses those few optimizations that significantly increase code size. The +Onosize option enables code-expanding optimizations. Use +Osize at all optimization levels. The default is +Onosize. Advanced +Ooptimization Options Advanced optimization options provide additional control for special situations.
Usage: +Odataprefetch=kind The defined values for kind are: direct Enable generation of data prefetch instructions for the benefit of direct memory accesses, but not indirect memory accesses. This is the default at optimization level +O1. indirect Enables the generation of data prefetch instructions for the benefit of both direct and indirect memory accesses. This is the default at optimization levels +O2 and above. It is treated the same as direct at optimization level +O1.
the results obtained with these options are adequately similar to those obtained without the optimization. For applications in which round-off error has been carefully studied, and the order of computation carefully crafted to control error, these options may be unsatisfactory. To insure the same result as in unoptimized code, use +Ofltacc. Example: All the options, except +Ofltacc=strict, allow the compiler to replace a division by a multiplication using the reciprocal.
The +Oinline option indicates that any function can be inlined by the optimizer. +Onoinline disables inlining of functions by the optimizer. This option does not affect functions inlined at the source code level. Use +O[no]inline at optimization levels 2, 3 and 4. The default is +Oinline at optimization levels 3 and 4. Usage: +O[no]inline=function1{,function2...] Enables [disables] optimizer inlining for the named functions.
+Ointeger_overflow=moderate is the default for all optimization levels. This was changed to enable a wider class of applications to be compiled with optimization and run correctly. The defined values of kind are: conservative Directs the compiler to make fewer assumptions that integer arithmetic expressions do not overflow.
+O[no]loop_unroll +O[no]loop_unroll [=unroll_factor] The +O[no]loop_unroll option enables [disables] loop unrolling. This optimization can occur at optimization levels 2, 3, and 4. The default is +Oloop_unroll. The default is 4, that is, four copies of the loop body. The unroll_factor controls code expansion. Note that +Onoloop_unroll has no effect on loop unroll-and-jam. +O[no]openmp +O[no]openmp The +Oopenmp option causes the OpenMP directives to be honored.
The +O[no]parminit option enables [disables] automatic initialization to non-NaT of unspecified function parameters at call sites. This is useful in preventing NaT values in parameter registers. The default is +Onoparminit. +O[no]parmsoverlap +O[no]parmsoverlap The +Onoparmsoverlap option optimizes with the assumption that on entry to a function each of that function’s pointer-typed formals points to memory that is accessed only through that formal or through copies of that formal made within the function.
NOTE: The optimizer tries to determine the most likely target of indirect calls. If the profile data is incomplete or ambiguous, the optimizer may not select the best target. If this happens, your code’s performance may decrease. This option can be used at optimization levels 3 and 4. At +O3, it is only effective if indirect calls from functions within a file are mostly to target functions within the same file. This is because +O3 optimizes only within a file, whereas +O4 optimizes across files.
NOTE: Using a value that is too big or without the optional size, possibly through +Ofast, may give various linker fix up errors, if there is more than 4Mb of short data. +O[no]store_ordering +O[no]store_ordering The +O[no]store_ordering option preserves [does not preserve] the original program order for stores to memory that is visible to multiple threads. This does not imply strong ordering. The default is +Onostore_ordering.
NOTE: loop. This option will be ignored if it is placed in a loop other than the innermost Profile-Based Optimization Options Profile-based optimization is a set of performance-improving code transformations based on the runtime characteristics of your application. +Oprofile +Oprofile=[use|collect] The +Oprofile option instructs the compiler to instrument the object code for collecting runtime profile data. The profiling information can then be used by the linker to perform profile-based optimization.
all Enables collection of all types of profile data. This is equivalent to +Oprofile=collect:arc,dcache,stride,loopiter. This is the default. This option merely enables the application for collection of the various forms of profiling data. The environment variable PBO_DATA_TYPE controls the type of data collected at runtime.
There are three possible sets of flags depending on your operating system and the libstd you use. Table 5 lists the option matrix for -mt. Table 5 Option Matrix for -mt Libraries Flags old-lib -D_REENTRANT libstd 1.2.1 -DRW_MULTI_THREAD (-AP)& -DRWSTD_MULTI_THREAD librwtool 7.0.x -D_THREAD_SAFE -D_POSIX_C_SOURCE=199506L -D_HPUX_SOURCE * -lpthread new-lib -D_REENTRANT (-AA) -D_RW_MULTI_THREAD libstd 2.2.
• RWSTD_MULTI_THREAD / _RWSTD_MULTI_THREAD Required by Rogue Wave standard library header files and libraries. RWSTD_MULTI_THREAD is used by libstd 1.2.1. _RWSTD_MULTI_THREAD is used by libstd 2.2.1 when compiling with -AA. • _POSIX_C_SOURCE=199506L Required by pthread. • libpthread.* Kernel thread library used on 11.x systems See “Using Threads” (page 202) for more information. NOTE: Make sure that -mt is used consistently at compile and link times.
Programs compiled with the +Oautopar option require the libcps, libomp, and libpthreads runtime support libraries to be present at both compilation and runtime. When linking with the HP-UX B.11.61 linker, compiling with the +Oautoparoption causes them to be automatically included. Older linkers require those libraries to be specified explicitly or by compiling with +Oopenmp. The +Oautopar option is supported when compiling C, C++, or Fortran files. Specifying +Oautopar implies the -mt option.
Performance Options The HP compiler provides a variety of options to help improve build and runtime performance. These options are: -fast -fast The -fast option selects a combination of optimization options for optimum execution speed and reasonable build times. This option is equivalent to +Ofast. Currently chosen options are: • +O2 • +Ofltacc=relaxed • +Onolimit • +DSnative • +FPD You can override any of the options in -fast by specifying a subsequent option after it.
NOTE: Do not use this option for programs that depend on IEEE standard floating point denormalized numbers. Otherwise, different numerical results may occur. See +Ofltacc=relaxed. +Ofaster +Ofaster The +Ofaster option is equivalent to +Ofast with an increased optimization level. The definition of +Ofaster may change, or the option may be deprecated in future releases. +[no]srcpos +[no]srcpos The +[no]srcpos option controls the generation of source position information for HP Caliper.
The -fast option selects a combination of optimization options for optimum execution speed and reasonable build times. Currently chosen options are: • +O2 • +Ofltacc=relaxed • +Onolimit • +DSnative • +FPD You can override any of the options in -fast by specifying a subsequent option after it. This option is equivalent to +Ofast. Use this option when porting C++ and C applications compiled on other UNIX operating systems to HP-UX.
NOTE: Since all unqualified char types in the compilation unit will be affected by this option (including those headers that define external and system interfaces), it is necessary to compile the interfaces used in a single program uniformly. +w64bit The +w64bit option enables warnings that help detection of potential problems in converting 32-bit applications to 64-bit. The option is equivalent to the +M2 option.
union u1 { // OK char c[4]; int v; char dummy; }; Another type of warning is on the use of IO functions that read/write persistent data from files that may be endian-dependent: read(0, &i, sizeof(i)); fread(&ai[0], sizeof(int), elems_of(ai, int), stdin); write(1, &i, sizeof(i)); fwrite(&ai[0], sizeof(int), elems_of(ai, int), stdout); This warning can be suppressed by adding an extra cast: fread((char*)(void*)ai, sizeof(char), 1, stdin); // OK Another +wendian warning captures cases where a cast when late
If no definition (def) is given, the name is defined as 1. NOTE: __ia64 and __HP_aCC are defined automatically. Example: The following example defines the preprocessor symbol DEBUGFLAG and gives it the value 1. aCC -DDEBUGFLAG file.C The following program uses this symbol: #include int main(){ int i, j; #ifdef DEBUGFLAG int call_count=0; #endif /* ... */ } -E -E Using the -E option runs only the preprocessor on the named C++ files and sends the result to standard output (stdout).
Table 6 Examples Command Line Specified .d file name .d file location Preprocessing Output aCC -c +make a.C none stdout none aCC -c -E -.i +maked a.C a.d current directory none aCC -c -P +maked a.C -o b.o b.d current directory a.i aCC -c -P +maked a.C -o /tmp/c c.d /tmp directory a.i +Make[d] +Make[d] The +Make[d] option directs a list of both the quote enclosed (" ") and angle bracket enclosed (< >) header files upon which your source code depends to stdout.
-Uname -Uname name is the symbol name whose definition is removed from the preprocessor. This option undefines any name that has initially been defined by the preprocessing stage of compilation. A name can be a definition set by the compiler. This is displayed when you specify the -v option. A name can also be a definition that you have specified with the -D option on the command line. The -D option has lower precedence than the -U option.
+profilebucketsize +profilebucketsize=[16|32] This is a link-time option to support prof and gprof when building an executable, but not a shared library. When prof or gprof startup code invokes sprofil, this option specifies the size in bits of the counters used to record sampled values of the program counter. The effect of this option can be overridden by setting the environment variable LD_PROFILEBUCKET_SIZE when running the instrumented program.
NOTE: The +check option is only supported on Integrity servers. +check=all The +check=all option enables all runtime checks provided by the compiler, except for +check=truncate, +check=lock, and +check=thread, which must be explicitly specified to enable them. It overrides any +check=xxx options that appear earlier on the command line.
When +check=all is specified, it enables +check=bounds:array only. To enable the pointer out-of-bounds check, you must explicitly specify +check=bounds:pointer. You can combine +check=bounds:[pointer | all] with all other +check options, except for +check=globals (which would be ignored in this case). Also see the +check=malloc and the +check=stack options for related runtime checks for heap and stack objects. Example: This example uses +check=bounds:pointer to find a program bug: $ cat rttest3.
value is set i, lp[i], i+1, ip[i+1], j, ip[j]); ^ Catch out-of-bounds pointer access through an uninitialized variable (the uninitialized variable can be checked by +check=uninit): $ RTC_NO_ABORT=1 a.out 2 Runtime Error: out of bounds buffer pointed by 0x40010320 has 40 bytes (variable "a"), reading at 0x40010320-19824, 4 bytes ("rttest3.c", line 33) (0) 0x0000000004004770 _rtc_raise_fault + 0x560 at rtc_utils.c:164 [./a.out](1) 0x0000000004008790 _rtc_oob_check_unknown_bounds + 0x1f0 at rtc_bounds.
(variable "a"), reading at 0x40010320-19824, 4 bytes ("rttest3.c", line 33) (0) 0x0000000004004770 _rtc_raise_fault + 0x560 at rtc_utils.c:164 [./a.out] (1) 0x0000000004008790 _rtc_oob_check_unknown_bounds + 0x1f0 at rtc_bounds.c:465 [./a.out] (2) 0x0000000004003920 main + 0x330 at rttest3.c:33 [./a.out] (3) 0x60000000c0049c50 main_opd_entry + 0x50 [/usr/lib/hpux32/dld.so] Memory fault(coredump) Check off by any number out-of-bounds access: RTC_NO_ABORT=1 a.
Note that +check=all does not enable +check=lock. Also note that since +check=lock requires instrumenting each memory access, it can result in a considerable slowdown of the application at runtime. +check=lock also increases the memory consumption of the instrumented application. The check is performed on each memory access. It detects violations in locking discipline for mutual exclusion locks (mutexes) for applications using posix threads.
intersection between the candidate lockset and incoming lockset is empty, the checker reports the locking discipline violation. The candidate lockset and incoming lockset members are specified in terms of the source file and line number pointing to the pthread_mutex_lock call associated with that lock. For further details on detecting lock discipline violations, refer to the above-referenced Eraser article. False positives are possible in certain cases, as mentioned in the Eraser article.
For a description for the above configuration parameters and the full list of other parameters, please refer to the HP WDB debugger documentation. +check=stack[:frame|:variables|:none] The +check=stack[:frame|:variables|:none] option enables runtime checks to detect writes outside stack boundaries. Markers are placed before and after the whole stack frame and around some stack variables. On procedure exit, a check is done to see if any marker has been overwritten.
• The thread waits on a condition variable for which the associated mutex is not locked. • The thread terminates execution, and the resources associated with the terminated thread continue to exist in the application because the thread has not been joined or detached. • The thread uses more than the specified percentage of the stack allocated to the thread. The +check=thread option should only be used with multithreaded programs. It is not enabled by +check=all.
This option turns on runtime checks for truncation on compiler-generated implicit type conversions, such as ch = int_val;. +check=truncate This option turns on runtime checks for both explicit cast and implicit conversion truncation. +check=uninit The +check=uninit option checks for a use of a stack variable before it is defined. If such a use is detected, an error message is emitted and the program is aborted.
-AA -AA The -AA option enables the use of the new 2.0 Standard C++ Library, which includes the new standard conforming (templatized) iostream library. It conforms to the ISO C++ standard. The –AA option sets -Wc,-koenig_lookup,on and -Wc,-ansi_for_scope,on, and is the default C++ compilation mode. Usage: The standard features enabled by -AA are incompatible with the older Rogue Wave Standard C++ Library 1.2.1 and Tools.h++ 7.0.6. All modules must be consistent in using -AA.
aCC -Ae aCC -AC99 -Ae -Ae Setting the -Ae option invokes aC++ as an ANSI C compiler, with additional support for HP C language extensions. This option is a synonym for the -AC99 option. For C++, if -Ae is anywhere on the command line, C-mode will be in effect. The options, -AA and -AP, are ignored with warnings. If both -Ae and -Aa are present, C-mode will be in effect and the right most option determines whether extended ANSI (-Ae) or strict ANSI (-Aa) is in effect.
-AP -AP NOTE: This option is deprecated and may not be supported in future releases. The -AP option turns off -AA mode and uses the older C++ runtime libraries. NOTE: This option is not supported in legacy HP C. This option is ignored with warnings in C-mode. -Ax The -Ax option turns on support for several extensions introduced by the working paper for the next C++ standard (called C++0x). The -Ax option is available only in C++ compilation mode and is binary compatible with the -AA compilation mode.
NOTE: This option is applicable to C language only. -Wc,-ansi_for_scope,[on|off] -Wc,-ansi_for_scope,[on|off] The -Wc,-ansi_for_scope is option enables or disables the standard scoping rules for init declarations in for statements; the scope of the declaration then ends with the scope of the loop body. By default, the option is disabled.
namespace N { struct S {}; void f(S const&, int); } // (1) void f(N::S const&, long); // (2) int main() { N::S x; f(x, 1); } Subprocesses of the Compiler These options allow you to substitute your own processes in place of the default HP aC++ subprocesses, or pass options to HP aC++ subprocesses. -tx,name -tx,name The -tx,name option substitutes or inserts subprocess x, using name. The parameter, x, is one or more identifiers indicating the subprocess or subprocesses.
For example, the following command invokes the assembler /users/sjs/myasmb instead of the default assembler /usr/ccs/bin/as to assemble and link file.s. aCC -ta,/users/sjs/myasmb file.s More Examples of -t Following are some examples of -t option: • Substituting for C++ file: The following example compiles file.C and specifies that /new/bin/c++filt should be used instead of the default /opt/aCC/bin/c++filt. aCC -tf,/new/bin/c++filt file.C • Substituting for ecom: The following example compiles file.
Table 9 Identifiers x Description a Assembler (standard suffix is as) c Compiler (standard suffix is ecom) C Same as c f Filter tool (standard suffix is c++filt) l Linker (standard suffix is ld) p Preprocessor (standard suffix is cpp.ansi). -tp must be used before any -Wp options can be passed to cpp.ansi. To enable the external preprocessor, use: -tp,/opt/langtools/lbin/cpp.ansi.
A global symbol is one that is visible by name across translation unit boundaries. A static symbol is one that is visible by name only within a single translation unit but is not associated with a particular procedure activation. A locally defined symbol is a global or static symbol with a definition in the translation unit from which it is being referenced. -Bdefault -Bdefault Global symbols are assigned the default export class.
hidden symbols will not be exported outside the current load module. The linker may eliminate them from a shared library, but in an executable, they remain accessible to the debugger unless +Oprocelim is also specified. When used with no symbol list, -Bhidden implies -Wl,-aarchive_shared, causing the linker to prefer an archive library over a shared library if one is available. This can be overridden by following the -Bhidden option with a subsequent -Wl,-a option. Usage: -Bhidden=symbol[,symbol...
-Bprotected_def -Bprotected_def The -Bprotected_def option is the same as -Bprotected but only locally defined (non-tentative) symbols are assigned the protected export class. -Bsymbolic -Bsymbolic The -Bsymbolic option assigns protected export class to all symbols. This is equivalent to -Bprotected with no symbol list. NOTE: This option is deprecated as of version A.06.05 and if used, it issues a warning that -Bprotected_defis almost always what should be used in its place.
NOTE: This option is supported in C++ only and ignored in C-mode. +inst_directed +inst_directed The +inst_directed option indicates to the compiler that no templates are to be instantiated (except explicit instantiations). If you are using only explicit instantiation, specify +inst_directed. The following example compiles file.C with the resulting object file containing no template instantiations, except for any explicit instantiations coded in your source file. aCC +inst_directed prog.
list is a set of space separated file extensions or suffixes, enclosed in quotes, that template definition files can have. The default extensions in order of precedence are: • .c • .C • .cxx • .CXX • .cc • .CC • .cpp User-specified extensions must begin with a dot and must not exceed four characters in total. Any extension that does not follow these rules causes a warning and is ignored. These restrictions do not apply in HP aC++.
Verbose Compile and Link Information Use the following options to obtain additional information about: • The HP compiler actions while compiling or linking your program. • The subprocesses executed for a given command line, without running the compiler. • The current compiler and linker version numbers. • The Execution time. -dumpversion -dumpversion The +dumpversion option displays the simple version number of the compiler, such as A.06.25.
The +time option generates timing information for compiler subprocesses. For each subprocess, estimated time is generated in seconds for user processes, system calls, and total processing time. This option is useful in the development process, for example, when tuning an application’s compile-time performance. Examples: • The aCC +time app.C command generates the following information: process: compiler process: ld • 0.94/u 0.37/u 0.65/s 0.76/s 4.35/r 3.02/r The aCC -v +time app.
:/usr/lib:/opt/langtools/lib:/usr/lib /opt/aCC/lbin/ld -o a.out /opt/aCC/lib/crt0.o -u ___exit -u main -L /opt/aCC/lib /opt/aCC/lib/cpprt0.o app.o -lstd -lstream -lCsup -lm /usr/lib/hpux32/libcl.a -lc /usr/lib/hpux32/libdld.so >/usr/tmp/AAAa28149 2>&1 removing /usr/tmp/AAAa28149 -V -V The -V option displays the version numbers of the current compiler and linker (if the linker is executed). Use this option whenever you need to know the current compiler and linker version numbers. Example: aCC -V app.
3 Pragma Directives and Attributes A pragma directive is an instruction to the compiler. You use a #pragma directive to control the actions of the compiler in a particular portion of a translation unit without affecting the translation unit as a whole. Put pragmas in your C++ source code where you want them to take effect. Unless otherwise specified, a pragma is in effect from the point where it is included until the end of the translation unit or until another pragma changes its status.
3 Pragma Directives and Attributes A pragma directive is an instruction to the compiler. You use a #pragma directive to control the actions of the compiler in a particular portion of a translation unit without affecting the translation unit as a whole. Put pragmas in your C++ source code where you want them to take effect. Unless otherwise specified, a pragma is in effect from the point where it is included until the end of the translation unit or until another pragma changes its status.
3 Pragma Directives and Attributes A pragma directive is an instruction to the compiler. You use a #pragma directive to control the actions of the compiler in a particular portion of a translation unit without affecting the translation unit as a whole. Put pragmas in your C++ source code where you want them to take effect. Unless otherwise specified, a pragma is in effect from the point where it is included until the end of the translation unit or until another pragma changes its status.
3 Pragma Directives and Attributes A pragma directive is an instruction to the compiler. You use a #pragma directive to control the actions of the compiler in a particular portion of a translation unit without affecting the translation unit as a whole. Put pragmas in your C++ source code where you want them to take effect. Unless otherwise specified, a pragma is in effect from the point where it is included until the end of the translation unit or until another pragma changes its status.
3 Pragma Directives and Attributes A pragma directive is an instruction to the compiler. You use a #pragma directive to control the actions of the compiler in a particular portion of a translation unit without affecting the translation unit as a whole. Put pragmas in your C++ source code where you want them to take effect. Unless otherwise specified, a pragma is in effect from the point where it is included until the end of the translation unit or until another pragma changes its status.
3 Pragma Directives and Attributes A pragma directive is an instruction to the compiler. You use a #pragma directive to control the actions of the compiler in a particular portion of a translation unit without affecting the translation unit as a whole. Put pragmas in your C++ source code where you want them to take effect. Unless otherwise specified, a pragma is in effect from the point where it is included until the end of the translation unit or until another pragma changes its status.
3 Pragma Directives and Attributes A pragma directive is an instruction to the compiler. You use a #pragma directive to control the actions of the compiler in a particular portion of a translation unit without affecting the translation unit as a whole. Put pragmas in your C++ source code where you want them to take effect. Unless otherwise specified, a pragma is in effect from the point where it is included until the end of the translation unit or until another pragma changes its status.
3 Pragma Directives and Attributes A pragma directive is an instruction to the compiler. You use a #pragma directive to control the actions of the compiler in a particular portion of a translation unit without affecting the translation unit as a whole. Put pragmas in your C++ source code where you want them to take effect. Unless otherwise specified, a pragma is in effect from the point where it is included until the end of the translation unit or until another pragma changes its status.
3 Pragma Directives and Attributes A pragma directive is an instruction to the compiler. You use a #pragma directive to control the actions of the compiler in a particular portion of a translation unit without affecting the translation unit as a whole. Put pragmas in your C++ source code where you want them to take effect. Unless otherwise specified, a pragma is in effect from the point where it is included until the end of the translation unit or until another pragma changes its status.
3 Pragma Directives and Attributes A pragma directive is an instruction to the compiler. You use a #pragma directive to control the actions of the compiler in a particular portion of a translation unit without affecting the translation unit as a whole. Put pragmas in your C++ source code where you want them to take effect. Unless otherwise specified, a pragma is in effect from the point where it is included until the end of the translation unit or until another pragma changes its status.
3 Pragma Directives and Attributes A pragma directive is an instruction to the compiler. You use a #pragma directive to control the actions of the compiler in a particular portion of a translation unit without affecting the translation unit as a whole. Put pragmas in your C++ source code where you want them to take effect. Unless otherwise specified, a pragma is in effect from the point where it is included until the end of the translation unit or until another pragma changes its status.
3 Pragma Directives and Attributes A pragma directive is an instruction to the compiler. You use a #pragma directive to control the actions of the compiler in a particular portion of a translation unit without affecting the translation unit as a whole. Put pragmas in your C++ source code where you want them to take effect. Unless otherwise specified, a pragma is in effect from the point where it is included until the end of the translation unit or until another pragma changes its status.
3 Pragma Directives and Attributes A pragma directive is an instruction to the compiler. You use a #pragma directive to control the actions of the compiler in a particular portion of a translation unit without affecting the translation unit as a whole. Put pragmas in your C++ source code where you want them to take effect. Unless otherwise specified, a pragma is in effect from the point where it is included until the end of the translation unit or until another pragma changes its status.
3 Pragma Directives and Attributes A pragma directive is an instruction to the compiler. You use a #pragma directive to control the actions of the compiler in a particular portion of a translation unit without affecting the translation unit as a whole. Put pragmas in your C++ source code where you want them to take effect. Unless otherwise specified, a pragma is in effect from the point where it is included until the end of the translation unit or until another pragma changes its status.
3 Pragma Directives and Attributes A pragma directive is an instruction to the compiler. You use a #pragma directive to control the actions of the compiler in a particular portion of a translation unit without affecting the translation unit as a whole. Put pragmas in your C++ source code where you want them to take effect. Unless otherwise specified, a pragma is in effect from the point where it is included until the end of the translation unit or until another pragma changes its status.
3 Pragma Directives and Attributes A pragma directive is an instruction to the compiler. You use a #pragma directive to control the actions of the compiler in a particular portion of a translation unit without affecting the translation unit as a whole. Put pragmas in your C++ source code where you want them to take effect. Unless otherwise specified, a pragma is in effect from the point where it is included until the end of the translation unit or until another pragma changes its status.
3 Pragma Directives and Attributes A pragma directive is an instruction to the compiler. You use a #pragma directive to control the actions of the compiler in a particular portion of a translation unit without affecting the translation unit as a whole. Put pragmas in your C++ source code where you want them to take effect. Unless otherwise specified, a pragma is in effect from the point where it is included until the end of the translation unit or until another pragma changes its status.
3 Pragma Directives and Attributes A pragma directive is an instruction to the compiler. You use a #pragma directive to control the actions of the compiler in a particular portion of a translation unit without affecting the translation unit as a whole. Put pragmas in your C++ source code where you want them to take effect. Unless otherwise specified, a pragma is in effect from the point where it is included until the end of the translation unit or until another pragma changes its status.
3 Pragma Directives and Attributes A pragma directive is an instruction to the compiler. You use a #pragma directive to control the actions of the compiler in a particular portion of a translation unit without affecting the translation unit as a whole. Put pragmas in your C++ source code where you want them to take effect. Unless otherwise specified, a pragma is in effect from the point where it is included until the end of the translation unit or until another pragma changes its status.
3 Pragma Directives and Attributes A pragma directive is an instruction to the compiler. You use a #pragma directive to control the actions of the compiler in a particular portion of a translation unit without affecting the translation unit as a whole. Put pragmas in your C++ source code where you want them to take effect. Unless otherwise specified, a pragma is in effect from the point where it is included until the end of the translation unit or until another pragma changes its status.
3 Pragma Directives and Attributes A pragma directive is an instruction to the compiler. You use a #pragma directive to control the actions of the compiler in a particular portion of a translation unit without affecting the translation unit as a whole. Put pragmas in your C++ source code where you want them to take effect. Unless otherwise specified, a pragma is in effect from the point where it is included until the end of the translation unit or until another pragma changes its status.
3 Pragma Directives and Attributes A pragma directive is an instruction to the compiler. You use a #pragma directive to control the actions of the compiler in a particular portion of a translation unit without affecting the translation unit as a whole. Put pragmas in your C++ source code where you want them to take effect. Unless otherwise specified, a pragma is in effect from the point where it is included until the end of the translation unit or until another pragma changes its status.
3 Pragma Directives and Attributes A pragma directive is an instruction to the compiler. You use a #pragma directive to control the actions of the compiler in a particular portion of a translation unit without affecting the translation unit as a whole. Put pragmas in your C++ source code where you want them to take effect. Unless otherwise specified, a pragma is in effect from the point where it is included until the end of the translation unit or until another pragma changes its status.
3 Pragma Directives and Attributes A pragma directive is an instruction to the compiler. You use a #pragma directive to control the actions of the compiler in a particular portion of a translation unit without affecting the translation unit as a whole. Put pragmas in your C++ source code where you want them to take effect. Unless otherwise specified, a pragma is in effect from the point where it is included until the end of the translation unit or until another pragma changes its status.
3 Pragma Directives and Attributes A pragma directive is an instruction to the compiler. You use a #pragma directive to control the actions of the compiler in a particular portion of a translation unit without affecting the translation unit as a whole. Put pragmas in your C++ source code where you want them to take effect. Unless otherwise specified, a pragma is in effect from the point where it is included until the end of the translation unit or until another pragma changes its status.
3 Pragma Directives and Attributes A pragma directive is an instruction to the compiler. You use a #pragma directive to control the actions of the compiler in a particular portion of a translation unit without affecting the translation unit as a whole. Put pragmas in your C++ source code where you want them to take effect. Unless otherwise specified, a pragma is in effect from the point where it is included until the end of the translation unit or until another pragma changes its status.
3 Pragma Directives and Attributes A pragma directive is an instruction to the compiler. You use a #pragma directive to control the actions of the compiler in a particular portion of a translation unit without affecting the translation unit as a whole. Put pragmas in your C++ source code where you want them to take effect. Unless otherwise specified, a pragma is in effect from the point where it is included until the end of the translation unit or until another pragma changes its status.
3 Pragma Directives and Attributes A pragma directive is an instruction to the compiler. You use a #pragma directive to control the actions of the compiler in a particular portion of a translation unit without affecting the translation unit as a whole. Put pragmas in your C++ source code where you want them to take effect. Unless otherwise specified, a pragma is in effect from the point where it is included until the end of the translation unit or until another pragma changes its status.
3 Pragma Directives and Attributes A pragma directive is an instruction to the compiler. You use a #pragma directive to control the actions of the compiler in a particular portion of a translation unit without affecting the translation unit as a whole. Put pragmas in your C++ source code where you want them to take effect. Unless otherwise specified, a pragma is in effect from the point where it is included until the end of the translation unit or until another pragma changes its status.
3 Pragma Directives and Attributes A pragma directive is an instruction to the compiler. You use a #pragma directive to control the actions of the compiler in a particular portion of a translation unit without affecting the translation unit as a whole. Put pragmas in your C++ source code where you want them to take effect. Unless otherwise specified, a pragma is in effect from the point where it is included until the end of the translation unit or until another pragma changes its status.
3 Pragma Directives and Attributes A pragma directive is an instruction to the compiler. You use a #pragma directive to control the actions of the compiler in a particular portion of a translation unit without affecting the translation unit as a whole. Put pragmas in your C++ source code where you want them to take effect. Unless otherwise specified, a pragma is in effect from the point where it is included until the end of the translation unit or until another pragma changes its status.
3 Pragma Directives and Attributes A pragma directive is an instruction to the compiler. You use a #pragma directive to control the actions of the compiler in a particular portion of a translation unit without affecting the translation unit as a whole. Put pragmas in your C++ source code where you want them to take effect. Unless otherwise specified, a pragma is in effect from the point where it is included until the end of the translation unit or until another pragma changes its status.
3 Pragma Directives and Attributes A pragma directive is an instruction to the compiler. You use a #pragma directive to control the actions of the compiler in a particular portion of a translation unit without affecting the translation unit as a whole. Put pragmas in your C++ source code where you want them to take effect. Unless otherwise specified, a pragma is in effect from the point where it is included until the end of the translation unit or until another pragma changes its status.
3 Pragma Directives and Attributes A pragma directive is an instruction to the compiler. You use a #pragma directive to control the actions of the compiler in a particular portion of a translation unit without affecting the translation unit as a whole. Put pragmas in your C++ source code where you want them to take effect. Unless otherwise specified, a pragma is in effect from the point where it is included until the end of the translation unit or until another pragma changes its status.
3 Pragma Directives and Attributes A pragma directive is an instruction to the compiler. You use a #pragma directive to control the actions of the compiler in a particular portion of a translation unit without affecting the translation unit as a whole. Put pragmas in your C++ source code where you want them to take effect. Unless otherwise specified, a pragma is in effect from the point where it is included until the end of the translation unit or until another pragma changes its status.
3 Pragma Directives and Attributes A pragma directive is an instruction to the compiler. You use a #pragma directive to control the actions of the compiler in a particular portion of a translation unit without affecting the translation unit as a whole. Put pragmas in your C++ source code where you want them to take effect. Unless otherwise specified, a pragma is in effect from the point where it is included until the end of the translation unit or until another pragma changes its status.
3 Pragma Directives and Attributes A pragma directive is an instruction to the compiler. You use a #pragma directive to control the actions of the compiler in a particular portion of a translation unit without affecting the translation unit as a whole. Put pragmas in your C++ source code where you want them to take effect. Unless otherwise specified, a pragma is in effect from the point where it is included until the end of the translation unit or until another pragma changes its status.
3 Pragma Directives and Attributes A pragma directive is an instruction to the compiler. You use a #pragma directive to control the actions of the compiler in a particular portion of a translation unit without affecting the translation unit as a whole. Put pragmas in your C++ source code where you want them to take effect. Unless otherwise specified, a pragma is in effect from the point where it is included until the end of the translation unit or until another pragma changes its status.
3 Pragma Directives and Attributes A pragma directive is an instruction to the compiler. You use a #pragma directive to control the actions of the compiler in a particular portion of a translation unit without affecting the translation unit as a whole. Put pragmas in your C++ source code where you want them to take effect. Unless otherwise specified, a pragma is in effect from the point where it is included until the end of the translation unit or until another pragma changes its status.
3 Pragma Directives and Attributes A pragma directive is an instruction to the compiler. You use a #pragma directive to control the actions of the compiler in a particular portion of a translation unit without affecting the translation unit as a whole. Put pragmas in your C++ source code where you want them to take effect. Unless otherwise specified, a pragma is in effect from the point where it is included until the end of the translation unit or until another pragma changes its status.
3 Pragma Directives and Attributes A pragma directive is an instruction to the compiler. You use a #pragma directive to control the actions of the compiler in a particular portion of a translation unit without affecting the translation unit as a whole. Put pragmas in your C++ source code where you want them to take effect. Unless otherwise specified, a pragma is in effect from the point where it is included until the end of the translation unit or until another pragma changes its status.
3 Pragma Directives and Attributes A pragma directive is an instruction to the compiler. You use a #pragma directive to control the actions of the compiler in a particular portion of a translation unit without affecting the translation unit as a whole. Put pragmas in your C++ source code where you want them to take effect. Unless otherwise specified, a pragma is in effect from the point where it is included until the end of the translation unit or until another pragma changes its status.
3 Pragma Directives and Attributes A pragma directive is an instruction to the compiler. You use a #pragma directive to control the actions of the compiler in a particular portion of a translation unit without affecting the translation unit as a whole. Put pragmas in your C++ source code where you want them to take effect. Unless otherwise specified, a pragma is in effect from the point where it is included until the end of the translation unit or until another pragma changes its status.
3 Pragma Directives and Attributes A pragma directive is an instruction to the compiler. You use a #pragma directive to control the actions of the compiler in a particular portion of a translation unit without affecting the translation unit as a whole. Put pragmas in your C++ source code where you want them to take effect. Unless otherwise specified, a pragma is in effect from the point where it is included until the end of the translation unit or until another pragma changes its status.
3 Pragma Directives and Attributes A pragma directive is an instruction to the compiler. You use a #pragma directive to control the actions of the compiler in a particular portion of a translation unit without affecting the translation unit as a whole. Put pragmas in your C++ source code where you want them to take effect. Unless otherwise specified, a pragma is in effect from the point where it is included until the end of the translation unit or until another pragma changes its status.
3 Pragma Directives and Attributes A pragma directive is an instruction to the compiler. You use a #pragma directive to control the actions of the compiler in a particular portion of a translation unit without affecting the translation unit as a whole. Put pragmas in your C++ source code where you want them to take effect. Unless otherwise specified, a pragma is in effect from the point where it is included until the end of the translation unit or until another pragma changes its status.
3 Pragma Directives and Attributes A pragma directive is an instruction to the compiler. You use a #pragma directive to control the actions of the compiler in a particular portion of a translation unit without affecting the translation unit as a whole. Put pragmas in your C++ source code where you want them to take effect. Unless otherwise specified, a pragma is in effect from the point where it is included until the end of the translation unit or until another pragma changes its status.
3 Pragma Directives and Attributes A pragma directive is an instruction to the compiler. You use a #pragma directive to control the actions of the compiler in a particular portion of a translation unit without affecting the translation unit as a whole. Put pragmas in your C++ source code where you want them to take effect. Unless otherwise specified, a pragma is in effect from the point where it is included until the end of the translation unit or until another pragma changes its status.
3 Pragma Directives and Attributes A pragma directive is an instruction to the compiler. You use a #pragma directive to control the actions of the compiler in a particular portion of a translation unit without affecting the translation unit as a whole. Put pragmas in your C++ source code where you want them to take effect. Unless otherwise specified, a pragma is in effect from the point where it is included until the end of the translation unit or until another pragma changes its status.
3 Pragma Directives and Attributes A pragma directive is an instruction to the compiler. You use a #pragma directive to control the actions of the compiler in a particular portion of a translation unit without affecting the translation unit as a whole. Put pragmas in your C++ source code where you want them to take effect. Unless otherwise specified, a pragma is in effect from the point where it is included until the end of the translation unit or until another pragma changes its status.
3 Pragma Directives and Attributes A pragma directive is an instruction to the compiler. You use a #pragma directive to control the actions of the compiler in a particular portion of a translation unit without affecting the translation unit as a whole. Put pragmas in your C++ source code where you want them to take effect. Unless otherwise specified, a pragma is in effect from the point where it is included until the end of the translation unit or until another pragma changes its status.
3 Pragma Directives and Attributes A pragma directive is an instruction to the compiler. You use a #pragma directive to control the actions of the compiler in a particular portion of a translation unit without affecting the translation unit as a whole. Put pragmas in your C++ source code where you want them to take effect. Unless otherwise specified, a pragma is in effect from the point where it is included until the end of the translation unit or until another pragma changes its status.
3 Pragma Directives and Attributes A pragma directive is an instruction to the compiler. You use a #pragma directive to control the actions of the compiler in a particular portion of a translation unit without affecting the translation unit as a whole. Put pragmas in your C++ source code where you want them to take effect. Unless otherwise specified, a pragma is in effect from the point where it is included until the end of the translation unit or until another pragma changes its status.
3 Pragma Directives and Attributes A pragma directive is an instruction to the compiler. You use a #pragma directive to control the actions of the compiler in a particular portion of a translation unit without affecting the translation unit as a whole. Put pragmas in your C++ source code where you want them to take effect. Unless otherwise specified, a pragma is in effect from the point where it is included until the end of the translation unit or until another pragma changes its status.
3 Pragma Directives and Attributes A pragma directive is an instruction to the compiler. You use a #pragma directive to control the actions of the compiler in a particular portion of a translation unit without affecting the translation unit as a whole. Put pragmas in your C++ source code where you want them to take effect. Unless otherwise specified, a pragma is in effect from the point where it is included until the end of the translation unit or until another pragma changes its status.
3 Pragma Directives and Attributes A pragma directive is an instruction to the compiler. You use a #pragma directive to control the actions of the compiler in a particular portion of a translation unit without affecting the translation unit as a whole. Put pragmas in your C++ source code where you want them to take effect. Unless otherwise specified, a pragma is in effect from the point where it is included until the end of the translation unit or until another pragma changes its status.
3 Pragma Directives and Attributes A pragma directive is an instruction to the compiler. You use a #pragma directive to control the actions of the compiler in a particular portion of a translation unit without affecting the translation unit as a whole. Put pragmas in your C++ source code where you want them to take effect. Unless otherwise specified, a pragma is in effect from the point where it is included until the end of the translation unit or until another pragma changes its status.
3 Pragma Directives and Attributes A pragma directive is an instruction to the compiler. You use a #pragma directive to control the actions of the compiler in a particular portion of a translation unit without affecting the translation unit as a whole. Put pragmas in your C++ source code where you want them to take effect. Unless otherwise specified, a pragma is in effect from the point where it is included until the end of the translation unit or until another pragma changes its status.
3 Pragma Directives and Attributes A pragma directive is an instruction to the compiler. You use a #pragma directive to control the actions of the compiler in a particular portion of a translation unit without affecting the translation unit as a whole. Put pragmas in your C++ source code where you want them to take effect. Unless otherwise specified, a pragma is in effect from the point where it is included until the end of the translation unit or until another pragma changes its status.
3 Pragma Directives and Attributes A pragma directive is an instruction to the compiler. You use a #pragma directive to control the actions of the compiler in a particular portion of a translation unit without affecting the translation unit as a whole. Put pragmas in your C++ source code where you want them to take effect. Unless otherwise specified, a pragma is in effect from the point where it is included until the end of the translation unit or until another pragma changes its status.
3 Pragma Directives and Attributes A pragma directive is an instruction to the compiler. You use a #pragma directive to control the actions of the compiler in a particular portion of a translation unit without affecting the translation unit as a whole. Put pragmas in your C++ source code where you want them to take effect. Unless otherwise specified, a pragma is in effect from the point where it is included until the end of the translation unit or until another pragma changes its status.
3 Pragma Directives and Attributes A pragma directive is an instruction to the compiler. You use a #pragma directive to control the actions of the compiler in a particular portion of a translation unit without affecting the translation unit as a whole. Put pragmas in your C++ source code where you want them to take effect. Unless otherwise specified, a pragma is in effect from the point where it is included until the end of the translation unit or until another pragma changes its status.
3 Pragma Directives and Attributes A pragma directive is an instruction to the compiler. You use a #pragma directive to control the actions of the compiler in a particular portion of a translation unit without affecting the translation unit as a whole. Put pragmas in your C++ source code where you want them to take effect. Unless otherwise specified, a pragma is in effect from the point where it is included until the end of the translation unit or until another pragma changes its status.
3 Pragma Directives and Attributes A pragma directive is an instruction to the compiler. You use a #pragma directive to control the actions of the compiler in a particular portion of a translation unit without affecting the translation unit as a whole. Put pragmas in your C++ source code where you want them to take effect. Unless otherwise specified, a pragma is in effect from the point where it is included until the end of the translation unit or until another pragma changes its status.
3 Pragma Directives and Attributes A pragma directive is an instruction to the compiler. You use a #pragma directive to control the actions of the compiler in a particular portion of a translation unit without affecting the translation unit as a whole. Put pragmas in your C++ source code where you want them to take effect. Unless otherwise specified, a pragma is in effect from the point where it is included until the end of the translation unit or until another pragma changes its status.
3 Pragma Directives and Attributes A pragma directive is an instruction to the compiler. You use a #pragma directive to control the actions of the compiler in a particular portion of a translation unit without affecting the translation unit as a whole. Put pragmas in your C++ source code where you want them to take effect. Unless otherwise specified, a pragma is in effect from the point where it is included until the end of the translation unit or until another pragma changes its status.
3 Pragma Directives and Attributes A pragma directive is an instruction to the compiler. You use a #pragma directive to control the actions of the compiler in a particular portion of a translation unit without affecting the translation unit as a whole. Put pragmas in your C++ source code where you want them to take effect. Unless otherwise specified, a pragma is in effect from the point where it is included until the end of the translation unit or until another pragma changes its status.
3 Pragma Directives and Attributes A pragma directive is an instruction to the compiler. You use a #pragma directive to control the actions of the compiler in a particular portion of a translation unit without affecting the translation unit as a whole. Put pragmas in your C++ source code where you want them to take effect. Unless otherwise specified, a pragma is in effect from the point where it is included until the end of the translation unit or until another pragma changes its status.
3 Pragma Directives and Attributes A pragma directive is an instruction to the compiler. You use a #pragma directive to control the actions of the compiler in a particular portion of a translation unit without affecting the translation unit as a whole. Put pragmas in your C++ source code where you want them to take effect. Unless otherwise specified, a pragma is in effect from the point where it is included until the end of the translation unit or until another pragma changes its status.
3 Pragma Directives and Attributes A pragma directive is an instruction to the compiler. You use a #pragma directive to control the actions of the compiler in a particular portion of a translation unit without affecting the translation unit as a whole. Put pragmas in your C++ source code where you want them to take effect. Unless otherwise specified, a pragma is in effect from the point where it is included until the end of the translation unit or until another pragma changes its status.
3 Pragma Directives and Attributes A pragma directive is an instruction to the compiler. You use a #pragma directive to control the actions of the compiler in a particular portion of a translation unit without affecting the translation unit as a whole. Put pragmas in your C++ source code where you want them to take effect. Unless otherwise specified, a pragma is in effect from the point where it is included until the end of the translation unit or until another pragma changes its status.
3 Pragma Directives and Attributes A pragma directive is an instruction to the compiler. You use a #pragma directive to control the actions of the compiler in a particular portion of a translation unit without affecting the translation unit as a whole. Put pragmas in your C++ source code where you want them to take effect. Unless otherwise specified, a pragma is in effect from the point where it is included until the end of the translation unit or until another pragma changes its status.
3 Pragma Directives and Attributes A pragma directive is an instruction to the compiler. You use a #pragma directive to control the actions of the compiler in a particular portion of a translation unit without affecting the translation unit as a whole. Put pragmas in your C++ source code where you want them to take effect. Unless otherwise specified, a pragma is in effect from the point where it is included until the end of the translation unit or until another pragma changes its status.
3 Pragma Directives and Attributes A pragma directive is an instruction to the compiler. You use a #pragma directive to control the actions of the compiler in a particular portion of a translation unit without affecting the translation unit as a whole. Put pragmas in your C++ source code where you want them to take effect. Unless otherwise specified, a pragma is in effect from the point where it is included until the end of the translation unit or until another pragma changes its status.
3 Pragma Directives and Attributes A pragma directive is an instruction to the compiler. You use a #pragma directive to control the actions of the compiler in a particular portion of a translation unit without affecting the translation unit as a whole. Put pragmas in your C++ source code where you want them to take effect. Unless otherwise specified, a pragma is in effect from the point where it is included until the end of the translation unit or until another pragma changes its status.
3 Pragma Directives and Attributes A pragma directive is an instruction to the compiler. You use a #pragma directive to control the actions of the compiler in a particular portion of a translation unit without affecting the translation unit as a whole. Put pragmas in your C++ source code where you want them to take effect. Unless otherwise specified, a pragma is in effect from the point where it is included until the end of the translation unit or until another pragma changes its status.
3 Pragma Directives and Attributes A pragma directive is an instruction to the compiler. You use a #pragma directive to control the actions of the compiler in a particular portion of a translation unit without affecting the translation unit as a whole. Put pragmas in your C++ source code where you want them to take effect. Unless otherwise specified, a pragma is in effect from the point where it is included until the end of the translation unit or until another pragma changes its status.
3 Pragma Directives and Attributes A pragma directive is an instruction to the compiler. You use a #pragma directive to control the actions of the compiler in a particular portion of a translation unit without affecting the translation unit as a whole. Put pragmas in your C++ source code where you want them to take effect. Unless otherwise specified, a pragma is in effect from the point where it is included until the end of the translation unit or until another pragma changes its status.
3 Pragma Directives and Attributes A pragma directive is an instruction to the compiler. You use a #pragma directive to control the actions of the compiler in a particular portion of a translation unit without affecting the translation unit as a whole. Put pragmas in your C++ source code where you want them to take effect. Unless otherwise specified, a pragma is in effect from the point where it is included until the end of the translation unit or until another pragma changes its status.
3 Pragma Directives and Attributes A pragma directive is an instruction to the compiler. You use a #pragma directive to control the actions of the compiler in a particular portion of a translation unit without affecting the translation unit as a whole. Put pragmas in your C++ source code where you want them to take effect. Unless otherwise specified, a pragma is in effect from the point where it is included until the end of the translation unit or until another pragma changes its status.
3 Pragma Directives and Attributes A pragma directive is an instruction to the compiler. You use a #pragma directive to control the actions of the compiler in a particular portion of a translation unit without affecting the translation unit as a whole. Put pragmas in your C++ source code where you want them to take effect. Unless otherwise specified, a pragma is in effect from the point where it is included until the end of the translation unit or until another pragma changes its status.
3 Pragma Directives and Attributes A pragma directive is an instruction to the compiler. You use a #pragma directive to control the actions of the compiler in a particular portion of a translation unit without affecting the translation unit as a whole. Put pragmas in your C++ source code where you want them to take effect. Unless otherwise specified, a pragma is in effect from the point where it is included until the end of the translation unit or until another pragma changes its status.
3 Pragma Directives and Attributes A pragma directive is an instruction to the compiler. You use a #pragma directive to control the actions of the compiler in a particular portion of a translation unit without affecting the translation unit as a whole. Put pragmas in your C++ source code where you want them to take effect. Unless otherwise specified, a pragma is in effect from the point where it is included until the end of the translation unit or until another pragma changes its status.
3 Pragma Directives and Attributes A pragma directive is an instruction to the compiler. You use a #pragma directive to control the actions of the compiler in a particular portion of a translation unit without affecting the translation unit as a whole. Put pragmas in your C++ source code where you want them to take effect. Unless otherwise specified, a pragma is in effect from the point where it is included until the end of the translation unit or until another pragma changes its status.
3 Pragma Directives and Attributes A pragma directive is an instruction to the compiler. You use a #pragma directive to control the actions of the compiler in a particular portion of a translation unit without affecting the translation unit as a whole. Put pragmas in your C++ source code where you want them to take effect. Unless otherwise specified, a pragma is in effect from the point where it is included until the end of the translation unit or until another pragma changes its status.
3 Pragma Directives and Attributes A pragma directive is an instruction to the compiler. You use a #pragma directive to control the actions of the compiler in a particular portion of a translation unit without affecting the translation unit as a whole. Put pragmas in your C++ source code where you want them to take effect. Unless otherwise specified, a pragma is in effect from the point where it is included until the end of the translation unit or until another pragma changes its status.
3 Pragma Directives and Attributes A pragma directive is an instruction to the compiler. You use a #pragma directive to control the actions of the compiler in a particular portion of a translation unit without affecting the translation unit as a whole. Put pragmas in your C++ source code where you want them to take effect. Unless otherwise specified, a pragma is in effect from the point where it is included until the end of the translation unit or until another pragma changes its status.
3 Pragma Directives and Attributes A pragma directive is an instruction to the compiler. You use a #pragma directive to control the actions of the compiler in a particular portion of a translation unit without affecting the translation unit as a whole. Put pragmas in your C++ source code where you want them to take effect. Unless otherwise specified, a pragma is in effect from the point where it is included until the end of the translation unit or until another pragma changes its status.
3 Pragma Directives and Attributes A pragma directive is an instruction to the compiler. You use a #pragma directive to control the actions of the compiler in a particular portion of a translation unit without affecting the translation unit as a whole. Put pragmas in your C++ source code where you want them to take effect. Unless otherwise specified, a pragma is in effect from the point where it is included until the end of the translation unit or until another pragma changes its status.
3 Pragma Directives and Attributes A pragma directive is an instruction to the compiler. You use a #pragma directive to control the actions of the compiler in a particular portion of a translation unit without affecting the translation unit as a whole. Put pragmas in your C++ source code where you want them to take effect. Unless otherwise specified, a pragma is in effect from the point where it is included until the end of the translation unit or until another pragma changes its status.
3 Pragma Directives and Attributes A pragma directive is an instruction to the compiler. You use a #pragma directive to control the actions of the compiler in a particular portion of a translation unit without affecting the translation unit as a whole. Put pragmas in your C++ source code where you want them to take effect. Unless otherwise specified, a pragma is in effect from the point where it is included until the end of the translation unit or until another pragma changes its status.
3 Pragma Directives and Attributes A pragma directive is an instruction to the compiler. You use a #pragma directive to control the actions of the compiler in a particular portion of a translation unit without affecting the translation unit as a whole. Put pragmas in your C++ source code where you want them to take effect. Unless otherwise specified, a pragma is in effect from the point where it is included until the end of the translation unit or until another pragma changes its status.
3 Pragma Directives and Attributes A pragma directive is an instruction to the compiler. You use a #pragma directive to control the actions of the compiler in a particular portion of a translation unit without affecting the translation unit as a whole. Put pragmas in your C++ source code where you want them to take effect. Unless otherwise specified, a pragma is in effect from the point where it is included until the end of the translation unit or until another pragma changes its status.
3 Pragma Directives and Attributes A pragma directive is an instruction to the compiler. You use a #pragma directive to control the actions of the compiler in a particular portion of a translation unit without affecting the translation unit as a whole. Put pragmas in your C++ source code where you want them to take effect. Unless otherwise specified, a pragma is in effect from the point where it is included until the end of the translation unit or until another pragma changes its status.
3 Pragma Directives and Attributes A pragma directive is an instruction to the compiler. You use a #pragma directive to control the actions of the compiler in a particular portion of a translation unit without affecting the translation unit as a whole. Put pragmas in your C++ source code where you want them to take effect. Unless otherwise specified, a pragma is in effect from the point where it is included until the end of the translation unit or until another pragma changes its status.
3 Pragma Directives and Attributes A pragma directive is an instruction to the compiler. You use a #pragma directive to control the actions of the compiler in a particular portion of a translation unit without affecting the translation unit as a whole. Put pragmas in your C++ source code where you want them to take effect. Unless otherwise specified, a pragma is in effect from the point where it is included until the end of the translation unit or until another pragma changes its status.
3 Pragma Directives and Attributes A pragma directive is an instruction to the compiler. You use a #pragma directive to control the actions of the compiler in a particular portion of a translation unit without affecting the translation unit as a whole. Put pragmas in your C++ source code where you want them to take effect. Unless otherwise specified, a pragma is in effect from the point where it is included until the end of the translation unit or until another pragma changes its status.
3 Pragma Directives and Attributes A pragma directive is an instruction to the compiler. You use a #pragma directive to control the actions of the compiler in a particular portion of a translation unit without affecting the translation unit as a whole. Put pragmas in your C++ source code where you want them to take effect. Unless otherwise specified, a pragma is in effect from the point where it is included until the end of the translation unit or until another pragma changes its status.
3 Pragma Directives and Attributes A pragma directive is an instruction to the compiler. You use a #pragma directive to control the actions of the compiler in a particular portion of a translation unit without affecting the translation unit as a whole. Put pragmas in your C++ source code where you want them to take effect. Unless otherwise specified, a pragma is in effect from the point where it is included until the end of the translation unit or until another pragma changes its status.
3 Pragma Directives and Attributes A pragma directive is an instruction to the compiler. You use a #pragma directive to control the actions of the compiler in a particular portion of a translation unit without affecting the translation unit as a whole. Put pragmas in your C++ source code where you want them to take effect. Unless otherwise specified, a pragma is in effect from the point where it is included until the end of the translation unit or until another pragma changes its status.
3 Pragma Directives and Attributes A pragma directive is an instruction to the compiler. You use a #pragma directive to control the actions of the compiler in a particular portion of a translation unit without affecting the translation unit as a whole. Put pragmas in your C++ source code where you want them to take effect. Unless otherwise specified, a pragma is in effect from the point where it is included until the end of the translation unit or until another pragma changes its status.
3 Pragma Directives and Attributes A pragma directive is an instruction to the compiler. You use a #pragma directive to control the actions of the compiler in a particular portion of a translation unit without affecting the translation unit as a whole. Put pragmas in your C++ source code where you want them to take effect. Unless otherwise specified, a pragma is in effect from the point where it is included until the end of the translation unit or until another pragma changes its status.
3 Pragma Directives and Attributes A pragma directive is an instruction to the compiler. You use a #pragma directive to control the actions of the compiler in a particular portion of a translation unit without affecting the translation unit as a whole. Put pragmas in your C++ source code where you want them to take effect. Unless otherwise specified, a pragma is in effect from the point where it is included until the end of the translation unit or until another pragma changes its status.
3 Pragma Directives and Attributes A pragma directive is an instruction to the compiler. You use a #pragma directive to control the actions of the compiler in a particular portion of a translation unit without affecting the translation unit as a whole. Put pragmas in your C++ source code where you want them to take effect. Unless otherwise specified, a pragma is in effect from the point where it is included until the end of the translation unit or until another pragma changes its status.
3 Pragma Directives and Attributes A pragma directive is an instruction to the compiler. You use a #pragma directive to control the actions of the compiler in a particular portion of a translation unit without affecting the translation unit as a whole. Put pragmas in your C++ source code where you want them to take effect. Unless otherwise specified, a pragma is in effect from the point where it is included until the end of the translation unit or until another pragma changes its status.
3 Pragma Directives and Attributes A pragma directive is an instruction to the compiler. You use a #pragma directive to control the actions of the compiler in a particular portion of a translation unit without affecting the translation unit as a whole. Put pragmas in your C++ source code where you want them to take effect. Unless otherwise specified, a pragma is in effect from the point where it is included until the end of the translation unit or until another pragma changes its status.
3 Pragma Directives and Attributes A pragma directive is an instruction to the compiler. You use a #pragma directive to control the actions of the compiler in a particular portion of a translation unit without affecting the translation unit as a whole. Put pragmas in your C++ source code where you want them to take effect. Unless otherwise specified, a pragma is in effect from the point where it is included until the end of the translation unit or until another pragma changes its status.
3 Pragma Directives and Attributes A pragma directive is an instruction to the compiler. You use a #pragma directive to control the actions of the compiler in a particular portion of a translation unit without affecting the translation unit as a whole. Put pragmas in your C++ source code where you want them to take effect. Unless otherwise specified, a pragma is in effect from the point where it is included until the end of the translation unit or until another pragma changes its status.
3 Pragma Directives and Attributes A pragma directive is an instruction to the compiler. You use a #pragma directive to control the actions of the compiler in a particular portion of a translation unit without affecting the translation unit as a whole. Put pragmas in your C++ source code where you want them to take effect. Unless otherwise specified, a pragma is in effect from the point where it is included until the end of the translation unit or until another pragma changes its status.
3 Pragma Directives and Attributes A pragma directive is an instruction to the compiler. You use a #pragma directive to control the actions of the compiler in a particular portion of a translation unit without affecting the translation unit as a whole. Put pragmas in your C++ source code where you want them to take effect. Unless otherwise specified, a pragma is in effect from the point where it is included until the end of the translation unit or until another pragma changes its status.
3 Pragma Directives and Attributes A pragma directive is an instruction to the compiler. You use a #pragma directive to control the actions of the compiler in a particular portion of a translation unit without affecting the translation unit as a whole. Put pragmas in your C++ source code where you want them to take effect. Unless otherwise specified, a pragma is in effect from the point where it is included until the end of the translation unit or until another pragma changes its status.
3 Pragma Directives and Attributes A pragma directive is an instruction to the compiler. You use a #pragma directive to control the actions of the compiler in a particular portion of a translation unit without affecting the translation unit as a whole. Put pragmas in your C++ source code where you want them to take effect. Unless otherwise specified, a pragma is in effect from the point where it is included until the end of the translation unit or until another pragma changes its status.
3 Pragma Directives and Attributes A pragma directive is an instruction to the compiler. You use a #pragma directive to control the actions of the compiler in a particular portion of a translation unit without affecting the translation unit as a whole. Put pragmas in your C++ source code where you want them to take effect. Unless otherwise specified, a pragma is in effect from the point where it is included until the end of the translation unit or until another pragma changes its status.
3 Pragma Directives and Attributes A pragma directive is an instruction to the compiler. You use a #pragma directive to control the actions of the compiler in a particular portion of a translation unit without affecting the translation unit as a whole. Put pragmas in your C++ source code where you want them to take effect. Unless otherwise specified, a pragma is in effect from the point where it is included until the end of the translation unit or until another pragma changes its status.
3 Pragma Directives and Attributes A pragma directive is an instruction to the compiler. You use a #pragma directive to control the actions of the compiler in a particular portion of a translation unit without affecting the translation unit as a whole. Put pragmas in your C++ source code where you want them to take effect. Unless otherwise specified, a pragma is in effect from the point where it is included until the end of the translation unit or until another pragma changes its status.
3 Pragma Directives and Attributes A pragma directive is an instruction to the compiler. You use a #pragma directive to control the actions of the compiler in a particular portion of a translation unit without affecting the translation unit as a whole. Put pragmas in your C++ source code where you want them to take effect. Unless otherwise specified, a pragma is in effect from the point where it is included until the end of the translation unit or until another pragma changes its status.
3 Pragma Directives and Attributes A pragma directive is an instruction to the compiler. You use a #pragma directive to control the actions of the compiler in a particular portion of a translation unit without affecting the translation unit as a whole. Put pragmas in your C++ source code where you want them to take effect. Unless otherwise specified, a pragma is in effect from the point where it is included until the end of the translation unit or until another pragma changes its status.
3 Pragma Directives and Attributes A pragma directive is an instruction to the compiler. You use a #pragma directive to control the actions of the compiler in a particular portion of a translation unit without affecting the translation unit as a whole. Put pragmas in your C++ source code where you want them to take effect. Unless otherwise specified, a pragma is in effect from the point where it is included until the end of the translation unit or until another pragma changes its status.
3 Pragma Directives and Attributes A pragma directive is an instruction to the compiler. You use a #pragma directive to control the actions of the compiler in a particular portion of a translation unit without affecting the translation unit as a whole. Put pragmas in your C++ source code where you want them to take effect. Unless otherwise specified, a pragma is in effect from the point where it is included until the end of the translation unit or until another pragma changes its status.
3 Pragma Directives and Attributes A pragma directive is an instruction to the compiler. You use a #pragma directive to control the actions of the compiler in a particular portion of a translation unit without affecting the translation unit as a whole. Put pragmas in your C++ source code where you want them to take effect. Unless otherwise specified, a pragma is in effect from the point where it is included until the end of the translation unit or until another pragma changes its status.
3 Pragma Directives and Attributes A pragma directive is an instruction to the compiler. You use a #pragma directive to control the actions of the compiler in a particular portion of a translation unit without affecting the translation unit as a whole. Put pragmas in your C++ source code where you want them to take effect. Unless otherwise specified, a pragma is in effect from the point where it is included until the end of the translation unit or until another pragma changes its status.
3 Pragma Directives and Attributes A pragma directive is an instruction to the compiler. You use a #pragma directive to control the actions of the compiler in a particular portion of a translation unit without affecting the translation unit as a whole. Put pragmas in your C++ source code where you want them to take effect. Unless otherwise specified, a pragma is in effect from the point where it is included until the end of the translation unit or until another pragma changes its status.
3 Pragma Directives and Attributes A pragma directive is an instruction to the compiler. You use a #pragma directive to control the actions of the compiler in a particular portion of a translation unit without affecting the translation unit as a whole. Put pragmas in your C++ source code where you want them to take effect. Unless otherwise specified, a pragma is in effect from the point where it is included until the end of the translation unit or until another pragma changes its status.
3 Pragma Directives and Attributes A pragma directive is an instruction to the compiler. You use a #pragma directive to control the actions of the compiler in a particular portion of a translation unit without affecting the translation unit as a whole. Put pragmas in your C++ source code where you want them to take effect. Unless otherwise specified, a pragma is in effect from the point where it is included until the end of the translation unit or until another pragma changes its status.
3 Pragma Directives and Attributes A pragma directive is an instruction to the compiler. You use a #pragma directive to control the actions of the compiler in a particular portion of a translation unit without affecting the translation unit as a whole. Put pragmas in your C++ source code where you want them to take effect. Unless otherwise specified, a pragma is in effect from the point where it is included until the end of the translation unit or until another pragma changes its status.
3 Pragma Directives and Attributes A pragma directive is an instruction to the compiler. You use a #pragma directive to control the actions of the compiler in a particular portion of a translation unit without affecting the translation unit as a whole. Put pragmas in your C++ source code where you want them to take effect. Unless otherwise specified, a pragma is in effect from the point where it is included until the end of the translation unit or until another pragma changes its status.
3 Pragma Directives and Attributes A pragma directive is an instruction to the compiler. You use a #pragma directive to control the actions of the compiler in a particular portion of a translation unit without affecting the translation unit as a whole. Put pragmas in your C++ source code where you want them to take effect. Unless otherwise specified, a pragma is in effect from the point where it is included until the end of the translation unit or until another pragma changes its status.
3 Pragma Directives and Attributes A pragma directive is an instruction to the compiler. You use a #pragma directive to control the actions of the compiler in a particular portion of a translation unit without affecting the translation unit as a whole. Put pragmas in your C++ source code where you want them to take effect. Unless otherwise specified, a pragma is in effect from the point where it is included until the end of the translation unit or until another pragma changes its status.
3 Pragma Directives and Attributes A pragma directive is an instruction to the compiler. You use a #pragma directive to control the actions of the compiler in a particular portion of a translation unit without affecting the translation unit as a whole. Put pragmas in your C++ source code where you want them to take effect. Unless otherwise specified, a pragma is in effect from the point where it is included until the end of the translation unit or until another pragma changes its status.
3 Pragma Directives and Attributes A pragma directive is an instruction to the compiler. You use a #pragma directive to control the actions of the compiler in a particular portion of a translation unit without affecting the translation unit as a whole. Put pragmas in your C++ source code where you want them to take effect. Unless otherwise specified, a pragma is in effect from the point where it is included until the end of the translation unit or until another pragma changes its status.
3 Pragma Directives and Attributes A pragma directive is an instruction to the compiler. You use a #pragma directive to control the actions of the compiler in a particular portion of a translation unit without affecting the translation unit as a whole. Put pragmas in your C++ source code where you want them to take effect. Unless otherwise specified, a pragma is in effect from the point where it is included until the end of the translation unit or until another pragma changes its status.
3 Pragma Directives and Attributes A pragma directive is an instruction to the compiler. You use a #pragma directive to control the actions of the compiler in a particular portion of a translation unit without affecting the translation unit as a whole. Put pragmas in your C++ source code where you want them to take effect. Unless otherwise specified, a pragma is in effect from the point where it is included until the end of the translation unit or until another pragma changes its status.
3 Pragma Directives and Attributes A pragma directive is an instruction to the compiler. You use a #pragma directive to control the actions of the compiler in a particular portion of a translation unit without affecting the translation unit as a whole. Put pragmas in your C++ source code where you want them to take effect. Unless otherwise specified, a pragma is in effect from the point where it is included until the end of the translation unit or until another pragma changes its status.
3 Pragma Directives and Attributes A pragma directive is an instruction to the compiler. You use a #pragma directive to control the actions of the compiler in a particular portion of a translation unit without affecting the translation unit as a whole. Put pragmas in your C++ source code where you want them to take effect. Unless otherwise specified, a pragma is in effect from the point where it is included until the end of the translation unit or until another pragma changes its status.
3 Pragma Directives and Attributes A pragma directive is an instruction to the compiler. You use a #pragma directive to control the actions of the compiler in a particular portion of a translation unit without affecting the translation unit as a whole. Put pragmas in your C++ source code where you want them to take effect. Unless otherwise specified, a pragma is in effect from the point where it is included until the end of the translation unit or until another pragma changes its status.
3 Pragma Directives and Attributes A pragma directive is an instruction to the compiler. You use a #pragma directive to control the actions of the compiler in a particular portion of a translation unit without affecting the translation unit as a whole. Put pragmas in your C++ source code where you want them to take effect. Unless otherwise specified, a pragma is in effect from the point where it is included until the end of the translation unit or until another pragma changes its status.
3 Pragma Directives and Attributes A pragma directive is an instruction to the compiler. You use a #pragma directive to control the actions of the compiler in a particular portion of a translation unit without affecting the translation unit as a whole. Put pragmas in your C++ source code where you want them to take effect. Unless otherwise specified, a pragma is in effect from the point where it is included until the end of the translation unit or until another pragma changes its status.
3 Pragma Directives and Attributes A pragma directive is an instruction to the compiler. You use a #pragma directive to control the actions of the compiler in a particular portion of a translation unit without affecting the translation unit as a whole. Put pragmas in your C++ source code where you want them to take effect. Unless otherwise specified, a pragma is in effect from the point where it is included until the end of the translation unit or until another pragma changes its status.
3 Pragma Directives and Attributes A pragma directive is an instruction to the compiler. You use a #pragma directive to control the actions of the compiler in a particular portion of a translation unit without affecting the translation unit as a whole. Put pragmas in your C++ source code where you want them to take effect. Unless otherwise specified, a pragma is in effect from the point where it is included until the end of the translation unit or until another pragma changes its status.
3 Pragma Directives and Attributes A pragma directive is an instruction to the compiler. You use a #pragma directive to control the actions of the compiler in a particular portion of a translation unit without affecting the translation unit as a whole. Put pragmas in your C++ source code where you want them to take effect. Unless otherwise specified, a pragma is in effect from the point where it is included until the end of the translation unit or until another pragma changes its status.
3 Pragma Directives and Attributes A pragma directive is an instruction to the compiler. You use a #pragma directive to control the actions of the compiler in a particular portion of a translation unit without affecting the translation unit as a whole. Put pragmas in your C++ source code where you want them to take effect. Unless otherwise specified, a pragma is in effect from the point where it is included until the end of the translation unit or until another pragma changes its status.
3 Pragma Directives and Attributes A pragma directive is an instruction to the compiler. You use a #pragma directive to control the actions of the compiler in a particular portion of a translation unit without affecting the translation unit as a whole. Put pragmas in your C++ source code where you want them to take effect. Unless otherwise specified, a pragma is in effect from the point where it is included until the end of the translation unit or until another pragma changes its status.
3 Pragma Directives and Attributes A pragma directive is an instruction to the compiler. You use a #pragma directive to control the actions of the compiler in a particular portion of a translation unit without affecting the translation unit as a whole. Put pragmas in your C++ source code where you want them to take effect. Unless otherwise specified, a pragma is in effect from the point where it is included until the end of the translation unit or until another pragma changes its status.
3 Pragma Directives and Attributes A pragma directive is an instruction to the compiler. You use a #pragma directive to control the actions of the compiler in a particular portion of a translation unit without affecting the translation unit as a whole. Put pragmas in your C++ source code where you want them to take effect. Unless otherwise specified, a pragma is in effect from the point where it is included until the end of the translation unit or until another pragma changes its status.
3 Pragma Directives and Attributes A pragma directive is an instruction to the compiler. You use a #pragma directive to control the actions of the compiler in a particular portion of a translation unit without affecting the translation unit as a whole. Put pragmas in your C++ source code where you want them to take effect. Unless otherwise specified, a pragma is in effect from the point where it is included until the end of the translation unit or until another pragma changes its status.
3 Pragma Directives and Attributes A pragma directive is an instruction to the compiler. You use a #pragma directive to control the actions of the compiler in a particular portion of a translation unit without affecting the translation unit as a whole. Put pragmas in your C++ source code where you want them to take effect. Unless otherwise specified, a pragma is in effect from the point where it is included until the end of the translation unit or until another pragma changes its status.
3 Pragma Directives and Attributes A pragma directive is an instruction to the compiler. You use a #pragma directive to control the actions of the compiler in a particular portion of a translation unit without affecting the translation unit as a whole. Put pragmas in your C++ source code where you want them to take effect. Unless otherwise specified, a pragma is in effect from the point where it is included until the end of the translation unit or until another pragma changes its status.
3 Pragma Directives and Attributes A pragma directive is an instruction to the compiler. You use a #pragma directive to control the actions of the compiler in a particular portion of a translation unit without affecting the translation unit as a whole. Put pragmas in your C++ source code where you want them to take effect. Unless otherwise specified, a pragma is in effect from the point where it is included until the end of the translation unit or until another pragma changes its status.
3 Pragma Directives and Attributes A pragma directive is an instruction to the compiler. You use a #pragma directive to control the actions of the compiler in a particular portion of a translation unit without affecting the translation unit as a whole. Put pragmas in your C++ source code where you want them to take effect. Unless otherwise specified, a pragma is in effect from the point where it is included until the end of the translation unit or until another pragma changes its status.
3 Pragma Directives and Attributes A pragma directive is an instruction to the compiler. You use a #pragma directive to control the actions of the compiler in a particular portion of a translation unit without affecting the translation unit as a whole. Put pragmas in your C++ source code where you want them to take effect. Unless otherwise specified, a pragma is in effect from the point where it is included until the end of the translation unit or until another pragma changes its status.
3 Pragma Directives and Attributes A pragma directive is an instruction to the compiler. You use a #pragma directive to control the actions of the compiler in a particular portion of a translation unit without affecting the translation unit as a whole. Put pragmas in your C++ source code where you want them to take effect. Unless otherwise specified, a pragma is in effect from the point where it is included until the end of the translation unit or until another pragma changes its status.
3 Pragma Directives and Attributes A pragma directive is an instruction to the compiler. You use a #pragma directive to control the actions of the compiler in a particular portion of a translation unit without affecting the translation unit as a whole. Put pragmas in your C++ source code where you want them to take effect. Unless otherwise specified, a pragma is in effect from the point where it is included until the end of the translation unit or until another pragma changes its status.
3 Pragma Directives and Attributes A pragma directive is an instruction to the compiler. You use a #pragma directive to control the actions of the compiler in a particular portion of a translation unit without affecting the translation unit as a whole. Put pragmas in your C++ source code where you want them to take effect. Unless otherwise specified, a pragma is in effect from the point where it is included until the end of the translation unit or until another pragma changes its status.
3 Pragma Directives and Attributes A pragma directive is an instruction to the compiler. You use a #pragma directive to control the actions of the compiler in a particular portion of a translation unit without affecting the translation unit as a whole. Put pragmas in your C++ source code where you want them to take effect. Unless otherwise specified, a pragma is in effect from the point where it is included until the end of the translation unit or until another pragma changes its status.
3 Pragma Directives and Attributes A pragma directive is an instruction to the compiler. You use a #pragma directive to control the actions of the compiler in a particular portion of a translation unit without affecting the translation unit as a whole. Put pragmas in your C++ source code where you want them to take effect. Unless otherwise specified, a pragma is in effect from the point where it is included until the end of the translation unit or until another pragma changes its status.
3 Pragma Directives and Attributes A pragma directive is an instruction to the compiler. You use a #pragma directive to control the actions of the compiler in a particular portion of a translation unit without affecting the translation unit as a whole. Put pragmas in your C++ source code where you want them to take effect. Unless otherwise specified, a pragma is in effect from the point where it is included until the end of the translation unit or until another pragma changes its status.
3 Pragma Directives and Attributes A pragma directive is an instruction to the compiler. You use a #pragma directive to control the actions of the compiler in a particular portion of a translation unit without affecting the translation unit as a whole. Put pragmas in your C++ source code where you want them to take effect. Unless otherwise specified, a pragma is in effect from the point where it is included until the end of the translation unit or until another pragma changes its status.
3 Pragma Directives and Attributes A pragma directive is an instruction to the compiler. You use a #pragma directive to control the actions of the compiler in a particular portion of a translation unit without affecting the translation unit as a whole. Put pragmas in your C++ source code where you want them to take effect. Unless otherwise specified, a pragma is in effect from the point where it is included until the end of the translation unit or until another pragma changes its status.
3 Pragma Directives and Attributes A pragma directive is an instruction to the compiler. You use a #pragma directive to control the actions of the compiler in a particular portion of a translation unit without affecting the translation unit as a whole. Put pragmas in your C++ source code where you want them to take effect. Unless otherwise specified, a pragma is in effect from the point where it is included until the end of the translation unit or until another pragma changes its status.
3 Pragma Directives and Attributes A pragma directive is an instruction to the compiler. You use a #pragma directive to control the actions of the compiler in a particular portion of a translation unit without affecting the translation unit as a whole. Put pragmas in your C++ source code where you want them to take effect. Unless otherwise specified, a pragma is in effect from the point where it is included until the end of the translation unit or until another pragma changes its status.
3 Pragma Directives and Attributes A pragma directive is an instruction to the compiler. You use a #pragma directive to control the actions of the compiler in a particular portion of a translation unit without affecting the translation unit as a whole. Put pragmas in your C++ source code where you want them to take effect. Unless otherwise specified, a pragma is in effect from the point where it is included until the end of the translation unit or until another pragma changes its status.
3 Pragma Directives and Attributes A pragma directive is an instruction to the compiler. You use a #pragma directive to control the actions of the compiler in a particular portion of a translation unit without affecting the translation unit as a whole. Put pragmas in your C++ source code where you want them to take effect. Unless otherwise specified, a pragma is in effect from the point where it is included until the end of the translation unit or until another pragma changes its status.
3 Pragma Directives and Attributes A pragma directive is an instruction to the compiler. You use a #pragma directive to control the actions of the compiler in a particular portion of a translation unit without affecting the translation unit as a whole. Put pragmas in your C++ source code where you want them to take effect. Unless otherwise specified, a pragma is in effect from the point where it is included until the end of the translation unit or until another pragma changes its status.
3 Pragma Directives and Attributes A pragma directive is an instruction to the compiler. You use a #pragma directive to control the actions of the compiler in a particular portion of a translation unit without affecting the translation unit as a whole. Put pragmas in your C++ source code where you want them to take effect. Unless otherwise specified, a pragma is in effect from the point where it is included until the end of the translation unit or until another pragma changes its status.
3 Pragma Directives and Attributes A pragma directive is an instruction to the compiler. You use a #pragma directive to control the actions of the compiler in a particular portion of a translation unit without affecting the translation unit as a whole. Put pragmas in your C++ source code where you want them to take effect. Unless otherwise specified, a pragma is in effect from the point where it is included until the end of the translation unit or until another pragma changes its status.
3 Pragma Directives and Attributes A pragma directive is an instruction to the compiler. You use a #pragma directive to control the actions of the compiler in a particular portion of a translation unit without affecting the translation unit as a whole. Put pragmas in your C++ source code where you want them to take effect. Unless otherwise specified, a pragma is in effect from the point where it is included until the end of the translation unit or until another pragma changes its status.
3 Pragma Directives and Attributes A pragma directive is an instruction to the compiler. You use a #pragma directive to control the actions of the compiler in a particular portion of a translation unit without affecting the translation unit as a whole. Put pragmas in your C++ source code where you want them to take effect. Unless otherwise specified, a pragma is in effect from the point where it is included until the end of the translation unit or until another pragma changes its status.
3 Pragma Directives and Attributes A pragma directive is an instruction to the compiler. You use a #pragma directive to control the actions of the compiler in a particular portion of a translation unit without affecting the translation unit as a whole. Put pragmas in your C++ source code where you want them to take effect. Unless otherwise specified, a pragma is in effect from the point where it is included until the end of the translation unit or until another pragma changes its status.
3 Pragma Directives and Attributes A pragma directive is an instruction to the compiler. You use a #pragma directive to control the actions of the compiler in a particular portion of a translation unit without affecting the translation unit as a whole. Put pragmas in your C++ source code where you want them to take effect. Unless otherwise specified, a pragma is in effect from the point where it is included until the end of the translation unit or until another pragma changes its status.
3 Pragma Directives and Attributes A pragma directive is an instruction to the compiler. You use a #pragma directive to control the actions of the compiler in a particular portion of a translation unit without affecting the translation unit as a whole. Put pragmas in your C++ source code where you want them to take effect. Unless otherwise specified, a pragma is in effect from the point where it is included until the end of the translation unit or until another pragma changes its status.
3 Pragma Directives and Attributes A pragma directive is an instruction to the compiler. You use a #pragma directive to control the actions of the compiler in a particular portion of a translation unit without affecting the translation unit as a whole. Put pragmas in your C++ source code where you want them to take effect. Unless otherwise specified, a pragma is in effect from the point where it is included until the end of the translation unit or until another pragma changes its status.
