Mix C and C++ code in the same program (2023)

The C++ language provides mechanisms for mixing code compiled by compatible C and C++ compilers in the same program. You may have varying degrees of success porting this code to different platforms and compilers. This article shows you how to resolve common issues that arise when mixing C and C++ code, and highlights areas where you may encounter portability issues. In all cases, we show what is needed when using the Oracle Developer Studio C and C++ compilers.

contents

• Use compatible compilers
• Access to C code within C++ source
• Accessing C++ code from C source
• Access C++ classes from C
• Mix of IOstream and C standard I/O
• Working with function pointers
• Working with C++ exceptions
• start the program

Use compatible compilers

The first requirement for mixing code is that the C and C++ compilers used must be compatible. For example, you should define primitive types like int, float, or pointer in the same way. The Oracle Solaris OS specifies the Application Binary Interface (ABI) for C programs, which contains information about basic types and how to call functions. Any useful compiler for Oracle Solaris must follow this ABI.

The Oracle Developer Studio C and C++ compilers follow the Oracle Solaris ABI and are compatible. Third-party C compilers for Oracle Solaris often follow the ABI as well. Any C compiler that is compatible with the Oracle Developer Studio C compiler is also compatible with the Oracle Developer Studio C++ compiler.

The C runtime library used by your C compiler must also be compatible with the C++ compiler. C++ includes the standard C runtime library as a subset, although there are some differences. If the C++ compiler provides its own versions of C headers, the versions of those headers that the C compiler uses must be compatible.

The Oracle Developer Studio C and C++ compilers use compatible headers and the same C runtime library. They are fully compatible.

Access to C code within C++ source

The C++ language provides a "binding specification" that is used to declare that a function or object follows the program binding conventions for a supported language. The default shortcut for objects and functions is C++. All C++ compilers also support C bindings to some compatible C compilers.

If you need to access a function that was compiled using C binding (for example, a function compiled by the C compiler or a function written in assembler), declare the function using C binding. Although most C++ compilers do not have different bindings for C and C++ data objects, you must declare that C data objects have C bindings in C++ code. With the exception of the function pointer type, the types have no C or C++ bindings.

Declare binding specifications

Use one of the following notations to declare that an object or function has the language bindinglanguage name:

