name-mangling systems for such features are not standardized across compilers, few linkers can link object code that was produced by different compilers. Simple example A single C++ translation unit might define two functions named : int f () { return 1; } int f (int) { return 0; } void g () { int i = f(), j = f(0); } These are distinct functions, with no relation to each other apart from the name. The C++ compiler will therefore encode the type information in the symbol name, the result being something resembling: int __f_v () { return 1; } int __f_i (int) { return 0; } void __g_v () { int i = __f_v(), j = __f_i(0); } Even though its name is unique, is still mangled: name mangling applies to all C++ symbols (those not in an extern "C"{} block). Complex example The mangled symbols in this example, in the comments below the respective identifier name, are those produced by the GNU GCC 3.x compilers, according to the IA-64 (Itanium) ABI: namespace wikipedia { class article { public: std::string format (); // = _ZN9wikipedia7article6formatEv bool print_to (std::ostream&); // = _ZN9wikipedia7article8print_toERSo class wikilink { public: wikilink (std::string const& name); // = _ZN9wikipedia7article8wikilinkC1ERKSs }; }; } All mangled symbols begin with (note that an identifier beginning with an underscore followed by a capital letter is a reserved identifier in C, so conflict with user identifiers is avoided); for nested names (including both namespaces and classes), this is followed by , then a series of <length, id> pairs (the length being the length of the next identifier), and finally . For example, becomes: _ZN9wikipedia7article6formatE For functions, this is then followed by the type information; as is a function, this is simply ; hence: _ZN9wikipedia7article6formatEv For , the standard type (which is a for ) is used, which has the special alias ; a reference to this type is therefore , with the complete name for the function being: _ZN9wikipedia7article8print_toERSo How different compilers mangle the same functions There isn't a standardized scheme by which even trivial C++ identifiers are mangled, and consequently different compilers (or even different versions of the same compiler, or the same compiler on different platforms) mangle public symbols in radically different (and thus totally incompatible) ways. Consider how different C++ compilers mangle the same functions: Notes: The Compaq C++ compiler on OpenVMS VAX and Alpha (but not IA-64)