внешняя линия

<p>я понимаю, что «встроенный» сам по себе является предложением для компилятора, и при его описании он может включать или не включать встроенную функцию, а также будет генерировать объектный код с возможностью связывания.</p><p>я думаю, что «static inline» делает то же самое (может или не может быть встроенным), но не будет создавать связываемый объектный код, когда встроен (так как никакой другой модуль не может ссылаться на него).</p><p>где "внешняя линия" вписывается в картину?</p><p>предположим, я хочу заменить макрос препроцессора встроенной функцией и требовать, чтобы эта функция была встроенной (например, потому что она использует макросы \_\_file\_\_ и \_\_line\_\_, которые должны разрешаться для вызывающей стороны, но не для этой вызываемой функции). то есть я хочу видеть ошибку компилятора или компоновщика в случае, если функция не вставлена в строку. делает ли это "extern inline"? (я предполагаю, что, если это не так, нет другого способа добиться такого поведения, кроме как придерживаться макроса.)</p><p>есть ли различия между c++ и c?</p><p>есть ли различия между разными поставщиками компиляторов и версиями?</p>

<p>в k & r c или c89 inline не был частью языка. многие компиляторы реализовали это как расширение, но не было определенной семантики относительно того, как это работает. gcc одним из первых внедрил встраивание и представил конструкции <code>inline</code>, <code>static inline</code> и <code>extern inline</code>; большинство компиляторов до c99 обычно следуют его примеру. </p><h1>gnu89:</h1><ul> <li><code>inline</code>: функция может быть встроенной (это всего лишь подсказка). версия вне линии всегда испускается и видна снаружи. следовательно, такая строка может быть определена только в одном модуле компиляции, а все остальные должны видеть ее как функцию вне строки (или вы получите дублированные символы во время ссылки).</li> <li><code>extern inline</code> не будет генерировать внешнюю версию, но может вызывать ее (которую вы, следовательно, должны определить в каком-то другом модуле компиляции. однако применяется правило одного определения; внешняя версия должна иметь такой же код, как inline, предлагаемый здесь, в случае, если компилятор вызывает это вместо.</li> <li><code>static inline</code> не будет генерировать внешне видимую внешнюю версию, хотя она может генерировать статическую версию файла. правило с одним определением не применяется, так как никогда не существует ни внешнего испускаемого символа, ни обращения к нему.</li> </ul><h1>c99 (или gnu99):</h1><ul> <li><code>inline</code>: как gnu89 "extern inline"; внешне видимая функция не испускается, но она может быть вызвана и должна существовать</li> <li><code>extern inline</code>: подобно gnu89 "inline": испускается внешне видимый код, поэтому его может использовать не более одной единицы перевода.</li> <li><code>static inline</code>: как в gnu89 "статическая строка". это единственный портативный между gnu89 и c99</li> </ul><h1>c++:</h1><p>функция, которая встроена где угодно, должна быть встроена везде с одинаковым определением. компилятор/компоновщик будет сортировать несколько экземпляров символа. не существует определения <code>static inline</code> или <code>extern inline</code>, хотя у многих компиляторов они есть (как правило, по модели gnu89).</p>

<p>я полагаю, что вы неправильно поняли \_\_file\_\_ и \_\_line\_\_ на основании этого утверждения:</p><blockquote> <p>потому что он использует \_\_file\_\_ и макросы \_\_line\_\_, которые должны разрешаться для вызывающей стороны, но не называются функция</p> </blockquote><p>есть несколько этапов компиляции, и предварительная обработка является первой. \_\_file\_\_ и \_\_line\_\_ заменяются на этом этапе. таким образом, к тому времени, когда компилятор может рассмотреть функцию для встраивания, они уже были заменены. </p>

<p>похоже, вы пытаетесь написать что-то вроде этого:</p><pre><code>inline void printlocation() { cout <<"you're at " \_\_file\_\_ ", line number" \_\_line\_\_; } { ... printlocation(); ... printlocation(); ... printlocation(); </code></pre><p>и надеясь, что вы будете печатать разные значения каждый раз. как говорит дон, вы этого не сделаете, потому что \_\_file\_\_ и \_\_line\_\_ реализованы препроцессором, а встроенные - компилятором. поэтому везде, где вы вызываете printlocation, вы получите тот же результат.</p><p><strong> only </strong>способ заставить это работать - сделать printlocation макросом. (да, я знаю...)</p><pre><code>#define print\_location {cout <<"you're at " \_\_file\_\_ ", line number" \_\_line\_\_} ... print\_location; ... print\_location; ... </code></pre>

<p>ситуация с inline, static inline и extern inline сложна, не в последнюю очередь потому, что gcc и c99 определяют немного разные значения для их поведения (и, вероятно, также c++). вы можете найти некоторую полезную и подробную информацию о том, что они делают в c <a href="http://www.greenend.org.uk/rjk/2003/03/inline.html">здесь</a> .</p>

<p>здесь вы выбираете макросы, а не встроенные функции. редкий случай, когда макросы управляют встроенными функциями. попробуйте следующее: я написал этот код "macro magic", и он должен работать! протестировано на gcc/g ++ ubuntu 10.04</p><pre><code>//(c) 2012 enthusiasticgeek (logging example for stackoverflow) #ifdef \_\_cplusplus #include <cstdio> #include <cstring> #else #include <stdio.h> #include <string.h> #endif //=========== macro magic begins ============ //trim full file path #define \_\_sfile\_\_ (strrchr(\_\_file\_\_,'/') ? strrchr(\_\_file\_\_,'/')+1 : \_\_file\_\_ ) #define stringify\_n(x) #x #define tostring\_n(x) stringify\_n(x) #define \_line (tostring\_n(\_\_line\_\_)) #define log(x, s...) printf("(%s:%s:%s)" x "\n" , \_\_sfile\_\_, \_\_func\_\_, \_line, ## s); //=========== macro magic ends ============ int main (int argc, char** argv) { log("greetings stackoverflow! - from enthusiasticgeek\n"); return 0; } </code></pre><p><strong> для нескольких файлов определите эти макросы в отдельном заголовочном файле, в том числе в каждом файле c/cc/cxx/cpp. </strong>пожалуйста, предпочитайте встроенные функции или константные идентификаторы (в зависимости от обстоятельств) макросам, где это возможно.</p>

<p>вместо ответа «что он делает?» я отвечаю «как заставить его делать то, что я хочу?» существует 5 видов встраивания, все они доступны в gnu c89, стандарте c99 и c++:</p><h2>всегда в строке, если адрес не занят</h2><p>добавьте <code>\_\_attribute\_\_((always\_inline))</code> к любому объявлению, а затем используйте один из случаев ниже для обработки возможности получения его адреса.</p><p>вы, вероятно, никогда не должны использовать это, если вам не нужна его семантика (например, чтобы повлиять на сборку определенным образом или использовать <code>alloca</code>). компилятор обычно лучше вас знает, стоит ли это того.</p><h2>встроенный и испускающий слабый символ (например, c++, он же «просто заставить его работать»)</h2><pre><code>\_\_attribute\_\_((weak)) void foo(void); inline void foo(void) { ... } </code></pre><p>обратите внимание, что это оставляет кучу копий одного и того же кода, а компоновщик выбирает один произвольно.</p><h2>встроенный, но никогда не испускает никакого символа (оставляя внешние ссылки)</h2><pre><code>\_\_attribute\_\_((gnu\_inline)) extern inline void foo(void) { ... } </code></pre><h2>выбрасывать всегда (для одного tu, для разрешения предыдущего)</h2><p>подсказка выдает слабый символ в c++, но сильный символ в любом из диалектов c:</p><pre><code>void foo(void); inline void foo(void) { ... } </code></pre><p>или вы можете сделать это без подсказки, которая испускает сильный символ на обоих языках:</p><pre><code>void foo(void) { ... } </code></pre><p>как правило, вы знаете, на каком языке tu вы используете, когда вы предоставляете определения, и, вероятно, вам не нужно много вставлять.</p><h2>встроенный и излучающий в каждом ту</h2><pre><code>static inline void foo(void) { ... } </code></pre><hr><p>для всех этих, кроме <code>static</code>, вы можете добавить объявление <code>void foo(void)</code> выше. это помогает с «лучшей практикой» написания чистых заголовков, а затем <code>#include</code>ing отдельного файла со встроенными определениями. затем, если используются строчные символы в стиле c, <code>#define</code> по-разному используется в одном выделенном tu макросе, чтобы обеспечить определения вне строки.</p><p>не забудьте <code>extern "c"</code>, если заголовок может использоваться как на c, так и на c++!</p>