что означает "статический" в c?

<p>я видел слово <code>static</code>, используемое в разных местах кода c; это как статическая функция/класс в c # (где реализация разделяется между объектами)? </p>

<ol> <li>статическая переменная внутри функции сохраняет свое значение между вызовами.</li> <li>статическая глобальная переменная или функция «видна» только в файле, в котором она объявлена</li> </ol><p>(1) является более иностранной темой, если вы новичок, так что вот пример:</p><pre><code>#include <stdio.h> void foo() { int a = 10; static int sa = 10; a += 5; sa += 5; printf("a = %d, sa = %d\n", a, sa); } int main() { int i; for (i = 0; i < 10; ++i) foo(); } </code></pre><p>это печатает:</p><pre><code>a = 15, sa = 15 a = 15, sa = 20 a = 15, sa = 25 a = 15, sa = 30 a = 15, sa = 35 a = 15, sa = 40 a = 15, sa = 45 a = 15, sa = 50 a = 15, sa = 55 a = 15, sa = 60 </code></pre><p>это полезно в тех случаях, когда функция должна сохранять некоторое состояние между вызовами, и вы не хотите использовать глобальные переменные. остерегайтесь, однако, эту функцию следует использовать очень экономно - она делает ваш код не поточно-ориентированным и трудным для понимания.</p><p>(2) широко используется как функция «контроля доступа». если у вас есть файл .c, реализующий некоторые функции, он обычно предоставляет пользователям только несколько «публичных» функций. остальные его функции должны быть сделаны <code>static</code>, чтобы пользователь не мог получить к ним доступ. это инкапсуляция, хорошая практика.</p><p>цитирование <a href="http://en.wikipedia.org/wiki/static\_variable">википедия</a> :</p><blockquote> <p>на языке программирования c, статический используется с глобальными переменными и функции, чтобы установить их область содержащий файл. в локальных переменных static используется для хранения переменной в статически выделенной памяти вместо автоматически выделенного объем памяти. пока языка нет диктовать реализацию любого тип памяти, статически выделенный память обычно резервируется в данных сегмент программы при компиляции время, а автоматически выделенная память обычно реализован как транзитный стек вызовов.</p> </blockquote><p>смотрите <a href="http://os.camden.rutgers.edu/c\_resources/c\_manual/c/concept/storage\_class.html">здесь</a> и <a href="http://os.camden.rutgers.edu/c\_resources/c\_manual/c/syntax/static.htm">здесь</a> для более подробной информации.</p><p>и чтобы ответить на ваш второй вопрос, это не так, как в c #.</p><p>однако в c++ <code>static</code> также используется для определения атрибутов класса (общих для всех объектов одного класса) и методов. в си нет классов, поэтому эта особенность неактуальна.</p>

<p>здесь есть еще одно использование, которое не рассматривается, и оно является частью объявления типа массива в качестве аргумента функции:</p><pre><code>int somefunction(char arg[static 10]) { ... } </code></pre><p>в этом контексте это указывает, что аргументы, передаваемые этой функции, должны быть массивом типа <code>char</code>, содержащим не менее 10 элементов. для получения дополнительной информации см. мой вопрос <a href="https://stackoverflow.com/questions/3430315/purpose-of-static-keyword-in-array-parameter-of-function">здесь</a> .</p>

<p>краткий ответ ...<strong> это зависит. </strong></p><ol> <li><p>статические определенные локальные переменные не теряют своего значения между вызовами функций. другими словами, они являются глобальными переменными, но ограничены локальной функцией, в которой они определены.</p></li> <li><p>статические глобальные переменные не видны вне файла c, в котором они определены.</p></li> <li><p>статические функции не видны вне файла c, в котором они определены.</p></li> </ol>

