g++faq.texi

来自「GCC编译器源代码」· TEXI 代码 · 共 1,691 行 · 第 1/5 页

in the official distribution, due to a disagreement over design philosophies.
But you can get a patch from Cygnus to turn it on; retrieve the patch
from @file{ftp://ftp.cygnus.com/pub/g++/gcc-2.7.2-repo.gz} to patch
gcc-2.7.2 (there are also patches for earlier gcc versions).

@item
@cindex exception handling, 2.7.0

@xref{exceptions}

@item
@cindex run-time type identification
Support for Run-Time Type Identification has been added with @code{-frtti}.
This support is still in alpha; one major restriction is that any file
compiled with @code{-frtti} must include @code{<typeinfo>} (@emph{not}
@code{typeinfo.h} as the NEWS file says).
Also, all C++ code you link with (including libg++) has to be built with
@code{-frtti}, so it's still tricky to use.

@item
@cindex compiler-generated operators
Synthesis of compiler-generated constructors, destructors and
assignment operators is now deferred until the functions are used.

@item
@cindex assignment in conditional expressions
The parsing of expressions such as @code{a ? b : c = 1}
has changed from
@code{(a ? b : c) = 1} to @code{a ? b : (c = 1)}.  This is a new C/C++
incompatibility brought to you by the ANSI/ISO standards committee.

@item
@cindex new operator keywords
The operator keywords and, and_eq, bitand, bitor, compl, not, not_eq,
or, or_eq, xor and xor_eq are now supported.  Use @code{-ansi} or
@code{-foperator-names} to enable them.

@item
@cindex explicit keyword
The @code{explicit} keyword is now supported.  @code{explicit} is used to mark
constructors and type conversion operators that should not be used
implicitly.

@item
@cindex user-defined type conversion
Handling of user-defined type conversion has been improved.

@item
@cindex explicit template instantiation
Explicit instantiation of template methods is now supported.  Also,
@code{inline template class foo<int>;}
can be used to emit only the vtable
for a template class.

@item
@cindex -fcheck-new
With -fcheck-new, g++ will check the return value of all calls to
operator new, and not attempt to modify a returned null pointer.

@item
collect2 now demangles linker output, and c++filt has become part of
the gcc distribution.

@item
Improvements to template instantiation: only members actually used
are instantiated.  (Actually this is not quite true: some inline
templates that are not successfully inlined may be expanded even
though they are not needed).

@end itemize

@node libstdc++, new work, version 2.7.x, evolution
@section The GNU Standard C++ Library

The GNU Standard C++ Library (also called the ``GNU ANSI C++ Library''
in places in the code) is not libg++, though it is included in the
libg++ distribution.  Rather, it contains classes and functions
required by the ANSI/ISO standard.  The copyright conditions are the
same as those for for the iostreams classes; the LGPL is not used
(@pxref{legalities}).

This library, libstdc++, is in the libg++ distribution in versions 2.6.2
and later.  It requires at least gcc 2.6.3 to build the libg++-2.6.2
version; use at least gcc 2.7.0 to build the libg++ 2.7.0 version.  It
contains a hacked-up version of HP's implementation of the Standard
Template Library (@pxref{Standard Template Library}).  I've
successfully used this Standard Template Library version to build
a number of the demos you'll see on various web pages.

As of version 2.7.0, the streams classes are now in libstdc++ instead of
libg++, and libiostream is being phased out (don't use it).  The g++
program searches this library.

The maintainers of libg++ have de-emphasized work on the older libg++ classes
in favor of enhancing libstdc++ to cover the full language, so while libg++
will always be available, enhancements to it should not be expected.

@node new work, egcs, libstdc++, evolution
@section What can we expect in future gcc releases?

A great deal of work has gone into enhancements to the C++ front end, as well
as to other aspects of the compiler.

The next major release(s) of gcc/g++ can be expected to have the following
features:

@itemize @bullet
@cindex new template implementation
@item
A completely new template implementation, much closer to the draft
standard.  Limitations in 2.7.2.x concerning inlining template functions
will be eliminated.  Static template data members, template class member
functions, partial specification, and default template arguments will be
supported.  An instantiation method resembling that used in Borland C++
(instantiating functions possibly in multiple .o files and using weak
symbols to link correctly) will be provided, in addition to other
options.  The SGI version of STL will be shipped with libstdc++ and will
compile unchanged.

@item
@cindex new exception implementation
Exception handling has been re-worked; exceptions will work together
with optimization.
Actually, there are two separate implementations: one based on setjmp/longjmp
and designed to be highly portable, and one designed to be more efficient but
requiring more processor-specific support (getting exceptions right has proven
to be extremely difficult and has been the chief obstacle to getting a new
release out).

@item
@cindex RTTI
RTTI has been re-done to work correctly and is on by default.

@item
@cindex overloading
Overloading has been re-worked to conform to the latest draft of the
standard.
@end itemize

Features that are still missing include namespaces and templates as
template arguments.

@node egcs, When?, new work, evolution
@section What's this I hear about egcs?

The egcs effort is a new effort to merge several threads of gcc
development and to provide a faster development process.
For more information see @file{http://www.cygnus.com/egcs/}.

@node When?,  , egcs, evolution
@section OK, when can I get this stuff?

The FSF has a policy of never announcing release dates in advance.
I'm sure this is frustrating to a lot of people, since it's taken
so long, and this frustration was one of the reasons the egcs effort
was created.  An egcs release should be expected to occur in the
very near future.   [ More on this next time ].

@node User Problems, legalities, evolution, Top
@chapter User Problems

@menu
* missing virtual table::       
* for scope::                   
* const constructor::           
* unused parameter warnings::   
* jump crosses initialization::  
* Demangler::                   
* static data members::         
* internal compiler error::     
* bug reports::                 
* porting to g++::              
* name mangling::               
* problems linking with other libraries::  
* documentation::               
* templates::                   
* undefined templates::         
* redundant templates::         
* Standard Template Library::   
* STL and string::              
* exceptions::                  
* namespaces::                  
* agreement with standards::    
* compiling standard libraries::  
* debugging on SVR4 systems::   
* debugging problems on Solaris::  
* X11 conflicts with libg++::   
* assignment to streams::       
@end menu

@node missing virtual table, for scope, User Problems, User Problems
@section Linker complains about missing virtual table

``I'm getting a message complaining about an undefined virtual table.  Is
this a compiler bug?''

(On platforms that run neither collect nor the GNU linker, like Solaris,
you may see an odd undefined symbol like "_vt.3foo", where foo is a
class name).

This is probably because you are missing a definition for the first
(non-inline) virtual function of the class.  Since gcc-2.7.0, g++ uses
a trick borrowed from cfront: the .o file containing the definition for
the first non-inline virtual function for the class will also contain
the virtual function table.

@node for scope, const constructor, missing virtual table, User Problems
@section gcc-2.7.0 breaks declarations in "for" statements!

@cindex declarations in for statements
@cindex for statements: declarations

gcc-2.7.0 implements the new ANSI/ISO rule on the scope of variables
declared in for loops.

@example
for (int i = 1; i <= 10; i++) @{
        // do something here
@}
foo(i);
@end example

In the above example, most existing C++ compilers would pass the
value 11 to the function @code{foo}.  In gcc 2.7 and in the ANSI/ISO
working paper, the scope of @code{i} is only the for loop body, so
this is an error.  So that old code can be compiled, the new gcc has
a flag @code{-fno-for-scope} that causes the old rule to be used.
@cindex -fno-for-scope

As of 2.7.1, the compiler attempts to issue warnings about code that
has different meanings under the two sets of rules, but the code is
not perfect: the intent was that code that has valid, but different,
meanings under the ARM rules and the working paper rules would give
warnings but have the new behavior, and this doesn't seem to happen.

The @code{-ffor-scope} flag under 2.7.1 and 2.7.2 gives the 2.7.0 behavior.

@node const constructor, unused parameter warnings, for scope, User Problems
@section g++ seems to want a const constructor.  What's that?

gcc-2.7.1 introduced a bug that causes the compiler to ask for a
const constructor (there's no such thing in C++) in certain situations
where a const object appears in a template class.  Most cases have been
fixed in gcc-2.7.2, but unfortunately not all.  Still, if you're running
gcc-2.7.1 and have this problem, upgrade to 2.7.2; it is a vast improvement.

@cindex ObjectSpace<STL>

The default constructor for the template @code{pair} in ObjectSpace's
implementation of STL triggers the bug in one place, for gcc 2.7.2.  If
you're using ObjectSpace<STL> and having this problem, simply
change the default constructor from

@example
os_pair () : first (T1 ()), second (T2 ()) @{@}
@end example

to just

@example
os_pair () @{@}
@end example

Once this is done, ObjectSpace<STL> works fairly well.

@node unused parameter warnings, jump crosses initialization, const constructor, User Problems
@section How to silence ``unused parameter'' warnings

@cindex -Wall
@cindex -Wunused

``When I use @code{-Wall} (or @code{-Wunused}), g++ warns about
unused parameters.  But the parameters have to be there, for use
in derived class functions.  How do I get g++ to stop complaining?''

The answer is to simply omit the names of the unused parameters when
defining the function.  This makes clear, both to g++ and to readers
of your code, that the parameter is unused.  For example:

@example
int Foo::bar(int arg) @{ return 0; @}
@end example

will give a warning for the unused parameter @code{arg}.  To suppress
the warning write

@example
int Foo::bar(int) @{ return 0; @}
@end example

@node jump crosses initialization, Demangler, unused parameter warnings, User Problems
@section g++ objects to a declaration in a case statement

``The compiler objects to my declaring a variable in one of the branches
of a case statement.  Earlier versions used to accept this code.  Why?''

The draft standard does not allow a goto or a jump to a case label to
skip over an initialization of a variable or a class object.  For
example:

@example
switch ( i ) @{
  case 1:
    Object obj(0);
        ...
    break;
  case 2:
	...
    break;
@}    
@end example

The reason is that @code{obj} is also in scope in the rest of the switch
statement.

As of version 2.7.0, the compiler will object that the jump to the
second case level crosses the initialization of @code{obj}.  Older
compiler versions would object only if class Object has a destructor.
In either case, the solution is to add a set of curly braces around
the case branch:

@example
  case 1:
    @{
       Object obj(0);
        ...
       break;
    @}
@end example

@node Demangler, static data members, jump crosses initialization, User Problems
@section Where can I find a demangler?

@cindex demangler program
A g++-compatible demangler named @code{c++filt} can be found in the
@file{binutils} distribution.  This distribution (which also contains
the GNU linker) can be found at any GNU archive site.

As of version 2.7.0, @code{c++filt} is included with gcc and is