C H A P T E R 5 - Moving From C to C++

C H A P T E R 5

Moving From C to C++

This chapter describes how to move programs from C to C++.

C programs generally require little modification to compile as C++ programs. C and C++ are link compatible. You do not have to modify compiled C code to link it with C++ code. See Commercially Available Books for a list of books on the C++ language.

5.1 Reserved and Predefined Words

TABLE 5-1 shows all reserved keywords in C++ and C, plus keywords that are predefined by C++. Keywords that are reserved in C++ but not in C are shown in boldface.

TABLE 5-1 Reserved Keywords
`asm`	`do`	`if`	`return`	`typedef`
`auto`	`double`	`inline`	`short`	`typeid`
`bool`	`dynamic_cast`	`int`	`signed`	`typename`
`break`	`else`	`long`	`sizeof`	`union`
`case`	`enum`	`mutable`	`static`	`unsigned`
`catch`	`explicit`	`namespace`	`static_cast`	`using`
`char`	`export`	`new`	`struct`	`virtual`
`class`	`extern`	`operator`	`switch`	`void`
`const`	`false`	`private`	`template`	`volatile`
`const_cast`	`float`	`protected`	`this`	`wchar_t`
`continue`	`for`	`public`	`throw`	`while`
`default`	`friend`	`register`	`true`
`delete`	`goto`	`reinterpret_cast`	`try`

_ _STDC_ _ is predefined to the value 0. For example:

#include <stdio.h>

main()

    #ifdef _ _STDC_ _

        printf("yes\n");

    #else

        printf("no\n");

    #endif

    #if    _ _STDC_ _ ==0

        printf("yes\n");

    #else

        printf("no\n");

    #endif

produces:

yes

yes

The following table lists reserved words for alternate representations of certain operators and punctuators specified in the C++ standard.

TABLE 5-2 C++ Reserved Words for Operators and Punctuators
`and`	`bitor`	`not`	`or`	`xor`
`and_eq`	`compl`	`not_eq`	`or_eq`	`xor_eq`
`bitand`

5.2 Creating Generic Header Files

K&R C, ANSI C, and C++ require different header files. To make C++ header files conform to K&R C and ANSI C standards so that they are generic, use the macro _ _cplusplus to separate C++ code from C code. The macro _ _STDC_ _ is defined in both ANSI C and C++. Use this macro to separate C++ or ANSI C code from K&R C code. For more information, see the C++ Programming Guide.

Note - Early C++ compilers pre-defined the macro c_plusplus, which is no longer supported. Use __cplusplus instead.

5.3 Linking to C Functions

The compiler encodes C++ function names to allow overloading. To call a C function, or a C++ function "masquerading" as a C function, you must prevent this encoding. Do so by using the extern "C" declaration. For example:

extern "C" {

double sqrt(double); //sqrt(double) has C linkage

This linkage specification does not affect the semantics of the program using sqrt(), but simply causes the compiler to use the C naming conventions for sqrt().

Only one of a set of overloaded C++ functions can have C linkage. You can use C linkage for C++ functions that you intend to call from a C program, but you would only be able to use one instance of that function.

You cannot specify C linkage inside a function definition. Such declarations can only be done at the global scope.

5.4 Inlining Functions in Both C and C++

If an inline function definition is in source code that can be compiled by both the C compiler and the C++ compiler, then the function must comply with the following restrictions.

The inline function declaration and definition must be enclosed by a conditional extern "C" statement as shown in the following example.

#ifdef __cplusplus

extern "C" {

#endif

inline int twice( int arg ) { return arg + arg; }

#ifdef __cplusplus

#endif

The inline function's declaration and definition must meet the constraints imposed by both languages.

The semantics of the function must be the same under both compilers. See appendix D of the C++ standard for program constructs that might yield different semantics in the two languages.