<p><strong>пример области действия нескольких файлов</strong></p><p>здесь я иллюстрирую, как static влияет на объем определений функций в нескольких файлах.</p><p>a.c</p><pre><code>#include <stdio.h> /* undefined behavior: already defined in main. binutils 2.24 gives an error and refuses to link. https://stackoverflow.com/questions/27667277/why-does-borland-compile-with-multiple-definitions-of-same-object-in-different-c */ /*int i = 0;*/ /* works in gcc as an extension: https://stackoverflow.com/a/3692486/895245 */ /*int i;*/ /* ok: extern. will use the one in main. */ extern int i; /* ok: only visible to this file. */ static int si = 0; void a() { i++; si++; puts("a()"); printf("i = %d\n", i); printf("si = %d\n", si); puts(""); } </code></pre><p>main.c</p><pre><code>#include <stdio.h> int i = 0; static int si = 0; void a(); void m() { i++; si++; puts("m()"); printf("i = %d\n", i); printf("si = %d\n", si); puts(""); } int main() { m(); m(); a(); a(); return 0; } </code></pre><p> <a href="https://github.com/cirosantilli/cpp-cheat/tree/b075d2d54c62c684cd03c17bb39fa1d6a8fd9bd6/static">github вверх по течению</a> .</p><p>скомпилируйте и запустите:</p><pre><code>gcc -c a.c -o a.o gcc -c main.c -o main.o gcc -o main main.o a.o </code></pre><p>результат:</p><pre><code>m() i = 1 si = 1 m() i = 2 si = 2 a() i = 3 si = 1 a() i = 4 si = 2 </code></pre><p><strong>интерпретация</strong></p><ul> <li>для <code>si</code> есть две отдельные переменные, по одной для каждого файла</li> <li>есть одна переменная общего доступа для <code>i</code></li> </ul><p>как обычно, чем меньше область действия, тем лучше, поэтому всегда объявляйте переменные <code>static</code>, если можете.</p><p>в программировании на c файлы часто используются для представления «классов», а переменные <code>static</code> представляют частные статические члены класса.</p><p><strong>что говорят об этом стандарты</strong></p><p> <a href="http://www.open-std.org/jtc1/sc22/wg14/www/docs/n1256.pdf">c99 n1256 черновик</a> 6.7.1 «спецификаторы класса хранения» говорят, что <code>static</code> является «спецификатором класса хранения».</p><p>6.2.2/3 «связи идентификаторов» говорит, что <code>static</code> подразумевает <code>internal linkage</code>:</p><blockquote> <p>если объявление идентификатора области файла для объекта или функции содержит статический спецификатор класса хранения, идентификатор имеет внутреннюю связь.</p> </blockquote><p>и 6.2.2/2 говорит, что <code>internal linkage</code> ведет себя так, как в нашем примере:</p><blockquote> <p>в наборе единиц перевода и библиотек, составляющих целую программу, каждое объявление определенного идентификатора с внешней связью обозначает один и тот же объект или функцию. в пределах одной единицы перевода каждое объявление идентификатора с внутренней связью обозначает один и тот же объект или функцию. </p> </blockquote><p>где блок перевода - это исходный файл после предварительной обработки.</p><p><strong>как gcc реализует это для elf (linux)?</strong></p><p>с привязкой <code>stb\_local</code>.</p><p>если мы скомпилируем:</p><pre><code>int i = 0; static int si = 0; </code></pre><p>и разберите таблицу символов с помощью:</p><pre><code>readelf -s main.o </code></pre><p>вывод содержит:</p><pre><code>num: value size type bind vis ndx name 5: 0000000000000004 4 object local default 4 si 10: 0000000000000000 4 object global default 4 i </code></pre><p>таким образом, связывание - единственное существенное различие между ними. <code>value</code> - это просто их смещение в секции <code>.bss</code>, поэтому мы ожидаем, что оно будет другим.</p><p><code>stb\_local</code> задокументирован в спецификации elf по адресу <a href="http://www.sco.com/developers/gabi/2003-12-17/ch4.symtab.html">http://www.sco.com/developers/gabi/2003-12-17/ch4.symtab.html</a> :</p><blockquote> <p>stb\_local локальные символы не видны за пределами объектного файла, содержащего их определение. локальные символы одного и того же имени могут существовать в нескольких файлах, не мешая друг другу</p> </blockquote><p>что делает его идеальным выбором для представления <code>static</code>.</p><p>переменные без статики - это <code>stb\_global</code>, а в спецификации говорится:</p><blockquote> <p>когда редактор ссылок объединяет несколько перемещаемых объектных файлов, он не позволяет использовать несколько определений символов stb\_global с одним и тем же именем. </p> </blockquote><p>что согласуется с ошибками ссылок в нескольких нестатических определениях.</p><p>если мы запускаем оптимизацию с помощью <code>-o3</code>, символ <code>si</code> полностью удаляется из таблицы символов: его нельзя использовать извне. todo зачем вообще хранить статические переменные в таблице символов, когда нет оптимизации? могут ли они быть использованы для чего-либо? возможно для отладки.</p><p><strong>смотрите также</strong></p><ul> <li>аналогично для функций <code>static</code>: <a href="https://stackoverflow.com/a/30319812/895245">https://stackoverflow.com/a/30319812/895245</a> </li> <li>сравните <code>static</code> с <code>extern</code>, что говорит об обратном: <a href="https://stackoverflow.com/questions/1433204/how-do-i-use-extern-to-share-variables-between-source-files-in-c">как мне использовать extern для обмена переменными между исходными файлами?</a> </li> </ul><p><strong>c++ анонимные пространства имен</strong></p><p>в c++ вы можете захотеть использовать анонимные пространства имен вместо статических, что дает аналогичный эффект, но дополнительно скрывает определения типов: <a href="https://stackoverflow.com/questions/154469/unnamed-anonymous-namespaces-vs-static-functions">безымянный/анонимные пространства имен против статических функций</a> </p>

