Symbol already defined acting differently for class methods?

[blazb]

Why does the linker (gcc, msvc) not fail for the example below?

It complains for multiple definitions of function bar, but not for multiple definitions of function foo in class Foo.


"a.cpp"

#include <stdio.h>

void bar() {
puts("bar from a.cpp");
}

struct Foo {
char a[20];
void foo(){
puts("foo from a.cpp");
}
};

void test_b();

int main()
{
printf("sizeof(Foo) in a.cpp: %d\n", sizeof(Foo));
Foo().foo();
bar();
test_b();
return 0;
}

"b.cpp"

#include <stdio.h>

struct Foo {
char a[20];
void foo(){
puts("foo from b.cpp");
}
};

//void bar() { puts("bar from b.cpp"); } // error: symbol already defined

void test_b()
{
printf("sizeof(Foo) in b.cpp: %d\n", sizeof(Foo));
Foo().foo();
// bar();
}

[sg]

Am 22.10.2013 15:20, schrieb blazb:
> Why does the linker (gcc, msvc) not fail for the example below?
>
> It complains for multiple definitions of function bar, but not for multiple definitions of function foo in class Foo.

That's because foo is defined inside a class and therefore implicitly
inline. The one definition rule makes an exception for inline functions
(as well as function templates and static data members of class templates).

[blaz.b...@gmail.com]

Thanks for yout prompt reponse.

However, its not clear to me, why the same member function is called from call in a and call in b.

with
g++ a.cpp b.cpp
foo from a.cpp is called in all cases.

and with
g++ b.cpp a.cpp
foo from b.cpp is called in all cases.

thanks

[blaz.b...@gmail.com]

ah, nvm. This was the case only for compilation with -O0, but works ok with -O1,2 and 3.

thanks

[Tobias Müller]

<blaz.b...@gmail.com> wrote:
[cleaned up quoting mess]

Careful!
Classes an inline functions can be defined in multiple translation units,
but all definitions must be the same. Everything else is undefined behavior
and _anything_ can happen.

Tobi

[Richard Damon]

On 10/22/13 9:20 AM, blazb wrote:
> Why does the linker (gcc, msvc) not fail for the example below?
>
> It complains for multiple definitions of function bar, but not for multiple definitions of function foo in class Foo.
>
>

As has been mentioned, Foo::foo is declared (implicitly) inline. Now
inline functions may need to generate a "real" version of the function
to call when it can't be made inline for some reason, and the compiler
is obligated to make this work. Typically, the compiler will mark the
object code generated in some way so the linker will throw out the extra
copies automatically.

[blaz.b...@gmail.com]

Thanks for all replies.