Why should I ever use inline code?

by

Performance

As has been suggested in previous answers, use of the inline keyword can make code faster by inlining function calls, often at the expense of increased executables. “Inlining function calls” just means substituting the call to the target function with the actual code of the function, after filling in the arguments accordingly.

However, modern compilers are very good at inlining function calls automatically without any prompt from the user when set to high optimisation. Actually, compilers are usually better at determining what calls to inline for speed gain than humans are.

Declaring functions inline explicitly for the sake of performance gain is (almost?) always unnecessary!

Additionally, compilers can and will ignore the inline request if it suits them. Compilers will do this if a call to the function is impossible to inline (i.e. using nontrivial recursion or function pointers) but also if the function is simply too large for a meaningful performance gain.

One Definition Rule

However, declaring an inline function using the inline keyword has other effects, and may actually be necessary to satisfy the One Definition Rule (ODR): This rule in the C++ standard states that a given symbol may be declared multiple times but may only be defined once. If the link editor (= linker) encounters several identical symbol definitions, it will generate an error.

One solution to this problem is to make sure that a compilation unit doesn’t export a given symbol by giving it internal linkage by declaring it static.

However, it’s often better to mark a function inline instead. This tells the linker to merge all definitions of this function across compilation units into one definition, with one address, and shared function-static variables.

As an example, consider the following program:

// header.hpp
#ifndef HEADER_HPP
#define HEADER_HPP

#include <cmath>
#include <numeric>
#include <vector>

using vec = std::vector<double>;

/*inline*/ double mean(vec const& sample) {
    return std::accumulate(begin(sample), end(sample), 0.0) / sample.size();
}

#endif // !defined(HEADER_HPP)

// test.cpp
#include "header.hpp"

#include <iostream>
#include <iomanip>

void print_mean(vec const& sample) {
    std::cout << "Sample with x̂ = " << mean(sample) << '\n';
}

// main.cpp
#include "header.hpp"

void print_mean(vec const&); // Forward declaration.

int main() {
    vec x{4, 3, 5, 4, 5, 5, 6, 3, 8, 6, 8, 3, 1, 7};
    print_mean(x);
}

Note that both .cpp files include the header file and thus the function definition of mean. Although the file is saved with include guards against double inclusion, this will result in two definitions of the same function, albeit in different compilation units.

Now, if you try to link those two compilation units — for example using the following command:

⟩⟩⟩ g++ -std=c++11 -pedantic main.cpp test.cpp

you’ll get an error saying “duplicate symbol __Z4meanRKNSt3__16vectorIdNS_9allocatorIdEEEE” (which is the mangled name of our function mean).

If, however, you uncomment the inline modifier in front of the function definition, the code compiles and links correctly.

Function templates are a special case: they are always inline, regardless of whether they were declared that way. This doesn’t mean that the compiler will inline calls to them, but they won’t violate ODR. The same is true for member functions that are defined inside a class or struct.

More Related Contents:

  1. Measuring execution time of a function in C++
  2. Which, if any, C++ compilers do tail-recursion optimization?
  3. How to overload std::swap()
  4. Why is transposing a matrix of 512×512 much slower than transposing a matrix of 513×513?
  5. How to write a large buffer into a binary file in C++, fast?
  6. Is it better to use std::memcpy() or std::copy() in terms to performance?
  7. What does extern inline do?
  8. Why does optimisation kill this function?
  9. Is the compiler allowed to optimize out heap memory allocations?
  10. Virtual functions and performance – C++
  11. How to get IOStream to perform better?
  12. How can I know which parts in the code are never used?
  13. Is RVO (Return Value Optimization) applicable for all objects?
  14. What Does It Mean For a C++ Function To Be Inline?
  15. Does a c/c++ compiler optimize constant divisions by power-of-two value into shifts?
  16. static variables in an inlined function
  17. How to use profile guided optimizations in g++?
  18. Is optimisation level -O3 dangerous in g++?
  19. C++ error: ‘_mm_sin_ps’ was not declared in this scope
  20. Is std::vector memory freed upon a clear?
  21. When do programmers use Empty Base Optimization (EBO)
  22. std::vector reserve() and push_back() is faster than resize() and array index, why?
  23. Skip some arguments in a C++ function?
  24. Most insanely fast way to convert 9 char digits into an int or unsigned int
  25. Optimizations for pow() with const non-integer exponent?
  26. Does GCC inline C++ functions without the ‘inline’ keyword?
  27. Which is faster/preferred: memset or for loop to zero out an array of doubles?
  28. Fastest way to produce a mask with n ones starting at position i
  29. VS: unexpected optimization behavior with _BitScanReverse64 intrinsic
  30. List of common C++ Optimization Techniques [closed]

Leave a Comment