<p>это зависит:</p><pre><code>int foo() { static int x; return ++x; } </code></pre><p>функция вернет 1, 2, 3 и т.д. --- переменная не находится в стеке.</p><h3>a.c:</h3><pre><code>static int foo() { } </code></pre><p>это означает, что эта функция имеет область действия только в этом файле. таким образом, a.c и b.c могут иметь разные <code>foo()</code>s, и foo не предоставляется совместно используемым объектам. поэтому, если вы определили foo в a.c, вы не сможете получить к нему доступ из <code>b.c</code> или из других мест.</p><p>в большинстве библиотек c все «частные» функции являются статическими, а большинство «открытых» - нет.</p>

<p>люди продолжают говорить, что «статический» в си имеет два значения. я предлагаю альтернативный способ просмотра, который дает единственное значение:</p><ul> <li>применение «статического» к элементу заставляет этот элемент иметь два свойства: (a) он не виден за пределами текущей области; (б) он постоянен.</li> </ul><p>причина, по которой он, кажется, имеет два значения, состоит в том, что в c каждый элемент, к которому может быть применен «статический»<em> уже имеет одно из этих двух свойств </em>, таким образом,<em> кажется </em>как будто это конкретное использование включает только другой.</p><p>например, рассмотрим переменные. переменные, объявленные вне функций, уже имеют постоянство (в сегменте данных), поэтому применение «статического» может только сделать их невидимыми вне текущей области (модуля компиляции). напротив, переменные, объявленные внутри функций, уже не видны вне текущей области (функции), поэтому применение «статического» может только сделать их постоянными.</p><p>применение «статического» к функциям аналогично применению его к глобальным переменным - код обязательно является постоянным (по крайней мере, внутри языка), поэтому можно изменять только видимость.</p><p><em> примечание: эти комментарии относятся только к c. в c++ применение «static» к методам класса действительно дает ключевое слово в другом значении. аналогично для расширения аргумента массива c99. </em></p>

<p>из википедии:</p><blockquote> <p><em>в языке программирования c<strong> static </strong>используется с глобальными переменными и функциями, чтобы установить их область действия для содержащегося файла. в локальных переменных static используется для хранения переменной в статически выделенной памяти вместо автоматически выделенной памяти. хотя язык не диктует реализацию памяти любого типа, статически распределенная память обычно резервируется в сегменте данных программы во время компиляции, в то время как автоматически распределенная память обычно реализуется как временный стек вызовов.</em></p> </blockquote>

