When is "extern C " necessary in c++ in windows?

Question

As we know that we can use c functions directly in c++, when is extern "C" necessary then?

Answer 1

It's necessary when a C++ function must be called by C code rather than C++ code.

Basically, when you want your C++ library to be backwards compatible.

Answer 2

If your function is implemented in a .c file, the .cpp files will need the extern "C" reference, or else they'd reference a mangled C++-style function name, and the link would fail.

It's also handy for exporting functions from DLLs so that they are exported with a non-mangled name.

Answer 3

Because the function signatures generated by C and C++ compilers differ -- this sets up the C convention for C function even when using C++.

Answer 4

As you know that c++ support function overloading, which define the same function or method many times with different parameters. To do this, the compiler has to add some part of symbols for each one ... for example, the compiler will change the function name foo in the following declaration from

void foo(int f,char c);

to

foo@i&c

Unfortunately, C doesn't support this. All function names remain the same after compiling it. So, to call a c++ function from c, you have to know the exact name after the modification and I think it's hard and different from a compiler to another.

to work around this and be able call c++ function from c and stop the compiler from changing the names you have to use this keyword like

extern "C" { 
void foo(int f,char c);
}

that's it !!!

Answer 5

There are two rather different uses for extern "C". One is to define a function in C++ that you should be able to call from C. I.e., you're writing code in C++, but it needs to interface with C code. In this case, you define the function as extern "C":

extern "C" {
    int c_callable_func1() {}
    int c_callable_func2() {}
}

When you do this, the interface of those functions must follow pretty much the same rules as they would in C as well (e.g., you can't overload the functions or use default values for any parameters).

The other (considerably more common) situation is that you have code written in C that you want to be able to call from C++. In this case, the function definitions remain exactly as before, but the functions need to be declared/prototyped as extern "C". In a typical case, you want to use a single header that can be #included in either a C or C++ file, so the structure looks something like this:

// myheader.h
#ifndef MY_HEADER_H_INCLUDED_
#define MY_HEADER_H_INCLUDED_

#ifdef __cplusplus
extern "C" {
#endif

    int func1(void);
    void func2(int);

#ifdef __cplusplus
}
#endif

#endif

So, a C++ compiler will see function declarations (and typedefs, etc.) surrounded by an extern "C" block, while a C compiler will see prototypes, not surrounded by something it doesn't recognize.

In the first case (C++ functions callable from C), you'll normally structure the header roughly the same way, so you can also call those functions from C++ if necessary (but at the interface, you still lose all extra features of C++ like function overloading).