gcc.hlp

gcc帮助文档！对linux c/c++开发大有帮助！

       Options Controlling C++ Dialect

       This section describes the command-line options that are only meaning-
       ful for C++ programs; but you can also use most of the GNU compiler
       options regardless of what language your program is in.	For example,
       you might compile a file "firstClass.C" like this:

	       g++ -g -frepo -O -c firstClass.C

       In this example, only -frepo is an option meant only for C++ programs;
       you can use the other options with any language supported by GCC.

       Here is a list of options that are only for compiling C++ programs:

       -fno-access-control
	   Turn off all access checking.  This switch is mainly useful for
	   working around bugs in the access control code.

       -fcheck-new
	   Check that the pointer returned by "operator new" is non-null
	   before attempting to modify the storage allocated.  The current
	   Working Paper requires that "operator new" never return a null
	   pointer, so this check is normally unnecessary.

	   An alternative to using this option is to specify that your "opera-
	   tor new" does not throw any exceptions; if you declare it throw(),
	   G++ will check the return value.  See also new (nothrow).

       -fconserve-space
	   Put uninitialized or runtime-initialized global variables into the
	   common segment, as C does.  This saves space in the executable at
	   the cost of not diagnosing duplicate definitions.  If you compile
	   with this flag and your program mysteriously crashes after "main()"
	   has completed, you may have an object that is being destroyed twice
	   because two definitions were merged.

	   This option is no longer useful on most targets, now that support
	   has been added for putting variables into BSS without making them
	   common.

       -fno-const-strings
	   Give string constants type "char *" instead of type "const char *".
	   By default, G++ uses type "const char *" as required by the stan-
	   dard.  Even if you use -fno-const-strings, you cannot actually mod-
	   ify the value of a string constant, unless you also use
	   -fwritable-strings.

	   This option might be removed in a future release of G++.  For maxi-
	   mum portability, you should structure your code so that it works
	   with string constants that have type "const char *".

       -fdollars-in-identifiers
	   Accept $ in identifiers.  You can also explicitly prohibit use of $
	   with the option -fno-dollars-in-identifiers.	 (GNU C allows $ by
	   default on most target systems, but there are a few exceptions.)
	   Traditional C allowed the character $ to form part of identifiers.
	   However, ISO C and C++ forbid $ in identifiers.

       -fno-elide-constructors
	   The C++ standard allows an implementation to omit creating a tempo-
	   rary which is only used to initialize another object of the same
	   type.  Specifying this option disables that optimization, and
	   forces G++ to call the copy constructor in all cases.

       -fno-enforce-eh-specs
	   Don't check for violation of exception specifications at runtime.
	   This option violates the C++ standard, but may be useful for reduc-
	   ing code size in production builds, much like defining NDEBUG.  The
	   compiler will still optimize based on the exception specifications.

       -fexternal-templates
	   Cause #pragma interface and implementation to apply to template
	   instantiation; template instances are emitted or not according to
	   the location of the template definition.

	   This option is deprecated.

       -falt-external-templates
	   Similar to -fexternal-templates, but template instances are emitted
	   or not according to the place where they are first instantiated.

	   This option is deprecated.

       -ffor-scope
       -fno-for-scope
	   If -ffor-scope is specified, the scope of variables declared in a
	   for-init-statement is limited to the for loop itself, as specified
	   by the C++ standard.	 If -fno-for-scope is specified, the scope of
	   variables declared in a for-init-statement extends to the end of
	   the enclosing scope, as was the case in old versions of G++, and
	   other (traditional) implementations of C++.

	   The default if neither flag is given to follow the standard, but to
	   allow and give a warning for old-style code that would otherwise be
	   invalid, or have different behavior.

       -fno-gnu-keywords
	   Do not recognize "typeof" as a keyword, so that code can use this
	   word as an identifier.  You can use the keyword "__typeof__"
	   instead.  -ansi implies -fno-gnu-keywords.

       -fno-implicit-templates
	   Never emit code for non-inline templates which are instantiated
	   implicitly (i.e. by use); only emit code for explicit instantia-
	   tions.

       -fno-implicit-inline-templates
	   Don't emit code for implicit instantiations of inline templates,
	   either.  The default is to handle inlines differently so that com-
	   piles with and without optimization will need the same set of
	   explicit instantiations.

       -fno-implement-inlines
	   To save space, do not emit out-of-line copies of inline functions
	   controlled by #pragma implementation.  This will cause linker
	   errors if these functions are not inlined everywhere they are
	   called.

       -fms-extensions
	   Disable pedantic warnings about constructs used in MFC, such as
	   implicit int and getting a pointer to member function via non-stan-
	   dard syntax.

       -fno-nonansi-builtins
	   Disable built-in declarations of functions that are not mandated by
	   ANSI/ISO C.	These include "ffs", "alloca", "_exit", "index",
	   "bzero", "conjf", and other related functions.

       -fno-operator-names
	   Do not treat the operator name keywords "and", "bitand", "bitor",
	   "compl", "not", "or" and "xor" as synonyms as keywords.

       -fno-optional-diags
	   Disable diagnostics that the standard says a compiler does not need
	   to issue.  Currently, the only such diagnostic issued by G++ is the
	   one for a name having multiple meanings within a class.

       -fpermissive
	   Downgrade messages about nonconformant code from errors to warn-
	   ings.  By default, G++ effectively sets -pedantic-errors without
	   -pedantic; this option reverses that.  This behavior and this
	   option are superseded by -pedantic, which works as it does for GNU
	   C.

       -frepo
	   Enable automatic template instantiation at link time.  This option
	   also implies -fno-implicit-templates.

       -fno-rtti
	   Disable generation of information about every class with virtual
	   functions for use by the C++ runtime type identification features
	   (dynamic_cast and typeid).  If you don't use those parts of the
	   language, you can save some space by using this flag.  Note that
	   exception handling uses the same information, but it will generate
	   it as needed.

       -fstats
	   Emit statistics about front-end processing at the end of the compi-
	   lation.  This information is generally only useful to the G++
	   development team.

       -ftemplate-depth-n
	   Set the maximum instantiation depth for template classes to n.  A
	   limit on the template instantiation depth is needed to detect end-
	   less recursions during template class instantiation.	 ANSI/ISO C++
	   conforming programs must not rely on a maximum depth greater than
	   17.

       -fuse-cxa-atexit
	   Register destructors for objects with static storage duration with
	   the "__cxa_atexit" function rather than the "atexit" function.
	   This option is required for fully standards-compliant handling of
	   static destructors, but will only work if your C library supports
	   "__cxa_atexit".

       -fvtable-gc
	   Emit special relocations for vtables and virtual function refer-
	   ences so that the linker can identify unused virtual functions and
	   zero out vtable slots that refer to them.  This is most useful with
	   -ffunction-sections and -Wl,--gc-sections, in order to also discard
	   the functions themselves.

	   This optimization requires GNU as and GNU ld.  Not all systems sup-
	   port this option.  -Wl,--gc-sections is ignored without -static.

       -fno-weak
	   Do not use weak symbol support, even if it is provided by the
	   linker.  By default, G++ will use weak symbols if they are avail-
	   able.  This option exists only for testing, and should not be used
	   by end-users; it will result in inferior code and has no benefits.
	   This option may be removed in a future release of G++.

       -nostdinc++
	   Do not search for header files in the standard directories specific
	   to C++, but do still search the other standard directories.	(This
	   option is used when building the C++ library.)

       In addition, these optimization, warning, and code generation options
       have meanings only for C++ programs:

       -fno-default-inline
	   Do not assume inline for functions defined inside a class scope.
	     Note that these functions will have linkage like inline
	   functions; they just won't be inlined by default.

       -Wabi (C++ only)
	   Warn when G++ generates code that is probably not compatible with
	   the vendor-neutral C++ ABI.	Although an effort has been made to
	   warn about all such cases, there are probably some cases that are
	   not warned about, even though G++ is generating incompatible code.
	   There may also be cases where warnings are emitted even though the
	   code that is generated will be compatible.

	   You should rewrite your code to avoid these warnings if you are
	   concerned about the fact that code generated by G++ may not be
	   binary compatible with code generated by other compilers.

	   The known incompatibilites at this point include:

	   o   Incorrect handling of tail-padding for bit-fields.  G++ may
	       attempt to pack data into the same byte as a base class.	 For
	       example:

		       struct A { virtual void f(); int f1 : 1; };
		       struct B : public A { int f2 : 1; };

	       In this case, G++ will place "B::f2" into the same byte
	       as"A::f1"; other compilers will not.  You can avoid this prob-
	       lem by explicitly padding "A" so that its size is a multiple of
	       the byte size on your platform; that will cause G++ and other
	       compilers to layout "B" identically.

	   o   Incorrect handling of tail-padding for virtual bases.  G++ does
	       not use tail padding when laying out virtual bases.  For exam-
	       ple:

		       struct A { virtual void f(); char c1; };
		       struct B { B(); char c2; };
		       struct C : public A, public virtual B {};

	       In this case, G++ will not place "B" into the tail-padding for
	       "A"; other compilers will.  You can avoid this problem by
	       explicitly padding "A" so that its size is a multiple of its
	       alignment (ignoring virtual base classes); that will cause G++
	       and other compilers to layout "C" identically.

       -Wctor-dtor-privacy (C++ only)
	   Warn when a class seems unusable, because all the constructors or
	   destructors in a class are private and the class has no friends or
	   public static member functions.

       -Wnon-virtual-dtor (C++ only)
	   Warn when a class declares a non-virtual destructor that should
	   probably be virtual, because it looks like the class will be used
	   polymorphically.

       -Wreorder (C++ only)
	   Warn when the order of member initializers given in the code does
	   not match the order in which they must be executed.	For instance:

		   struct A {
		     int i;
		     int j;
		     A(): j (0), i (1) { }
		   };

	   Here the compiler will warn that the member initializers for i and
	   j will be rearranged to match the declaration order of the members.

       The following -W... options are not affected by -Wall.

       -Weffc++ (C++ only)
	   Warn about violations of the following style guidelines from Scott
	   Meyers' Effective C++ book:

	   o   Item 11:	 Define a copy constructor and an assignment operator
	       for classes with dynamically allocated memory.

	   o   Item 12:	 Prefer initialization to assignment in constructors.

	   o   Item 14:	 Make destructors virtual in base classes.

	   o   Item 15:	 Have "operator=" return a reference to *this.

	   o   Item 23:	 Don't try to return a reference when you must return
	       an object.

	   and about violations of the following style guidelines from Scott
	   Meyers' More Effective C++ book:

	   o   Item 6:	Distinguish between prefix and postfix forms of incre-
	       ment and decrement operators.

	   o   Item 7:	Never overload "&&", "||", or ",".

	   If you use this option, you should be aware that the standard
	   library headers do not obey all of these guidelines; you can use
	   grep -v to filter out those warnings.

       -Wno-deprecated (C++ only)
	   Do not warn about usage of deprecated features.

       -Wno-non-template-friend (C++ only)
	   Disable warnings when non-templatized friend functions are declared
	   within a template.  With the advent of explicit template specifica-
	   tion support in G++, if the name of the friend is an unqualified-id
	   (i.e., friend foo(int)), the C++ language specification demands
	   that the friend declare or define an ordinary, nontemplate func-
	   tion.  (Section 14.5.3).  Before G++ implemented explicit specifi-
	   cation, unqualified-ids could be interpreted as a particular spe-