Contents|Index|Previous|Next
Declarations
and definitions in one header
C++ object definitions can
be quite complex. In principle, your source code will need two kinds of
things for each object that you use across more than one source file.
First, you need an interface
specification, describing its structure with type declarations and function
prototypes. Second, you need the implementation itself. It can be
tedious to maintain a separate interface description in a header file,
in parallel to the actual implementation. It is also dangerous, since separate
interface and implementation definitions may not remain parallel. With
GNU C++, you can use a single header file for both purposes.
Warning:
The mechanism to specify
this is in transition. For the nonce, you must use one of two #pragma
commands; in a future release of GNU C++, an alternative mechanism will
make these #pragma
commands unnecessary.
The header file contains the
full definitions, but is marked with #pragma
interface in
the source code. This allows the compiler to use the header file only as
an interface specification when ordinary source files incorporate it with
#include.
In the single source file where the full implementation belongs, you can
use either a naming convention or #pragma
implementation
to indicate this alternate use of the header file.
-
#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
as your source file. For example, in allclass.cc,
#pragma implementation,
by itself, is equivalent to #pragma
implementation
"allclass.h".
A files basename
was the name stripped of all leading path information and of trailing suffixes
(such as .h,
.C
or .cc).
-
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.
If you use an explicit #pragma
implementation,
it must appear in your source file before you include the affected header
files.
-
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 fileit doesnt 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 a function defined in that class is similar to an explicit extern
declarationthe 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.
Top|Contents|Index|Previous|Next