extern "language name" declaration ;extern "language name" { declaration ; Explanation; 🇧🇷

The first notation indicates that the statement (or definition) immediately following it has the link oflanguage name🇧🇷 The second notation indicates that everything between braces has the link oflanguage name, unless otherwise stated. Notice that in the second notation, after the closing brace, you don't use a semicolon.

You can nest union specifications, but braces do not create scopes. Consider the following example:

externo "C" { void f(); // enlace C externo "C++" { void g(); // enlace C++ externo "C" void h(); // Atalho C void g2(); // vincular C++ } externo "C++" void k(); // Atalho C++ void m(); // Atalho C }

All of the above functions are in the same global scope despite the nested join specifiers.

Including C headers in C++ code

If you want to use a C library with its own header definition intended for C compilers, you can include the headerexternal "C"brackets:

externo "C" { #include "header.h"}

Warning:Do not use this technique for system headers on Oracle Solaris. The Oracle Solaris headers and all headers provided with the Oracle Developer Studio C and C++ compilers are already configured for use with C and C++ compilers. You can override declarations in Oracle Solaris headers by specifying a link.

Observation:For headers other than system headers, make sure the header is written to work with C++ compilers; that is, if you already have binding specifications. In this case, you should not include the headerexternal "C"brackets.

Creating Mixed Language Headers

If you want to create a header suitable for C and C++ compilers, you can put all the declarations in it.external "C"parentheses, but the C compiler does not recognize the syntax. Every C++ compiler predefines the macro__cplusplus, then you can use this macro to protect C++ syntax extensions:

#ifdef __cplusplusextern "C" {#endif... // header body#ifdef __cplusplus} // closing parenthesis for extern "C"#endif

Adding C++ functions to C frameworks

Suppose you want to simplify the use of a C library in your C++ code. Suppose instead of a C-style accessor, you want to add virtual or non-virtual member functions, derive from the class, and so on. How can you perform this transformation and ensure that C library functions are still structure-aware? Consider using the Cstructure benefitin the following example:

struct buf { char * data; unsigned account;};void buf_clear(struct buf*);int buf_print(struct buf*); // return status, 0 means failure buf_append(struct buf*, const char*, unsigned count); // same return

You want to convert this structure to a C++ class and make it easier to use with the following changes:

extern "C" { #include "buf.h"}class mybuf { // first try -- will it work? public: mybuf() : data(0), count(0) { } void clear() { buf_clear( (buf*)más); } bool print() { return buf_print( (buf*)this ); } bool append(const char* p, sin firmar c) { return buf_append( (buf*)this, p, c ); }privado: char* data; contagem sem sinal;};

An interface forclass mybufit's more like C++ code and can be more easily integrated into an object-oriented programming style, if it works.

What happens when member functions pass thego deadpointer to thebuffunctions? Does the C++ class design match the C design? Do thatgo deadThe pointers point to theDatamember, as a pointer tobufdoes it? And if you add virtual functions?puffed?

The C++ standard makes no promises about the compatibility ofstructure benefitmiclass mybuf🇧🇷 This code without virtual functions might work, but you can't trust it. If you add virtual functions, your code will fail when using compilers that add extra data (for example, pointers to virtual tables) to the beginning of a class.

The portable solution is walkingstructure benefitstrictly solo, although you want to protect member data and only allow access via member resources. The only way to ensure C and C++ compatibility is to leave the declaration unchanged.

You can derive a C++class mybufby Cstructure benefitand pass pointers to thebufbase class forpuffedfunctions If a pointer topuffeddoes not point to the beginning of thebufdata, the C++ compiler wraps it automatically when converting amiffed*for onebuf*🇧🇷 the arrangement ofpuffedmay vary depending on the C++ compiler, but the C++ source code it handlespuffedmibufObjects work everywhere. The following example shows a portable way to add C++ and object-oriented functionality to a C framework.

extern "C" { #include "buf.h"}class mybuf : public buf { // eine portable Lösungpublic: mybuf() : data(0), count(0) { } void clear() { buf_clear(this); } bool print() { return buf_print(esto); } bool append(const char* p, sin firmar c) { return buf_append(this, p, c); }};

C++ code can be freely created and usedpuffedobjects and passes them to C code that expectsbufobjects, and everything will work together. Of course, if you add datespuffed, the C code does not know. This is a general design consideration for class hierarchies. You must also deal with creating and deletingbufmipuffedobjects constantly. It is safer to have clean C code (libre) an object if it was created by C code and you do not allow C code to remove apuffedObject.

Accessing C++ code from C source

If you declare a C++ function using C binding, it can be called from within a function compiled by the C compiler. A function declared in a C shortcut can use any of the C++ functions, but its parameters and return type must be accessible from C if you want to call them from C code. For example, if a function is declared to accept a reference to a class IOstream as a parameter, there is no (portable) way to tell a C compiler the type of the parameter. The C language has no references, models, or classes with C++ features.

Here is an example C++ function with C binding:

#include <iostream>extern "C" int print(int i, double d){ std::cout << "i = " << i << ", d = " << d;}

You can declare functionspressin a header file shared between C and C++ code:

#ifdef __cplusplusextern "C"#endifint print(int i, double d);

You can declare at most one function from an overloaded set asexternal "C"because only a C function can have a specific name. If you need to access overloaded C functions, you can write C++ wrapper functions with different names, as the following example shows:

int g(int);doble g(doble);externo "C" int g_int(int i) { return g(i); }extern "C" double g_double(doble d) { return g(d); }

Here is the example C header for the wrapper functions:

int g_int(int);doble g_doble(doble);

You also need wrapper functions to call template functions because template functions cannot be declared asexternal "C":

Vorlage<Klasse T> T foo(T t) { ... }extern "C" int foo_of_int(int t) { return foo(t); } externo "C" char* foo_of_charp(char* p) { return foo(p); }

C++ code can still call overloaded functions and template functions. C code must use wrapper functions.

Access C++ classes from C

Can you access a C++ class from C code? Can you declare a C structure that looks like a C++ class and somehow call the member functions? The answer is yes, although you may need to add some complexity to maintain portability. Also, any changes to the definition of the C++ class you access require you to revise your C code.

Suppose you have a C++ class like the following:

Class M { public: virtual int foo(int); // ...private: int i, j;};

You cannot declare a class.METROin your C code. The best you can do is pass hints to the classMETROObjects, how to handle FILE objects in C Standard I/O. you can writeexternal "C"C++ functions that access the classMETROobjects and call them from C code. Here is a C++ function to call the member functionFoo:

extern "C" int call_M_foo(M* m, int i) { return m->foo(i); }

Here is an example of C code using classesMETRO:

Structure M; // You can only specify an incomplete declaration int call_M_foo(struct M*, int); // declare the wrapper function int f(struct M* p, int j) // now you can call M::foo { return call_M_foo(p, j); 🇧🇷

Mix of IOstream and C standard I/O

You can use standard C I/O from the standard C <stdio.h> header in C++ programs because standard C I/O is part of C++.

Therefore, any consideration of mixing IOstream and standard I/O in the same program does not depend on whether the program specifically contains C code. The issues are the same for pure C++ programs that use both standard I/O and IOstreams.

Oracle Developer Studio C and C++ use the same C runtime libraries mentioned in the supported compilers section. Therefore, the Oracle Developer Studio compilers allow you to freely use standard I/O functions in C and C++ code in the same program.

The C++ standard states that you can mix standard I/O functions and IOstream functions in the same target "stream" as: B. the standard input and output streams. However, C++ implementations differ in their compatibility. Some systems require you to call themsync_to_stdio()Function explicitly before doing I/O. Implementations also differ in I/O efficiency when I/O styles are mixed for the same stream or file. In the worst case, you receive a system call per character input or output. If the program does a lot of I/O operations, the performance may not be acceptable.

It is safer to use only one of the standard I/O or IOstream styles for a given standard file or stream. Using standard I/O for one file or stream and IOstream for another file or stream does not cause problems.

Working with function pointers

A function pointer must indicate whether it points to a C function or a C++ function, since C and C++ functions may use different calling conventions. Otherwise, the compiler won't know what kind of function call code to generate. Most systems do not have different calling conventions for C and C++, but C++ allows for this possibility. Therefore, you must be careful when declaring function pointers to ensure that the types match. Consider the following example:

typedef int(*fun)(int); // line 1external "C" void foo(help); // Line 2extern "C" int g(int) // Line 3...foo( g ); // Error! // line

• Line 1 explainedpfunTarget a C++ function because it lacks a binding specifier.
• Therefore, line 2 explainsFoobe a C function that takes a pointer to a C++ function.
• Line 5 is trying to callFoowith a pointer upgram, a C function, a type mismatch.

Take care to match the association of a pointer to a function with the functions it will point to. In the corrected example below, all declarations are includedexternal "C"Parentheses to ensure types match.

outer "C" { typedef int (*pfun)(int); null foo(pfun); int g(int);}foo(g); // Now everything is fine

Function pointers have another nicety that can occasionally trip up programmers. A combination specification applies to all parameter types and the return type of a function. If you use the elaborate declaration of a function pointer in a function parameter, a binding specification on the function also applies to the function pointer. If you declare a pointer to a function with adef type, its union specificationdef typeit is not affected by its use in a function declaration. For example, consider this code:

typedef int (*pfn)(int);extern "C" void foo(pfn p) { ... } // definiciónextern "C" void foo( int (*)(int) ); // Explicación

The first two lines can appear in a program file and the third line can appear in a header where you don't want to reveal the name of the private typedef. Even though you wanted an explanationFooand to match your definition, they don't. The definition ofFootakes a pointer to a C++ function, but the declaration ofFootakes a pointer to a C function. The code declares a couple of overloaded functions. The program may not be able to create a shortcut due to an unresolved icon.

To avoid this problem, use typedefs consistently in declarations or include the typedefs in the appropriate binding specifications. For example, whenever you wantFooTo get a pointer to a C function, you can write the definition ofFooHere:

externo "C" { typedef int (*pfn)(int); foo vacío (pfn p) { ... }}

Working with C++ exceptions

propagate exceptions

What happens when you call a C++ function from a C function and the C++ function throws an exception? The C++ standard is a bit vague about whether you can expect exceptions to behave correctly, and on some systems you need to take extra precautions. In general, you should consult the user guides to see if the code works correctly.

No special precautions are needed with Oracle Developer Studio C++. The exception mechanism in Oracle Developer Studio C++ does not affect how functions are called. If a C function is active when a C++ exception is thrown, the C function will be ignored when handling the exception.

Mix exceptions with set_jmp and long_jmp

The best advice is not to uselargo_jmpin programs that contain C++ code. A C++ exception mechanism and C++ rules for destroying objects that are out of scope are likely to be violated by alargo_jmp, with unpredictable results. Some compilers incorporate exceptions andlargo_jmpto allow them to work together, but you should not rely on such behavior. Oracle Developer Studio C++ uses the sameset_jmpmilargo_jmpas a C compiler.

Some C++ experts think solargo_jmpit should not be built with exceptions, since it is difficult to specify exactly how it should behave.

and uselargo_jmpIn C code that mixes with C++, make sure that onelargo_jmpit does not go through a C++ active function. If you can't guarantee that, see if you can compile this C++ code with exceptions disabled. You may still have problems with local object destructors being ignored.

start the program

Previously, most C++ compilers required this featuremainlycompiled by the C++ compiler. This requirement is not common today and is not required by Oracle Developer Studio C++. If your C++ compiler needs to compile the main function but for some reason can't, you can rename the main C function and call it a wrapper version of C++mainly🇧🇷 For example, rename the main function from C toC_principaland write this C++ code:

externo "C" int C_main(int, char**); // no se requiere para Oracle Developer Studio C++int main(int argc, char** argv) { return C_main(argc, argv); 🇧🇷

clear,C_principalmust be declared in C code to return an int and must return an int. As mentioned above, with Oracle Developer Studio C++, you don't have to go through this hassle.

Even if your program consists primarily of C code but uses C++ libraries, you must include the C++ runtime support libraries provided with the C++ compiler in your program. The easiest and best way to do this is to useCC, the C++ compiler driver, to link. The C++ compiler driver knows which libraries to link and in what order to link them. The specific libraries may depend on the options used when compiling the C++ code.

Suppose you have C program filesmain.the,f1.o, mif2.p, and you are using a C++ libraryhelper.a🇧🇷 With Oracle Developer Studio C++, you would issue the command.

CC -or main miprog.or f1.or f2.or auxiliary.a

The required C++ runtime libraries, such as libCrun and libCstd, are linked automatically. documentation forhelper.amay require you to use additional link time options. If for some reason you can't use the C++ compiler, you can use the- A birdCC command option to get the list of commands issued by the compiler and capture them in a shell script. Since the exact commands depend on command line options, you should examine the output of- A birdevery time the command line changes.

For more information

Watch theOracle Developer Studio C/C++-Documentationfor the latest information about Oracle Developer Studio C and C++ compilers and tools, including man pages and readme files.

About the Author

Steve Clamagehas been with Sun (now Oracle) since 1994 and is currently the technical lead for the Oracle Developer Studio C++ compiler. He has been a member of the ANSI C++ Committee since its inception in 1990 and served as its chair from 1995 to 2014.