An exception to the "only one implementation" rule ?

Question

While I was reading the accepted answer of this question, I had the following question:

Typically, methods are defined in header files (.hpp or whatever), and implementation in source files (.cpp or whatever).

One of the main reasons it is bad practice to ever include a "source file" (#include <source_file.cpp>) is that its methods implementation would then be duplicated, resulting in linking errors.

When one writes:

#ifndef BRITNEYSPEARS_HPP
#define BRITNEYSPEARS_HPP

class BritneySpears
{
  public:

    BritneySpears() {}; // Here the constructor has implementation.
};

#endif /* BRITNEYSPEARS_HPP */

He is giving the implementation of the constructor (here an "empty" implementation, but still).

But why then including this header file multiple times (aka. on different source files) will not generate a "duplicate definition" error at link time ?

Answer 1

Because it is an "inline" function. Inline functions can be included from headers as many times as you like and they don't cause duplicate definition linker errors.

The compiler will also try to bring them inline so, in your example above, the compiler will try and eliminate the call to the constructor completely.

Answer 2

Functions with "inline linkage" are exceptions to the "one definition rule": you are allowed to have identical implementations of them in more than one compilation unit. Functions have inline linkage if they are declared inline or implemented inside a class definition.

Answer 3

Member functions with implementation inside the class definition are treated as inline functions. Inline functions are exempt from one definition rule.

Specifically when the linker sees two inline functions with the same signature it treats them as if it is the same function and just picks one of them. This can lead to really weird hard to detect problems.