In C++ what does it mean for a compiler to “inline

Question

In the wikipedia article about function objects it says such objects have performance advantages when used with for_each because the compiler can "inline" them.

I'm a bit foggy on exactly what this means in this context... or any context I'm embarrassed to say. Thanks for any help!

Answer 1

It means that the function's definition (code) may be copied and saving you from a function call (which is considered to be expensive on some systems). Think of macro replacement.

Answer 2

Inline is the process a compiler can replace a call to a function with the contents of the function itself. It requires the compiler to know the contents of the function when it's being compiled.

The compiler often can't do this if a function pointer is passed.

Answer 3

Inlining just means replacing every call to that function with the body of that function directly.

It's an optimization for small functions because it reduces the overhead of jumping to a new function and then returning.

Answer 4

The last parameter of for_each template is a functor. Functor is something that can be "called" using the () operator (possibly with arguments). By defintion, there are two distinctive kinds of functors:

1. Ordinary non-member functions are functors.
2. Objects of class type with overloaded () operator (so called function objects) are also functors.

Now, if you wanted to use an ordinary function as a functor for for_each, it would look something like the following

inline void do_something(int &i) { /* do something */ }

int main() {
  int array[10];
  std::for_each(array, array + 10, &do_something);
}

In this case the for_each template is instantiated with [deduced] arguments <int *, void (*)(int &)>. Note that the actual functor value in this case is the function pointer &do_something passed as the function argument. From the point of view of for_each function this is a run-time value. And since it is a run-time value, the calls to the functor cannot be inlined. (Just like it is in general case impossible to inline any call made through a function pointer).

But if we use a function object instead, the code might look as follows

struct do_something {
  void operator()(int &i) { /* do something */ }
}; 

int main() {
  int array[10];
  std::for_each(array, array + 10, do_something());
}

In this case the for_each template is instantiated with [deduced] arguments <int *, do_something>. The calls to the functor from inside for_each will be directed to do_something::operator(). The target for the call is known and fixed at compile-time. Since the target function is known at compile-time, the call can easily be inlined.

In the latter case we, of course, also have a run-time value passed as an argument to for_each. It is a [possibly "dummy" temporary] instance of do_something class we create when we call for_each. But this run-time value has no effect on the target for the call (unless the operator () is virtual), so it doesn't affect inlining.