C++ helps you attain information hiding in your programs. You just specify the interface in one file (sorry, "translation unit") with a .h suffix; that's the file you #include. The implementation goes in another file with a .cpp, .cxx, .C, .c++ or .cc suffix (see "C++: standard names for source files" for more information on how to pick the correct suffix for your C++ source code). That way, the application programmer using the library doesn't need to see the actual code implementing the interface. This is a Good Thing, and C++ is all for such Good Things.
C++ also supports parametrised programming through function templates. You can write just one function which looks like this (in practice, the standard library defines std::swap, which does the same:
template<typename T> void swap(T& a, T& b) {
T c = a;
a = b;
b = c;
}
which can swap 2 variables of
any type, and has a convenient interface. This is really cool.
C++ programmers really like this example. I mean, REALLY. "Let's see you write that in C," they sneer, a grin wrapping itself around their ugly little faces.
(Note: when I wrote this, I hadn't known that this example appears in the swap node to show just how groovy C++ templates really are. Ooops.)
Well, OK, but first let's see them write it in C++. I mean, you'd think that the above is code, so it goes in the implementation file, and the interface file just contains a line
template<typename T> void swap(T& a, T& b);
Well, you'd think that, but you'd also be
wrong. You see,
separate compilation doesn't apply to template functions. They go in the
header file. Reduced to being glorified
#define macros, the
compiler has to see them separately in each source file (oops, sorry, "translation unit").
The same goes for class templates, too: you can use them, but you end up implementing the entire class in the header file. So much for information hiding.
At this point, the dedicated C++-head starts sweating. "But wait!" they scream, as you lean in for the kill, "the new export keyword solves all that!" New, it is. And it may well solve everything. I don't know, and neither do they. Because there are serious issues with implementing it. Doing it properly probably requires the linker to be really smart, maybe even to be able to call back to the compiler. So nobody's ever actually written code with the legendary export keyword...