Why does defining a class across cpp files not cause a linker error?

Question

If I have a file foo.cpp with the following code:

class Foo {
};

class Foo {
};

int main() {
    return 0;
}

Then naturally I get error: redefinition of 'Foo'. However, if I have foo.cpp with

class Foo {
};

int main() {
    return 0;
}

And bar.cpp with

class Foo {
};

Despite class Foo being defined twice across the program, this whole thing compiles fine.

If I had put int something; in both files in global namespace, then I would've gotten a linker error (specifically duplicate symbol), but for class definitions, this never happens.

I know function declarations such as int doIt(); can be duplicated in both cpp files, but a definition, e.g. int doIt() {} cannot be. Now in the first compiler error (with class Foo{}; twice in one cpp file), it said redefinition of foo, so class Foo{}; is a definition. Then why, unlike functions, can it be defined twice in one program?

EDIT: According to this website, named classes have external linkage. So why then is there no clash between class Foo across both cpp files?

EDIT2: According to the website linked above, not only do named classes have external linkage, but so do it's static members. Yet this all compiles fine:

foo.cpp:

class Foo {
public:
    int foo();
    static int x;
};

int Foo::foo() {
    return 5;
}

int main() {
    return 0;
}

bar.cpp:

class Foo {
public:
    int foo(int);
    static bool x;
};

int Foo::foo(int i) {
    return i * 2;
}

Not only has Foo::foo been redefined with a different signature, but Foo::x is of a different type. Both of these should have external linkage yet this code is A-ok.

This question has been discussed here, tl;dr; When classes (enums, unions, etc.) with same name are separately defined in different translation units they have internal or no linkage so no error occurs. Note, that accepted answer there is wrong and the one with more upvotes is correct. — user7860670
@ΦXocę웃Пepeúpaツ Apple LLVM version 7.3.0 (clang-703.0.31) — rcplusplus
Are you interested in the corresponding rule(s) of the standard, or the motivation for that? — chtz
@VTT You linked to the right question, pointed to the right answer, and then summarized it all wrong. — T.C.

John Smith John Smith · Accepted Answer · 2017-04-18T20:21:44

Regarding your first question, with identical definitions across multiple TU's, that's explicitly allowed by ODR, because otherwise the language would be useless.

Regarding the second question, with different definitions in different TU's, that is an ODR-violation. However, those are NDR. Your program is still malformed, and it will probably cause weird errors.

Regarding the third question, with static data members, those are declarations, not definitions. They need an unique definition, like:

TheType ClassName::VariableName;

Those are typically placed in the accompanying .cpp file.

There is an exception to that, with const static data members with inline initializers.

ODR = One Definition Rule
TU = Translation Unit
NDR = No Diagnostic Required

A note regarding NDR; some kind of errors are hard for the compiler to detect, and the standard usually do not require that the compiler issue a diagnostic (ie warning or error) in those cases. There are tools, such as CppLint, that can detect many of the errors the compiler can not. When it comes to ODR-violations, those can usually be avoided by only define types in headers.

Why does defining a class across cpp files not cause a linker error?

4 Answers