Why do C++ member functions defined in a class not produce duplicate symbols, whereas they do in C?

Question

C Example

bb.c:

#include "bb.h"
#include <stdio.h>

void bb() {
    printf("aa()...\n");
    aa();
}

main.c:

#include "aa.h"
#include "bb.h"

int main(int argc, const char** argv) {

    aa();
    bb();

    return 0;
}

aa.h:

#ifndef aa_h
#define aa_h

#include <stdio.h>

void aa() {
    printf("aa()...\n");
}

#endif // aa_h

bb.h:

#ifndef bb_h
#define bb_h

#include "aa.h"

void bb();

#endif // bb_h

C Result

Compiled with clang main.c bb.c:

duplicate symbol _aa in:
    /var/folders/f2/2w4c0_n519g8cd2k6xv66hc80000gn/T/main-OsFJVB.o
    /var/folders/f2/2w4c0_n519g8cd2k6xv66hc80000gn/T/bb-OkcMzn.o
ld: 1 duplicate symbol for architecture x86_64
clang: error: linker command failed with exit code 1 (use -v to see invocation)

C++ Example

b.cpp:

#include "b.hpp"

void b::do_something_else() {
    std::cout << "b::do_something_else() being called..." << std::endl;
    a a;
    a.doit();
}

main.cpp:

#include "a.hpp"
#include "b.hpp"

int main() {

    a a;
    b b;

    a.doit();
    b.do_something_else();

    return 0;
}

a.hpp:

#ifndef a_hpp
#define a_hpp

#include <iostream>

class a{
public:

    void doit() {
        std::cout << "a::doit() being called..." << std::endl;
    }

};

#endif // a_hpp

b.hpp:

#ifndef b_hpp
#define b_hpp

#include "a.hpp"

#include <iostream>

class b{
public:

    void do_something_else();

};

#endif // b_hpp

C++ Result

The above compiles fine with clang++ main.cpp b.cpp and the output to the program is:

a::doit() being called...
b::do_something_else() being called...
a::doit() being called...

Questions

1. Why does the duplicate error not occur with the C++ version?

2. Does the fact that the function void a::doit() is defined in the header file rather than a source file mean that the compiler will automatically inline the function?

Answer 1

In C++ class methods are not top-level symbols, but are effectively scoped names within their class hierarchy.

This means that you have defined in C++ two doit() methods, a::doit() and b::doit()

In C, you have attempted to define one aa() function twice.

Note that C++ will give an error too if you define the doit() method twice, within the scope of the same class.

#include <iostream>

class a {

  public:

  void doit() {
    std::cout << "hello" << std::endl;
  }

  void doit() {
    std::cout << "goodbye" << std::endl;
  }
};

leads to

ed.cpp:11:8: error: ‘void a::doit()’ cannot be overloaded
   void doit() {
        ^
ed.cpp:7:8: error: with ‘void a::doit()’
   void doit() {
        ^

Answer 2

In your C example, aa is defined twice, which violates the "one definition rule". This would be equally true if it were C++.

In your C++ example, a::doit is defined twice, but it is implicitly declared inline. Member functions defined within a class are implicitly inline per [dcl.fct.spec]/3:

A function defined within a class definition is an inline function. ...

inline functions are an exception to the one definition rule (in fact, this is the only meaning of inline required by the standard) per [basic.def.odr]/5.

There can be more than one definition of a ... inline function with external linkage (7.1.2) ... in a program, provided that each definition appears in a different translation unit, and provided the definitions satisfy the following requirements. ...

The requirements essentially boil down to a requirement that the definitions be identical in every translation unit where they appear.

Had you declared aa as inline, similar rules would have applied and your code would have compiled and worked as expected.

Answer 3

Why does the duplicate error not occur with the C++ version?

Because there is no duplication. C++ member functions are scoped by the class they are defined in. b::doit() isn't a duplicate of a::doit().

Does the fact that the function void a::doit() is defined in the header file rather than a source file mean that the compiler will automatically inline the function?

No, but it means it is possible.