Understanding what causes this multiple definition error - c++

Question

I have a base class with a pure virtual method implemented by two classes:
// base_class.hpp
class base_class {
public:
virtual std::string hello() = 0;
};
// base_implementer_1.hpp
class base_implementer1 : base_class {
public:
std::string hello();
};
// base_implementer_2.hpp
class base_implementer2 : base_class {
public:
std::string hello();
};
// base_implementer_1.cpp
std::string hello() {
return(std::string("Hello!"));
}
// base_implementer_2.cpp
std::string hello() {
return(std::string("Hola!"));
}
Note the lack of base_implementer1:: and base_implementer2:: in the implementations. This is deliberate.
By adding in the base_implementer1:: and base_implementer2:: I do not get a multiple definition error. However, leaving them off the linker complains I have two definitions of the same function (hello()).
Since these two implementations are not featured in the header files, I would think that (even though they are not correct in terms of ACTUALLY implementing hello()) they would be allowed since there's no reason you couldn't have two hello() functions in two distinct .cpp files. But this doesn't seem to be the case. Can anyone tell me what's happening in the linker to make this multiple definition error happen?

Answer 1

One-Definition-Rule defines rules for two scopes, i.e. translation unit scope and program scope.
The following rule with translation unit scope states that the same translation unit must not comprise two different definitions of the same function:
Only one definition of any variable, function, class type, enumeration
type, or template is allowed in any one translation unit (some of
these may have multiple declarations, but only one definition is
allowed).
So, if you have two different .cpp-files, than you have two different translation units, and each of them may have their own definition of hello(); ODR is not violated in the scope of a translation unit.
The following rule with program scope defines that an odr-used function must be defined exactly once in the program:
One and only one definition of every non-inline function or variable
that is odr-used (see below) is required to appear in the entire
program (including any standard and user-defined libraries). The
compiler is not required to diagnose this violation, but the behavior
of the program that violates it is undefined.
The definition of odr-used informally states that for every function that is called or which's address is taken must be defined in the program:
Informally, an object is odr-used if its address is taken, or a
reference is bound to it, and a function is odr-used if a function
call to it is made or its address is taken. If an object or a
function is odr-used, its definition must exist somewhere in the
program; a violation of that is a link-time error.
So, if more than one .cpp-file exposes an implementation of hello(), and if this function is called or referenced, then ODR from program scope is clearly violated.
If the respective function is not odr-used (i.e. called or referenced), ODR should - to my understanding - not be violated;
If a compiler complains about duplicate symbols, than this is because the program violates linkage rules (please confer also SO answer concerning "If I don't odr-use a variable"). C++11 §3.5[basic.link]/9 states:
Two names that are the same and that are declared in different scopes
shall denote the same variable, function, type, enumerator, template
or namespace if
both names have external linkage or else both names have internal linkage and are declared in the same translation unit; and ...
To avoid this, make sure that at most one implementation of hello() is exposed, and make all others static or use an unnamed namespace.
In the C programming language, static is used with global variables and functions to set their scope to the containing file, i.e. it does not expose this implementation and name clashes with other binaries are avoided.
So a reasonable suggestion would be: Make function definitions, that are solely used within a translation unit, visible only to this translation unit; and define functions that are exposed within a namespace or class in order to avoid unintended or unforeseeable name clashes / duplicate symbol problems in the linker.

Answer 2

You have two different definitions of a function named hello in two different translation units. When it comes to link time, the linker has no idea which hello function to link to.
Consider:
A.cpp
#include <string>
std::string hello() {
return "A";
}
B.cpp
#include <string>
std::string hello() {
return "B";
}
C.cpp
#include <iostream>
std::string hello();
int main() {
std::cout << hello() << '\n';
}
How could the linker possibly know which hello to call in main? It can't because the One Definition Rule has been violated.

Answer 3

You define a global function called hello in base_implementor_1.cpp. You define another global function called hello in base_implementor_2.cpp. This results in the multiple definition and the required error for violation of the ODR. Why is this a problem? If you have a 3rd source file that calls hello(), which function should be called?
If you want to define distinct functions with the same name in multiple source files, you can preface them with the static keyword
static void hello() { }
or within an anonymous namespace
namespace {
void hello() { }
}