<p><code>static</code> означает разные вещи в разных контекстах.</p><ol> <li><p>вы можете объявить статическую переменную в функции c. эта переменная видна только в функции, однако она ведет себя как глобальная в том смысле, что она инициализируется только один раз и сохраняет свое значение. в этом примере каждый раз, когда вы вызываете <code>foo()</code>, он будет печатать все большее число. статическая переменная инициализируется только один раз.</p> <pre><code>void foo () { static int i = 0; printf("%d", i); i++ } </code></pre></li> <li><p>другое использование статического - это когда вы реализуете функцию или глобальную переменную в файле .c, но не хотите, чтобы ее символ был виден за пределами <code>.obj</code>, сгенерированного файлом. например.</p> <pre><code>static void foo() { ... } </code></pre></li> </ol>

<p>ненавижу отвечать на старый вопрос, но я не думаю, что кто-либо упоминал, как k & r объясняет это в разделе a4.1 «языка программирования си».</p><p>вкратце, статическое слово используется со значениями <strong>two</strong>:</p><ol> <li>статический - это один из двух классов хранения (другой - автоматический). статический объект сохраняет свое значение между вызовами. объекты, объявленные вне всех блоков, всегда статичны и не могут быть сделаны автоматически.</li> <li>но когда <code>static</code> <strong>keyword</strong> (большое внимание уделяется его использованию в коде в качестве ключевого слова) используется с объявлением, это дает внутреннюю связь этого объекта, поэтому его можно использовать только внутри этого модуля перевода. но если ключевое слово используется в функции, оно меняет класс хранения объекта (в любом случае объект будет виден только внутри этой функции). противоположностью static является ключевое слово <code>extern</code>, которое дает внешнюю связь объекта.</li> </ol><p>питер ван дер линден дает следующие два значения в «программировании expert c»:</p><ul> <li>внутри функции сохраняет свое значение между вызовами.</li> <li>на уровне функций виден только в этом файле.</li> </ul>

<p>если вы объявите переменную в статической функции, ее значение не будет сохранено в стеке вызовов функций и будет по-прежнему доступно при повторном вызове функции.</p><p>если вы объявляете глобальную переменную статической, ее область действия будет ограничена тем файлом, в котором вы ее объявили. это немного безопаснее, чем обычный глобальный, который может быть прочитан и изменен во всей вашей программе.</p>

<p>в си static имеет два значения, в зависимости от области его использования. в глобальной области, когда объект объявляется на уровне файла, это означает, что этот объект виден только внутри этого файла.</p><p>в любой другой области он объявляет объект, который будет сохранять свое значение в разное время, когда вводится конкретная область. например, если int искажено в процедуре:</p><pre><code>void procedure(void) { static int i = 0; i++; } </code></pre><p>значение 'i' инициализируется в ноль при первом вызове процедуры, и значение сохраняется при каждом последующем вызове процедуры. если бы «я» было напечатано, он вывел бы последовательность 0, 1, 2, 3, ...</p>

<p>если вы объявите это в файле mytest.c:</p><pre><code>static int my\_variable; </code></pre><p>тогда эту переменную можно увидеть только из этого файла. переменная не может быть экспортирована в другом месте.</p><p>если вы объявите внутри функции, значение переменной будет сохранять свое значение при каждом вызове функции.</p><p>статическая функция не может быть экспортирована извне файла. таким образом, в файле * .c вы скрываете функции и переменные, если объявляете их статическими.</p>

<p>важно отметить, что статические переменные в функциях инициализируются при первом входе в эту функцию и сохраняются даже после завершения их вызова;<strong> в случае рекурсивных функций статическая переменная инициализируется только один раз и сохраняется также во всех рекурсивных вызовах и даже после завершения вызова функции. </strong></p><p>если переменная была создана вне функции, это означает, что программист может использовать только переменную в исходном файле, переменная была объявлена.</p>

