How to : Using C and C++ headers

Hi all,

I'm looking for a document which summarize the equivalence between C and C++ headers. Is there any?

So far, i've been using this technique when i couldn't find a C++ header equivalent (as far as my knolewdge allows me to do so...) :

Code:

---

extern "C" {
#include <io.h>
#include <sys/stat.h>
}

---

Thank you.

The header itself SHOULD have extern "C" in them, but I guess if they are really low-level headers, maybe no one has updated them. I would post a bug-report to the relevant maintainer (probably glibc).

--
Mats

Thanks Mat

What exactly does putting extern "C" around the #include directives do?

It tells the compiler that these function declarations are "C" rather than "C++". This is because certain concepts are every so slightly different in C and C++.

For example, in C:

Code:

---

int foo();

---

means that there is a function foo that returns an integer, and it takes an arbitrary number of arguments.

In C++ the same would mean "it takes NO arguments".

Another example is the C++ keyword "new" that is not a keyword in C. So you could have:

Code:

---

extern "C" void foo(int new, int old);

---

But without extern "C" the this would cause a compile error.

--
Mats

This will cause a compile error with extern "C", too. The linkage specification only affects linkage.

OK, here's the real reason: C names traditionally follow a very simple "name mangling" (that's the process of turning the names you use in the programming language into those used at the final linking level): just prepend an underscore. E.g. this C function:

Code:

---

void foo(void)
{
}

---

is called _foo at the binary level.

This C function:

Code:

---

int foo(int i1, int i2, float f, struct bar *pb)
{
  return i1 * i2 + (int)(f * pb->whoa);
}

---

is also called _foo at the binary level. You can't have both in the same program. Overloading is not allowed in C.

In C++, a different way had to be found. It uses a much more complicated mangling scheme that encodes the parameter types into the name. E.g. the first foo could become "_foo$v", and the second could become "_foo$iif$$bar$" or something like that. Now the functions can be distinguished.

The problem is obvious. Compile the first foo with a C compiler. Then use a C++ compiler to compile code that uses it. The C compiler generates the name "_foo", but the C++ compiler will parse the declaration and make a reference to "_foo$v". The linker comes along and can't find "_foo$v" and throws an error.

The extern "C" tells the C++ compiler to use C mangling rules.

Hmm...
So does that mean when I write C code, I should always create the headers like this:

Code:

---

#ifdef INCLUDE_GUARD_BLAH_BLAH
#define INCLUDE_GUARD_BLAH_BLAH

extern "C"
{
    /* ... */
}
#endif

---

This ancient C library I'm porting doesn't have that in the headers, but customers are using it in their C++ programs without problems. Is that by luck, or are they putting extern "C" around the headers themselves?

Actually something like:

Code:

---

#if __cplusplus
extern "C" {
#endif
...
#if __cplusplus
}
#endif

---

Otherwise it won't compile with a non-C++ compiler.

--
Mats