Using the GNU Compiler Collection (GCC): C++ Extensions

[ < ] | [ > ] |  | [ << ] | [ Up ] | [ >> ] |  |  |  |  | [Top] | [Contents] | [Index] | [ ? ]

# 7. Extensions to the C++ Language

The GNU compiler provides these extensions to the C++ language (and you can also use most of the C language extensions in your C++ programs). If you want to write code that checks whether these features are available, you can test for the GNU compiler the same way as for C programs: check for a predefined macro `__GNUC__`. You can also use `__GNUG__` to test specifically for GNU C++ (see section `Predefined Macros' in The GNU C Preprocessor).

> 7.1 When is a Volatile C++ Object Accessed? |  | What constitutes an access to a volatile object.
> 7.2 Restricting Pointer Aliasing |  | C99 restricted pointers and references.
> 7.3 Vague Linkage |  | Where G++ puts inlines, vtables and such.
> 7.4 #pragma interface and implementation |  | You can use a single C++ header file for both declarations and definitions.
> 7.5 Where's the Template? |  | Methods for ensuring that exactly one copy of each needed template instantiation is emitted.
> 7.6 Extracting the function pointer from a bound pointer to member function |  | You can extract a function pointer to the method denoted by a ``->*'` or ``.*'` expression.
> 7.7 C++-Specific Variable, Function, and Type Attributes |  | Variable, function, and type attributes for C++ only.
> 7.8 Namespace Association |  | Strong using-directives for namespace association.
> 7.9 Type Traits |  | Compiler support for type traits
> 7.10 Java Exceptions |  | Tweaking exception handling to work with Java.
> 7.11 Deprecated Features |  | Things will disappear from g++.
> 7.12 Backwards Compatibility |  | Compatibilities with earlier definitions of C++.

[ < ] | [ > ] |  | [ << ] | [ Up ] | [ >> ] |  |  |  |  | [Top] | [Contents] | [Index] | [ ? ]

## 7.1 When is a Volatile C++ Object Accessed?

The C++ standard differs from the C standard in its treatment of volatile objects. It fails to specify what constitutes a volatile access, except to say that C++ should behave in a similar manner to C with respect to volatiles, where possible. However, the different lvalueness of expressions between C and C++ complicate the behavior. G++ behaves the same as GCC for volatile access, See section Volatiles, for a description of GCC's behavior.

The C and C++ language specifications differ when an object is accessed in a void context:

    volatile int *src = somevalue;
    *src;

The C++ standard specifies that such expressions do not undergo lvalue to rvalue conversion, and that the type of the dereferenced object may be incomplete. The C++ standard does not specify explicitly that it is lvalue to rvalue conversion which is responsible for causing an access. There is reason to believe that it is, because otherwise certain simple expressions become undefined. However, because it would surprise most programmers, G++ treats dereferencing a pointer to volatile object of complete type as GCC would do for an equivalent type in C. When the object has incomplete type, G++ issues a warning; if you wish to force an error, you must force a conversion to rvalue with, for instance, a static cast.

When using a reference to volatile, G++ does not treat equivalent expressions as accesses to volatiles, but instead issues a warning that no volatile is accessed. The rationale for this is that otherwise it becomes difficult to determine where volatile access occur, and not possible to ignore the return value from functions returning volatile references. Again, if you wish to force a read, cast the reference to an rvalue.

G++ implements the same behavior as GCC does when assigning to a volatile object -- there is no reread of the assigned-to object, the assigned rvalue is reused. Note that in C++ assignment expressions are lvalues, and if used as an lvalue, the volatile object will be referred to. For instance, vref will refer to vobj, as expected, in the following example:

    volatile int vobj;
    volatile int &vref = vobj = something;

[ < ] | [ > ] |  | [ << ] | [ Up ] | [ >> ] |  |  |  |  | [Top] | [Contents] | [Index] | [ ? ]

## 7.2 Restricting Pointer Aliasing

As with the C front end, G++ understands the C99 feature of restricted pointers, specified with the `__restrict__`, or `__restrict` type qualifier. Because you cannot compile C++ by specifying the ``-std=c99'` language flag, `restrict` is not a keyword in C++.

In addition to allowing restricted pointers, you can specify restricted references, which indicate that the reference is not aliased in the local context.

    void fn (int *__restrict__ rptr, int &__restrict__ rref)
    {
      /* ... */
    }

In the body of `fn`, rptr points to an unaliased integer and rref refers to a (different) unaliased integer.

You may also specify whether a member function's this pointer is unaliased by using `__restrict__` as a member function qualifier.

    void T::fn () __restrict__
    {
      /* ... */
    }

Within the body of `T::fn`, this will have the effective definition `T *__restrict__ const this`. Notice that the interpretation of a `__restrict__` member function qualifier is different to that of `const` or `volatile` qualifier, in that it is applied to the pointer rather than the object. This is consistent with other compilers which implement restricted pointers.

As with all outermost parameter qualifiers, `__restrict__` is ignored in function definition matching. This means you only need to specify `__restrict__` in a function definition, rather than in a function prototype as well.

[ < ] | [ > ] |  | [ << ] | [ Up ] | [ >> ] |  |  |  |  | [Top] | [Contents] | [Index] | [ ? ]

## 7.3 Vague Linkage

There are several constructs in C++ which require space in the object file but are not clearly tied to a single translation unit. We say that these constructs have "vague linkage". Typically such constructs are emitted wherever they are needed, though sometimes we can be more clever.

Inline Functions
  Inline functions are typically defined in a header file which can be included in many different compilations. Hopefully they can usually be inlined, but sometimes an out-of-line copy is necessary, if the address of the function is taken or if inlining fails. In general, we emit an out-of-line copy in all translation units where one is needed. As an exception, we only emit inline virtual functions with the vtable, since it will always require a copy.

  Local static variables and string constants used in an inline function are also considered to have vague linkage, since they must be shared between all inlined and out-of-line instances of the function.

VTables
  C++ virtual functions are implemented in most compilers using a lookup table, known as a vtable. The vtable contains pointers to the virtual functions provided by a class, and each object of the class contains a pointer to its vtable (or vtables, in some multiple-inheritance situations). If the class declares any non-inline, non-pure virtual functions, the first one is chosen as the "key method" for the class, and the vtable is only emitted in the translation unit where the key method is defined.

  Note: If the chosen key method is later defined as inline, the vtable will still be emitted in every translation unit which defines it. Make sure that any inline virtuals are declared inline in the class body, even if they are not defined there.

`type_info` objects
  C++ requires information about types to be written out in order to implement ``dynamic_cast'`, ``typeid'` and exception handling. For polymorphic classes (classes with virtual functions), the ``type_info'` object is written out along with the vtable so that ``dynamic_cast'` can determine the dynamic type of a class object at runtime. For all other types, we write out the ``type_info'` object when it is used: when applying ``typeid'` to an expression, throwing an object, or referring to a type in a catch clause or exception specification.

Template Instantiations
  Most everything in this section also applies to template instantiations, but there are other options as well. See section Where's the Template?.

When used with GNU ld version 2.8 or later on an ELF system such as GNU/Linux or Solaris 2, or on Microsoft Windows, duplicate copies of these constructs will be discarded at link time. This is known as COMDAT support.

On targets that don't support COMDAT, but do support weak symbols, GCC will use them. This way one copy will override all the others, but the unused copies will still take up space in the executable.

For targets which do not support either COMDAT or weak symbols, most entities with vague linkage will be emitted as local symbols to avoid duplicate definition errors from the linker. This will not happen for local statics in inlines, however, as having multiple copies will almost certainly break things.

See section Declarations and Definitions in One Header, for another way to control placement of these constructs.

[ < ] | [ > ] |  | [ << ] | [ Up ] | [ >> ] |  |  |  |  | [Top] | [Contents] | [Index] | [ ? ]

## 7.4 #pragma interface and implementation

`#pragma interface` and `#pragma implementation` provide the user with a way of explicitly directing the compiler to emit entities with vague linkage (and debugging information) in a particular translation unit.

Note: As of GCC 2.7.2, these `#pragma`s are not useful in most cases, because of COMDAT support and the "key method" heuristic mentioned in 7.3 Vague Linkage. Using them can actually cause your program to grow due to unnecessary out-of-line copies of inline functions. Currently (3.4) the only benefit of these `#pragma`s is reduced duplication of debugging information, and that should be addressed soon on DWARF 2 targets with the use of COMDAT groups.

`#pragma interface`
`#pragma interface "subdir/objects.h"`
  Use this directive in header files that define object classes, to save space in most of the object files that use those classes. Normally, local copies of certain information (backup copies of inline member functions, debugging information, and the internal tables that implement virtual functions) must be kept in each object file that includes class definitions. You can use this pragma to avoid such duplication. When a header file containing ``#pragma interface'` is included in a compilation, this auxiliary information will not be generated (unless the main input source file itself uses ``#pragma implementation'`). Instead, the object files will contain references to be resolved at link time.

  The second form of this directive is useful for the case where you have multiple headers with the same name in different directories. If you use this form, you must specify the same string to ``#pragma implementation'`.

`#pragma implementation`
`#pragma implementation "objects.h"`
  Use this pragma in a main input file, when you want full output from included header files to be generated (and made globally visible). The included header file, in turn, should use ``#pragma interface'`. Backup copies of inline member functions, debugging information, and the internal tables used to implement virtual functions are all generated in implementation files.

  If you use ``#pragma implementation'` with no argument, it applies to an include file with the same basename(4) as your source file. For example, in ``allclass.cc'`, giving just ``#pragma implementation'` by itself is equivalent to ``#pragma implementation "allclass.h"'`.

  In versions of GNU C++ prior to 2.6.0 ``allclass.h'` was treated as an implementation file whenever you would include it from ``allclass.cc'` even if you never specified ``#pragma implementation'`. This was deemed to be more trouble than it was worth, however, and disabled.

  Use the string argument if you want a single implementation file to include code from multiple header files. (You must also use ``#include'` to include the header file; ``#pragma implementation'` only specifies how to use the file--it doesn't actually include it.)

  There is no way to split up the contents of a single header file into multiple implementation files.

``#pragma implementation'` and ``#pragma interface'` also have an effect on function inlining.

If you define a class in a header file marked with ``#pragma interface'`, the effect on an inline function defined in that class is similar to an explicit `extern` declaration--the compiler emits no code at all to define an independent version of the function. Its definition is used only for inlining with its callers.

Conversely, when you include the same header file in a main source file that declares it as ``#pragma implementation'`, the compiler emits code for the function itself; this defines a version of the function that can be found via pointers (or by callers compiled without inlining). If all calls to the function can be inlined, you can avoid emitting the function by compiling with ``-fno-implement-inlines'`. If any calls were not inlined, you will get linker errors.

[ < ] | [ > ] |  | [ << ] | [ Up ] | [ >> ] |  |  |  |  | [Top] | [Contents] | [Index] | [ ? ]

## 7.5 Where's the Template?

C++ templates are the first language feature to require more intelligence from the environment than one usually finds on a UNIX system. Somehow the compiler and linker have to make sure that each template instance occurs exactly once in the executable if it is needed, and not at all otherwise. There are two basic approaches to this problem, which are referred to as the Borland model and the Cfront model.

Borland model
  Borland C++ solved the template instantiation problem by adding the code equivalent of common blocks to their linker; the compiler emits template instances in each translation unit that uses them, and the linker collapses them together. The advantage of this model is that the linker only has to consider the object files themselves; there is no external complexity to worry about. This disadvantage is that compilation time is increased because the template code is being compiled repeatedly. Code written for this model tends to include definitions of all templates in the header file, since they must be seen to be instantiated.

Cfront model
  The AT&T C++ translator, Cfront, solved the template instantiation problem by creating the notion of a template repository, an automatically maintained place where template instances are stored. A more modern version of the repository works as follows: As individual object files are built, the compiler places any template definitions and instantiations encountered in the repository. At link time, the link wrapper adds in the objects in the repository and compiles any needed instances that were not previously emitted. The advantages of this model are more optimal compilation speed and the ability to use the system linker; to implement the Borland model a compiler vendor also needs to replace the linker. The disadvantages are vastly increased complexity, and thus potential for error; for some code this can be just as transparent, but in practice it can been very difficult to build multiple programs in one directory and one program in multiple directories. Code written for this model tends to separate definitions of non-inline member templates into a separate file, which should be compiled separately.

When used with GNU ld version 2.8 or later on an ELF system such as GNU/Linux or Solaris 2, or on Microsoft Windows, G++ supports the Borland model. On other systems, G++ implements neither automatic model.

A future version of G++ will support a hybrid model whereby the compiler will emit any instantiations for which the template definition is included in the compile, and store template definitions and instantiation context information into the object file for the rest. The link wrapper will extract that information as necessary and invoke the compiler to produce the remaining instantiations. The linker will then combine duplicate instantiations.

In the mean time, you have the following options for dealing with template instantiations:

1. Compile your template-using code with ``-frepo'`. The compiler will generate files with the extension ``.rpo'` listing all of the template instantiations used in the corresponding object files which could be instantiated there; the link wrapper, ``collect2'`, will then update the ``.rpo'` files to tell the compiler where to place those instantiations and rebuild any affected object files. The link-time overhead is negligible after the first pass, as the compiler will continue to place the instantiations in the same files.

   This is your best option for application code written for the Borland model, as it will just work. Code written for the Cfront model will need to be modified so that the template definitions are available at one or more points of instantiation; usually this is as simple as adding `#include <tmethods.cc>` to the end of each template header.

   For library code, if you want the library to provide all of the template instantiations it needs, just try to link all of its object files together; the link will fail, but cause the instantiations to be generated as a side effect. Be warned, however, that this may cause conflicts if multiple libraries try to provide the same instantiations. For greater control, use explicit instantiation as described in the next option.

2. Compile your code with ``-fno-implicit-templates'` to disable the implicit generation of template instances, and explicitly instantiate all the ones you use. This approach requires more knowledge of exactly which instances you need than do the others, but it's less mysterious and allows greater control. You can scatter the explicit instantiations throughout your program, perhaps putting them in the translation units where the instances are used or the translation units that define the templates themselves; you can put all of the explicit instantiations you need into one big file; or you can create small files like

       #include "Foo.h"
       #include "Foo.cc"

       template class Foo<int>;
       template ostream& operator <<
                       (ostream&, const Foo<int>&);

   for each of the instances you need, and create a template instantiation library from those.

   If you are using Cfront-model code, you can probably get away with not using ``-fno-implicit-templates'` when compiling files that don't ``#include'` the member template definitions.

   If you use one big file to do the instantiations, you may want to compile it without ``-fno-implicit-templates'` so you get all of the instances required by your explicit instantiations (but not by any other files) without having to specify them as well.

   G++ has extended the template instantiation syntax given in the ISO standard to allow forward declaration of explicit instantiations (with `extern`), instantiation of the compiler support data for a template class (i.e. the vtable) without instantiating any of its members (with `inline`), and instantiation of only the static data members of a template class, without the support data or member functions (with (`static`):

       extern template int max (int, int);
       inline template class Foo<int>;
       static template class Foo<int>;

3. Do nothing. Pretend G++ does implement automatic instantiation management. Code written for the Borland model will work fine, but each translation unit will contain instances of each of the templates it uses. In a large program, this can lead to an unacceptable amount of code duplication.

[ < ] | [ > ] |  | [ << ] | [ Up ] | [ >> ] |  |  |  |  | [Top] | [Contents] | [Index] | [ ? ]

## 7.6 Extracting the function pointer from a bound pointer to member function

In C++, pointer to member functions (PMFs) are implemented using a wide pointer of sorts to handle all the possible call mechanisms; the PMF needs to store information about how to adjust the ``this'` pointer, and if the function pointed to is virtual, where to find the vtable, and where in the vtable to look for the member function. If you are using PMFs in an inner loop, you should really reconsider that decision. If that is not an option, you can extract the pointer to the function that would be called for a given object/PMF pair and call it directly inside the inner loop, to save a bit of time.

Note that you will still be paying the penalty for the call through a function pointer; on most modern architectures, such a call defeats the branch prediction features of the CPU. This is also true of normal virtual function calls.

The syntax for this extension is

    extern A a;
    extern int (A::*fp)();
    typedef int (*fptr)(A *);

    fptr p = (fptr)(a.*fp);

For PMF constants (i.e. expressions of the form ``&Klasse::Member'`), no object is needed to obtain the address of the function. They can be converted to function pointers directly:

    fptr p1 = (fptr)(&A::foo);

You must specify ``-Wno-pmf-conversions'` to use this extension.

[ < ] | [ > ] |  | [ << ] | [ Up ] | [ >> ] |  |  |  |  | [Top] | [Contents] | [Index] | [ ? ]

## 7.7 C++-Specific Variable, Function, and Type Attributes

Some attributes only make sense for C++ programs.

`init_priority (priority)`

  In Standard C++, objects defined at namespace scope are guaranteed to be initialized in an order in strict accordance with that of their definitions in a given translation unit. No guarantee is made for initializations across translation units. However, GNU C++ allows users to control the order of initialization of objects defined at namespace scope with the `init_priority` attribute by specifying a relative priority, a constant integral expression currently bounded between 101 and 65535 inclusive. Lower numbers indicate a higher priority.

  In the following example, `A` would normally be created before `B`, but the `init_priority` attribute has reversed that order:

      Some_Class  A  __attribute__ ((init_priority (2000)));
      Some_Class  B  __attribute__ ((init_priority (543)));

  Note that the particular values of priority do not matter; only their relative ordering.

`java_interface`

  This type attribute informs C++ that the class is a Java interface. It may only be applied to classes declared within an `extern "Java"` block. Calls to methods declared in this interface will be dispatched using GCJ's interface table mechanism, instead of regular virtual table dispatch.

See also 7.8 Namespace Association.

[ < ] | [ > ] |  | [ << ] | [ Up ] | [ >> ] |  |  |  |  | [Top] | [Contents] | [Index] | [ ? ]

## 7.8 Namespace Association

Caution: The semantics of this extension are not fully defined. Users should refrain from using this extension as its semantics may change subtly over time. It is possible that this extension will be removed in future versions of G++.

A using-directive with `__attribute ((strong))` is stronger than a normal using-directive in two ways:

- Templates from the used namespace can be specialized and explicitly instantiated as though they were members of the using namespace.

- The using namespace is considered an associated namespace of all templates in the used namespace for purposes of argument-dependent name lookup.

The used namespace must be nested within the using namespace so that normal unqualified lookup works properly.

This is useful for composing a namespace transparently from implementation namespaces. For example:

    namespace std {
      namespace debug {
        template <class T> struct A { };
      }
      using namespace debug __attribute ((__strong__));
      template <> struct A<int> { };   // ok to specialize

      template <class T> void f (A<T>);
    }

    int main()
    {
      f (std::A<float>());             // lookup finds std::f
      f (std::A<int>());
    }

[ < ] | [ > ] |  | [ << ] | [ Up ] | [ >> ] |  |  |  |  | [Top] | [Contents] | [Index] | [ ? ]

## 7.9 Type Traits

The C++ front-end implements syntactic extensions that allow to determine at compile time various characteristics of a type (or of a pair of types).

`__has_nothrow_assign (type)`
  If `type` is const qualified or is a reference type then the trait is false. Otherwise if `__has_trivial_assign (type)` is true then the trait is true, else if `type` is a cv class or union type with copy assignment operators that are known not to throw an exception then the trait is true, else it is false. Requires: `type` shall be a complete type, (possibly cv-qualified) `void`, or an array of unknown bound.

`__has_nothrow_copy (type)`
  If `__has_trivial_copy (type)` is true then the trait is true, else if `type` is a cv class or union type with copy constructors that are known not to throw an exception then the trait is true, else it is false. Requires: `type` shall be a complete type, (possibly cv-qualified) `void`, or an array of unknown bound.

`__has_nothrow_constructor (type)`
  If `__has_trivial_constructor (type)` is true then the trait is true, else if `type` is a cv class or union type (or array thereof) with a default constructor that is known not to throw an exception then the trait is true, else it is false. Requires: `type` shall be a complete type, (possibly cv-qualified) `void`, or an array of unknown bound.

`__has_trivial_assign (type)`
  If `type` is const qualified or is a reference type then the trait is false. Otherwise if `__is_pod (type)` is true then the trait is true, else if `type` is a cv class or union type with a trivial copy assignment ([class.copy]) then the trait is true, else it is false. Requires: `type` shall be a complete type, (possibly cv-qualified) `void`, or an array of unknown bound.

`__has_trivial_copy (type)`
  If `__is_pod (type)` is true or `type` is a reference type then the trait is true, else if `type` is a cv class or union type with a trivial copy constructor ([class.copy]) then the trait is true, else it is false. Requires: `type` shall be a complete type, (possibly cv-qualified) `void`, or an array of unknown bound.

`__has_trivial_constructor (type)`
  If `__is_pod (type)` is true then the trait is true, else if `type` is a cv class or union type (or array thereof) with a trivial default constructor ([class.ctor]) then the trait is true, else it is false. Requires: `type` shall be a complete type, (possibly cv-qualified) `void`, or an array of unknown bound.

`__has_trivial_destructor (type)`
  If `__is_pod (type)` is true or `type` is a reference type then the trait is true, else if `type` is a cv class or union type (or array thereof) with a trivial destructor ([class.dtor]) then the trait is true, else it is false. Requires: `type` shall be a complete type, (possibly cv-qualified) `void`, or an array of unknown bound.

`__has_virtual_destructor (type)`
  If `type` is a class type with a virtual destructor ([class.dtor]) then the trait is true, else it is false. Requires: `type` shall be a complete type, (possibly cv-qualified) `void`, or an array of unknown bound.

`__is_abstract (type)`
  If `type` is an abstract class ([class.abstract]) then the trait is true, else it is false. Requires: `type` shall be a complete type, (possibly cv-qualified) `void`, or an array of unknown bound.

`__is_base_of (base_type, derived_type)`
  If `base_type` is a base class of `derived_type` ([class.derived]) then the trait is true, otherwise it is false. Top-level cv qualifications of `base_type` and `derived_type` are ignored. For the purposes of this trait, a class type is considered is own base. Requires: if `__is_class (base_type)` and `__is_class (derived_type)` are true and `base_type` and `derived_type` are not the same type (disregarding cv-qualifiers), `derived_type` shall be a complete type. Diagnostic is produced if this requirement is not met.

`__is_class (type)`
  If `type` is a cv class type, and not a union type ([basic.compound]) the trait is true, else it is false.

`__is_empty (type)`
  If `__is_class (type)` is false then the trait is false. Otherwise `type` is considered empty if and only if: `type` has no non-static data members, or all non-static data members, if any, are bit-fields of length 0, and `type` has no virtual members, and `type` has no virtual base classes, and `type` has no base classes `base_type` for which `__is_empty (base_type)` is false. Requires: `type` shall be a complete type, (possibly cv-qualified) `void`, or an array of unknown bound.

`__is_enum (type)`
  If `type` is a cv enumeration type ([basic.compound]) the trait is true, else it is false.

`__is_literal_type (type)`
  If `type` is a literal type ([basic.types]) the trait is true, else it is false. Requires: `type` shall be a complete type, (possibly cv-qualified) `void`, or an array of unknown bound.

`__is_pod (type)`
  If `type` is a cv POD type ([basic.types]) then the trait is true, else it is false. Requires: `type` shall be a complete type, (possibly cv-qualified) `void`, or an array of unknown bound.

`__is_polymorphic (type)`
  If `type` is a polymorphic class ([class.virtual]) then the trait is true, else it is false. Requires: `type` shall be a complete type, (possibly cv-qualified) `void`, or an array of unknown bound.

`__is_standard_layout (type)`
  If `type` is a standard-layout type ([basic.types]) the trait is true, else it is false. Requires: `type` shall be a complete type, (possibly cv-qualified) `void`, or an array of unknown bound.

`__is_trivial (type)`
  If `type` is a trivial type ([basic.types]) the trait is true, else it is false. Requires: `type` shall be a complete type, (possibly cv-qualified) `void`, or an array of unknown bound.

`__is_union (type)`
  If `type` is a cv union type ([basic.compound]) the trait is true, else it is false.

`__underlying_type (type)`
  The underlying type of `type`. Requires: `type` shall be an enumeration type ([dcl.enum]).

[ < ] | [ > ] |  | [ << ] | [ Up ] | [ >> ] |  |  |  |  | [Top] | [Contents] | [Index] | [ ? ]

## 7.10 Java Exceptions

The Java language uses a slightly different exception handling model from C++. Normally, GNU C++ will automatically detect when you are writing C++ code that uses Java exceptions, and handle them appropriately. However, if C++ code only needs to execute destructors when Java exceptions are thrown through it, GCC will guess incorrectly. Sample problematic code is:

      struct S { ~S(); };
      extern void bar();    // is written in Java, and may throw exceptions
      void foo()
      {
        S s;
        bar();
      }

The usual effect of an incorrect guess is a link failure, complaining of a missing routine called ``__gxx_personality_v0'`.

You can inform the compiler that Java exceptions are to be used in a translation unit, irrespective of what it might think, by writing ``#pragma GCC java_exceptions'` at the head of the file. This ``#pragma'` must appear before any functions that throw or catch exceptions, or run destructors when exceptions are thrown through them.

You cannot mix Java and C++ exceptions in the same translation unit. It is believed to be safe to throw a C++ exception from one file through another file compiled for the Java exception model, or vice versa, but there may be bugs in this area.

[ < ] | [ > ] |  | [ << ] | [ Up ] | [ >> ] |  |  |  |  | [Top] | [Contents] | [Index] | [ ? ]

## 7.11 Deprecated Features

In the past, the GNU C++ compiler was extended to experiment with new features, at a time when the C++ language was still evolving. Now that the C++ standard is complete, some of those features are superseded by superior alternatives. Using the old features might cause a warning in some cases that the feature will be dropped in the future. In other cases, the feature might be gone already.

While the list below is not exhaustive, it documents some of the options that are now deprecated:

`-fexternal-templates`
`-falt-external-templates`
  These are two of the many ways for G++ to implement template instantiation. See section 7.5 Where's the Template?. The C++ standard clearly defines how template definitions have to be organized across implementation units. G++ has an implicit instantiation mechanism that should work just fine for standard-conforming code.

`-fstrict-prototype`
`-fno-strict-prototype`
  Previously it was possible to use an empty prototype parameter list to indicate an unspecified number of parameters (like C), rather than no parameters, as C++ demands. This feature has been removed, except where it is required for backwards compatibility. See section 7.12 Backwards Compatibility.

G++ allows a virtual function returning ``void *'` to be overridden by one returning a different pointer type. This extension to the covariant return type rules is now deprecated and will be removed from a future version.

The G++ minimum and maximum operators (``<?'` and ``>?'`) and their compound forms (``<?='`) and ``>?='`) have been deprecated and are now removed from G++. Code using these operators should be modified to use `std::min` and `std::max` instead.

The named return value extension has been deprecated, and is now removed from G++.

The use of initializer lists with new expressions has been deprecated, and is now removed from G++.

Floating and complex non-type template parameters have been deprecated, and are now removed from G++.

The implicit typename extension has been deprecated and is now removed from G++.

The use of default arguments in function pointers, function typedefs and other places where they are not permitted by the standard is deprecated and will be removed from a future version of G++.

G++ allows floating-point literals to appear in integral constant expressions, e.g. `` enum E { e = int(2.2 * 3.7) } '` This extension is deprecated and will be removed from a future version.

G++ allows static data members of const floating-point type to be declared with an initializer in a class definition. The standard only allows initializers for static members of const integral types and const enumeration types so this extension has been deprecated and will be removed from a future version.

[ < ] | [ > ] |  | [ << ] | [ Up ] | [ >> ] |  |  |  |  | [Top] | [Contents] | [Index] | [ ? ]

## 7.12 Backwards Compatibility

Now that there is a definitive ISO standard C++, G++ has a specification to adhere to. The C++ language evolved over time, and features that used to be acceptable in previous drafts of the standard, such as the ARM [Annotated C++ Reference Manual], are no longer accepted. In order to allow compilation of C++ written to such drafts, G++ contains some backwards compatibilities. All such backwards compatibility features are liable to disappear in future versions of G++. They should be considered deprecated. See section 7.11 Deprecated Features.

`For scope`
  If a variable is declared at for scope, it used to remain in scope until the end of the scope which contained the for statement (rather than just within the for scope). G++ retains this, but issues a warning, if such a variable is accessed outside the for scope.

`Implicit C language`
  Old C system header files did not contain an `extern "C" {...}` scope to set the language. On such systems, all header files are implicitly scoped inside a C language scope. Also, an empty prototype `()` will be treated as an unspecified number of arguments, rather than no arguments, as C++ demands.

[ << ] | [ >> ] |  |  |  |  |  | [Top] | [Contents] | [Index] | [ ? ]

This document was generated by GNAT Mailserver on April, 17 2014 using texi2html