<p>статические переменные в c имеют время жизни программы.</p><p>если они определены в функции, они имеют локальную область видимости, то есть к ним можно получить доступ только внутри этих функций. значение статических переменных сохраняется между вызовами функций.</p><p>например:</p><pre><code>void function() { static int var = 1; var++; printf("%d", var); } int main() { function(); // call 1 function(); // call 2 } </code></pre><p>в приведенной выше программе <code>var</code> хранится в сегменте данных. его время жизни - вся программа на си.</p><p>после вызова функции 1 <code>var</code> становится 2. после вызова функции 2 <code>var</code> становится 3.</p><p>значение <code>var</code> не уничтожается между вызовами функций.</p><p>если <code>var</code> находится между нестатической и локальной переменными, она будет храниться в сегменте стека в программе на си. поскольку фрейм стека функции уничтожается после ее возврата, значение <code>var</code> также уничтожается.</p><p>инициализированные статические переменные хранятся в сегменте данных программы на си, а неинициализированные - в сегменте bss.</p><p>еще одна информация о статических: если переменная является глобальной и статической, она имеет время жизни программы на си, но имеет область видимости файла. это видно только в этом файле.</p><p>чтобы попробовать это:</p><h3>file1.c</h3><pre><code>static int x; int main() { printf("accessing in same file%d", x): } </code></pre><h3>file2.c</h3><pre><code> extern int x; func() { printf("accessing in different file %d",x); // not allowed, x has the file scope of file1.c } run gcc -c file1.c gcc -c file2.c </code></pre><p>теперь попробуйте связать их, используя:</p><pre><code>gcc -o output file1.o file2.o </code></pre><p>это даст ошибку компоновщика, так как x имеет область видимости файла file1.c, и компоновщик не сможет разрешить ссылку на переменную x, используемую в file2.c.</p><p>рекомендации:</p><ol> <li> <a href="http://en.wikipedia.org/wiki/translation\_unit\_(programming)">http://en.wikipedia.org/wiki/translation\_unit\_(programming)</a> </li> <li> <a href="http://en.wikipedia.org/wiki/call\_stack">http://en.wikipedia.org/wiki/call\_stack</a> </li> </ol>

<p>статическая переменная - это специальная переменная, которую вы можете использовать в функции, она сохраняет данные между вызовами и не удаляет их между вызовами. например:</p><pre><code>void func(){ static int count; // if you don't declare its value, the value automatically initializes to zero printf("%d, ", count); count++; } void main(){ while(true){ func(); } } </code></pre><p>результат:</p><p>0, 1, 2, 3, 4, 5, ...</p>

<p>значение статической переменной сохраняется между вызовами различных функций, и ее область действия ограничена локальным блоком статическая переменная всегда инициализируется значением 0</p>

<p>есть 2 случая:</p><p>(1) объявлены локальные переменные <code>static</code>: размещены в сегменте данных вместо стека. его значение сохраняется при повторном вызове функции.</p><p>(2) объявлены глобальные переменные или функции <code>static</code>: невидимая внешняя единица компиляции (т.е. это локальные символы в таблице символов во время компоновки).</p>

<p>в c-программировании static является зарезервированным ключевым словом, которое управляет как временем жизни, так и видимостью. если мы объявим переменную как статическую внутри функции, то она будет видна только во всей этой функции. при таком использовании время жизни статической переменной начнется при вызове функции и будет уничтожено после выполнения этой функции. вы можете увидеть следующий пример:</p><pre><code>#include<stdio.h> int counterfunction() { static int count = 0; count++; return count; } int main() { printf("first counter output = %d\n", counterfunction()); printf("second counter output = %d ", counterfunction()); return 0; } </code></pre><p>выше программа даст нам такой вывод:<br> выход первого счетчика = 1 <br> выход второго счетчика = 1 <br> потому что, как только мы вызовем функцию, она инициализирует count = 0. и пока мы выполняем counterfunction, она уничтожит переменную count.</p>