Compatibility of C and C++

Constructs valid in C but not in C++

• One commonly encountered difference is C being more weakly-typed regarding pointers. Specifically, C allows a void* pointer to be assigned to any pointer type without a cast, while C++ does not; this idiom appears often in C code using malloc memory allocation, or in the passing of context pointers to the POSIX pthreads API, and other frameworks involving callbacks. For example, the following is valid in C but not C++:

• C allows implicitly adding additional non-topmost cv-qualifiers where it is safe, while C++ simply gives up.
• C++ changes some C standard library functions to add additional overloaded functions with const type qualifiers, e.g. strchr returns char* in C, while C++ acts as if there were two overloaded functions const char *strchr and a char *strchr.
• C++ is also more strict in conversions to enums: ints cannot be implicitly converted to enums as in C. Also, Enumeration constants are always of type int in C, whereas they are distinct types in C++ and may have a size different from that of int. C++11 allows the programmer to use custom integer types for the values of an enum.
• In C++ a const variable must be initialized; in C this is not necessary.
• C++ compilers prohibit goto or switch from crossing an initialization, as in the following C99 code:

• While syntactically valid, a longjmp results in undefined behaviour in C++ if the jumped-over stack frames include objects with nontrivial destructors. The C++ implementation is free to define the behaviour such that destructors would be called. However, this would preclude some uses of longjmp which would otherwise be valid, such as implementation of threads or coroutines by longjmping between separate call stacks - when jumping from the lower to the upper call stack in global address space, destructors would be called for every object in the lower call stack. No such issue exists in C.
• C allows for multiple tentative definitions of a single global variable in a single translation unit, which is disallowed as an ODR violation in C++.

• C allows declaring a new type with the same name as an existing struct, union or enum which is not allowed in C++, as in C struct, union, and enum types must be indicated as such whenever the type is referenced whereas in C++ all declarations of such types carry the typedef implicitly.

• Non-prototype function declarations are not allowed in C++; they are still allowed in C, although they have been deemed obsolescent since C's original standardization in 1990. Similarly, implicit function declarations are not allowed in C++, and have been disallowed in C since 1999.
• In C, a function prototype without parameters, e.g. int foo;, implies that the parameters are unspecified. Therefore, it is legal to call such a function with one or more arguments, e.g. foo. In contrast, in C++ a function prototype without arguments means that the function takes no arguments, and calling such a function with arguments is ill-formed. In C, the correct way to declare a function that takes no arguments is by using 'void', as in int foo;, which is also valid in C++. Empty function prototypes are a deprecated feature in C99.
• In both C and C++, one can define nested struct types, but the scope is interpreted differently: in C++, a nested struct is defined only within the scope/namespace of the outer struct, whereas in C the inner struct is also defined outside the outer struct.

• Complex arithmetic using the float complex and double complex primitive data types was added in the C99 standard, via the _Complex keyword and complex convenience macro. In C++, complex arithmetic can be performed using the complex number class, but the two methods are not code-compatible.
• Variable length arrays. This feature leads to possibly non-compile time operator.

• The last member of a C99 structure type with more than one member may be a "flexible array member", which takes the syntactic form of an array with unspecified length. This serves a purpose similar to variable-length arrays, but VLAs cannot appear in type definitions, and unlike VLAs, flexible array members have no defined size. ISO C++ has no such feature. Example:

• The restrict type qualifier defined in C99 was not included in the C++03 standard, but most mainstream compilers such as the GNU Compiler Collection, Microsoft Visual C++, and Intel C++ Compiler provide similar functionality as an extension.
• Array parameter qualifiers in functions are supported in C but not C++.

• The functionality of compound literals in C is generalized to both built-in and user-defined types by the list initialization syntax of C++11, although with some syntactic and semantic differences.

• Designated initializers for structs and arrays are valid only in C, although struct designated initializers are planned for addition in C++2x:

• Functions that do not return can be annotated using a noreturn attribute in C++ whereas C uses a distinct keyword.
• C allows struct, union, and enum types to be declared in function prototypes, whereas C++ does not.

Constructs that behave differently in C and C++

• Character literals such as 'a' are of type int in C and of type char in C++, which means that sizeof 'a' will generally give different results in the two languages: in C++, it will be 1, while in C it will be sizeof. As another consequence of this type difference, in C, 'a' will always be a signed expression, regardless of whether or not char is a signed or unsigned type, whereas for C++ this is compiler implementation specific.
• C++ assigns internal linkage to namespace-scoped const variables unless they are explicitly declared extern, unlike C in which extern is the default for all file-scoped entities. Note that in practice this does not lead to silent semantic changes between identical C and C++ code but instead will lead to a compile-time or linkage error.
• In C use of inline functions requires manually adding a prototype declaration of the function using the extern keyword in exactly one translation unit to ensure a non-inlined version is linked in, whereas C++ handles this automatically. In more detail, C distinguishes two kinds of definitions of inline functions: ordinary external definitions and inline definitions. C++, on the other hand, provides only inline definitions for inline functions. In C, an inline definition is similar to an internal one, in that it can coexist in the same program with one external definition and any number of internal and inline definitions of the same function in other translation units, all of which can differ. This is a separate consideration from the linkage of the function, but not an independent one. C compilers are afforded the discretion to choose between using inline and external definitions of the same function when both are visible. C++, however, requires that if a function with external linkage is declared inline in any translation unit then it must be so declared in every translation unit where it is used, and that all the definitions of that function be identical, following the ODR. Note that static inline functions behave identically in C and C++.
• Both C99 and C++ have a boolean type bool with constants true and false, but they are defined differently. In C++, bool is a built-in type and a reserved keyword. In C99, a new keyword, _Bool, is introduced as the new boolean type. The header stdbool.h provides macros bool, true and false that are defined as _Bool, 1 and 0, respectively. Therefore, true and false have type int in C.

Linking C and C++ code

• C compilers do not name mangle symbols in the way that C++ compilers do.
• Depending on the compiler and architecture, it also may be the case that calling conventions differ between the two languages.