c++ emitting inline functions

Question

Let's say that I have a library which contains a public definition of function void foo();. The library calls this function internally. To get the best performance I want internal calls to be inlined. I also want to prevent external code from seeing the definition so that later I can change the implementation without breaking the ABI. Here is a piece of code:

MyLib.h:

void foo();

MyLibInlined.h:

inline void foo() { code here }

MyLib.cpp

#define inline
#include "MyLibInlined.h"

The question is does it break the ODR or is it considered bad practice?

EDIT: What if foo was a member function?

Answer 1

The question is does it break the ODR or is it considered bad practice?

It doesn't break the ODR, but it breaks the rules in [dcl.fct.spec]:

If a function with external linkage is declared inline in one translation unit, it shall be declared inline in all translation units in which it appears; no diagnostic is required.

Instead you should have a public version of the function, which is not declared inline, and have an internal version which you use inside your library:

// MyLibInlined.h
inline void foo_impl() { }

Then inside the library define foo as a call to the internal one:

// MyLib.cpp
#include "MyLibInlined.h"
void foo() { foo_impl(); }

Alternatively, if all the calls to foo() are in a single file you don't need to worry at all, just define it as a non-inline function, and let the compiler inline it in the file where the definition is visible:

// MyLib.h
void foo();

// MyLib.cpp
void foo() { code here }
// use foo ...

The inline keyword doesn't mean the function will be inlined, it means the definition is provided inline in headers. The compiler doesn't need that keyword to be able to inline it within the file where it's defined, because it can see the definition. You only need the inline keyword to allow the definition to appear in multiple translation units without causing a multiple definition error.