Есть ли еще применение inline?

Я постараюсь как можно лучше объяснить свое «тайное понимание».

Здесь есть два совершенно разных понятия. Один из них - это способность компилятора заменять вызов функции, повторяя тело функции непосредственно в месте вызова. Другой - возможность определения функции более чем в одной единице перевода (= более чем в одном .cpp файле).

Первый называется встраиванием функций. Второй - это назначение ключевого слова inline. Исторически ключевое слово inline также убедительно предлагало компилятору встроить функцию, помеченную inline. Поскольку компиляторы стали лучше оптимизировать, эта функциональность уменьшилась, и использование inline в качестве предложения встроить функцию действительно устарело. Компилятор с радостью проигнорирует это и встроит что-то еще, если сочтет, что это лучшая оптимизация.

Надеюсь, мы разобрались с явным отношением inlineinlining. В текущем коде его нет.

Итак, какова реальная цель ключевого слова inline? Все просто: функция с пометкой inline может быть определена в нескольких единицах перевода без нарушения правила единого определения (ODR). Представьте себе эти два файла:

file1.cpp

int f() { return 42; }

int main()
{ return f(); }

file2.cpp

int f() { return 42; }

Эта команда:

> gcc file1.cpp file2.cpp

Выдает ошибку компоновщика с жалобой на то, что символ f определен дважды.

Однако, если вы помечаете функцию ключевым словом inline, она конкретно сообщает компилятору и компоновщику: «Ребята, убедитесь, что несколько идентичных определений этой функции не приводят к каким-либо ошибкам!»

Таким образом, будет работать следующее:

file1.cpp

inline int f() { return 42; }

int main()
{ return f(); }

file2.cpp

inline int f() { return 42; }

Компиляция и связывание этих двух файлов вместе не приведет к ошибкам компоновщика.

Обратите внимание, что определение f не обязательно должно быть дословно в файлах. Вместо этого он может поступать из файла заголовка #included:

f.hpp

inline int f() { return 42; }

file1.cpp

#include "f.hpp"

int main()
{ return f(); }

file2.cpp

#include "f.hpp"

По сути, чтобы иметь возможность записать определение функции в файл заголовка, вы должны пометить его как inline, иначе это приведет к множественным ошибкам определения.

Последний кусок головоломки: почему ключевое слово на самом деле пишется inline, когда оно не имеет никакого отношения к встраиванию? Причина проста: чтобы встроить функцию (то есть заменить ее вызов повторением ее тела на сайте вызова), компилятор должен иметь тело функции в первую очередь.

C ++ следует отдельной модели компиляции, где компилятор не имеет доступа к объектным файлам, кроме тех, которые он в настоящее время создает. Следовательно, чтобы иметь возможность встроить функцию, ее определение должно быть частью текущей единицы перевода. Если вы хотите иметь возможность встроить его в несколько единиц перевода, его определение должно быть во всех из них. Обычно это приводит к множественной ошибке определения. Поэтому, если вы поместите свою функцию в заголовок и #include ее определение повсюду, чтобы включить ее встраивание повсюду, вы должны пометить ее как inline, чтобы предотвратить множественные ошибки определения.

Обратите внимание, что даже сегодня, хотя компилятор будет встроить любую функцию, которую он считает нужной, он все еще должен иметь доступ к определению этой функции. Таким образом, хотя ключевое слово inline не требуется в качестве подсказки «пожалуйста, вставьте это», вы все равно можете обнаружить, что вам нужно использовать его, чтобы включить компилятор для выполнения встраивания, если он решит это сделать. Без него вы не сможете получить определение в единицу перевода, а без определения компилятор просто не сможет встроить функцию.

Компилятор не может. Компоновщик может. Современные методы оптимизации включают генерацию кода во время компоновки (также известную как оптимизация всей программы), при которой оптимизатор запускается для всех объектных файлов как часть процесса связывания перед фактическим связыванием. На этом этапе, конечно, доступны все определения функций, и встраивание вполне возможно без использования единственного ключевого слова inline где-либо в программе. Но такая оптимизация обычно требует больших затрат времени на сборку, особенно для крупных проектов. Имея это в виду, полагаться только на LTCG для встраивания может быть не лучшим вариантом.

Для полноты: в первой части я немного схитрил. Свойство ODR на самом деле не является свойством ключевого слова inline, а является свойством встроенных функций (что является термином языка). Правила для встроенных функций:

• Может быть определен в нескольких единицах перевода, не вызывая ошибок компоновщика
• Должен быть определен в каждой единице перевода, в которой он используется
• Все его определения должны быть идентичными для токена для токена и сущности для сущности.

Ключевое слово inline превращает функцию во встроенную функцию. Другой способ пометить функцию как встроенную - определить (а не просто объявить) ее непосредственно в определении класса. Такая функция является встроенной автоматически, даже без ключевого слова inline.

inline в настоящее время в основном является просто спецификатором внешней ссылки по причинам, которые вы указали.

Так что да, у него есть применение, но оно отличается от фактического встраивания функций. Это позволяет вам определять один и тот же метод несколько раз между модулями компиляции и правильно связывать их вместе, вместо того, чтобы получать несколько ошибок определения.

//header.h
inline void foo() {}
void goo() {}

//cpp1.cpp
#include "header.h"

//cpp2.cpp
#include "header.h"

// foo is okay, goo breaks the one definition rule (ODR)

Фактически принудительное встраивание функций зависит от компилятора, некоторые из них могут иметь поддержку через определенные attributes, pragmas, (__forceinline) или еще много чего.

Проще говоря, он позволяет вам определять функции в заголовках, не нарушая ODR ...