Combining C++ and C – how does #ifdef __cplusplus work?

I’m working on a project that has a lot of legacy C code. We’ve started writing in C++, with the intent to eventually convert the legacy code, as well. I’m a little confused about how the C and C++ interact. I understand that by wrapping the C code with extern "C" the C++ compiler will not mangle the C code’s names, but I’m not entirely sure how to implement this.

So, at the top of each C header file (after the include guards), we have

#ifdef __cplusplus
extern "C" {
#endif

and at the bottom, we write

#ifdef __cplusplus
}
#endif

In between the two, we have all of our includes, typedefs, and function prototypes. I have a few questions, to see if I’m understanding this correctly:

1. If I have a C++ file A.hh which
   includes a C header file B.h,
   includes another C header file C.h,
   how does this work? I think that
   when the compiler steps into B.h,
   __cplusplus will be defined, so it
   will wrap the code with extern "C"
   (and __cplusplus will not be
   defined inside this block). So,
   when it steps into C.h,
   __cplusplus will not be defined
   and the code will not be wrapped in
   extern "C". Is this correct?

2. Is there anything wrong with
   wrapping a piece of code with
   extern "C" { extern "C" { .. } }?
   What will the second extern "C"
   do?

3. We don’t put this wrapper around the .c files, just the .h files. So, what happens if a function doesn’t have a prototype? Does the compiler think that it’s a C++ function?

4. We are also using some third-party
   code which is written in C, and does
   not have this sort of wrapper around
   it. Any time I include a header
   from that library, I’ve been putting
   an extern "C" around the #include.
   Is this the right way to deal with
   that?

5. Finally, is this set up a good idea?
   Is there anything else we should do?
   We’re going to be mixing C and C++
   for the foreseeable future, and I
   want to make sure we’re covering all
   our bases.