Статические переменные в си: Статические переменные

Содержание

Статические переменные в C

На чтение 5 мин Просмотров 78 Опубликовано 02.06.2021

Статические переменные действительно могут сохранять свое значение, даже если они были удалены из области действия! В результате статические переменные сохраняют свое прежнее значение в настройке, упомянутой выше, и их не нужно инициализировать один раз в новой среде. Статические переменные всегда устанавливаются один раз. Компилятор хранит переменную до завершения кода. Внутри и вне метода могут быть указаны статические переменные. Статические переменные имеют стандартное фиксированное значение 0. Статические переменные остаются активными до завершения кода. Обычные переменные ограничены диапазоном, в котором они указаны, тогда как статические переменные имеют область действия, которая распространяется внутри кода.

Синтаксис

Вот синтаксис объявления статической переменной на языке C.

Статический тип переменной имя-переменной = значение-переменной;

Реплика статической переменной создается после ее указания. Основная причина, по которой нас используют вместо локальной переменной, по-видимому, заключается в том, что значение, выделенное в диапазоне, в котором она может быть найдена, сохраняется. В новом объеме кода разработчик старается не инициализировать параметр снова. Это можно понять во всем коде. Он сообщает компилятору ограничить ширину переменной или метода в коде и остается на месте на протяжении всего кода. Эта функция предотвращает случайный доступ к статическим переменным, инкапсулируя или скрывая их от остальной части кода. Давайте рассмотрим несколько примеров работы со статическими переменными. Поскольку мы работали над языком C, убедитесь, что в вашей системе Linux установлен компилятор «GCC» для компиляции кода C.

Пример 01

Откройте командную оболочку с помощью «Ctrl + Alt + T» и создайте файл типа C с помощью редактора «nano», используя приведенный ниже запрос. Имя файла — «test.c», и он будет напрямую открыт в GNU Nano Editor.

Вы можете увидеть приведенный ниже фрагмент кода. Напишите тот же код в свой файл GNU. Код содержит один обязательный заголовок, основную функцию и еще одну функцию с именем «значение». Мы инициализировали переменную целочисленного типа «num» в функции «value», имеющую значение 0. Затем значение «num» будет увеличено и возвращено в основную функцию. В основном методе мы указали три оператора печати для вызова функции «value» и печати результата переменной «num», которая была увеличена. Нажмите клавишу «Ctrl + S», чтобы сохранить код, и закройте файл, нажав «Ctrl + X».

Теперь скомпилируйте код, используя команду «gcc», как показано ниже. Если ошибки не возникает, значит, код правильный.

После компиляции файла test.c мы будем запускать этот файл через запрос «a.out» ниже в консоли. Вы увидите, что результат будет увеличивать значение переменной «num» только один раз, даже после трехкратного вызова функции. Это связано с тем, что значение переменной «num» не было указано как статическое, из-за чего всякий раз, когда вызывается функция «value», она восстанавливает исходное значение, равное 0. Вот почему она увеличивает только 0 до 1 все три типа при вызове.

Обновим код. Снова откройте файл языка C test.c, используя запрос «nano».

Нам просто нужно указать, что переменная «num» статична. Для этого используйте ключевое слово «static» в начале переменной «num» и перед типом переменной, который в нашем случае является целым числом. Каждый раз, когда основная функция вызывает метод «value», статическая переменная «num» будет увеличиваться, а значение станет статическим. Это означает, что новое обновленное значение будет использоваться в следующем вызове, и так далее, процесс будет повторяться.

Давайте сначала скомпилируем файл C с помощью запроса компиляции «gcc» в консольном терминале.

После выполнения файла с помощью инструкции «a.out» вы можете видеть, что выходные данные показывают увеличенное значение каждый раз при вызове метода «value» из-за использования ключевого слова «static» перед переменной «num».

Пример 02

Давайте посмотрим на другой пример статической переменной. Откройте тот же файл C, чтобы написать в нем код.

Вы будете использовать показанный ниже код в редакторе GNU. У нас есть библиотека с одним заголовком и основной метод в коде. На этот раз вы будете использовать две переменные целого типа, «x» и «y», соответственно, в основной функции скрипта C. Один из них — автоматический, второй — статический со значениями «-75» и «22». Затем мы использовали две строки печати для вывода значений обеих переменных отдельно на экран терминала. Затем мы должны попрактиковаться в выражении «если» для выполнения условия. В этом состоянии мы проверим, не равно ли значение переменной «x» 0. Если значение не равно 0, тогда будет выполнен другой оператор печати. Этот оператор печати выведет общую сумму обеих переменных «x» и «y» в нем. После этого основная функция будет закрыта.

Давайте скомпилируем обновленный код C снова через запрос «gcc» вместе с именем файла C «test.c», указанным в запросе, как показано ниже.

Давайте начнем запускать файл «test.c» с помощью старой инструкции «a.out», как указано. Вывод на экране вашего терминала покажет вам точное значение обеих переменных в первых двух строках. После этого в третьей строке отобразится сумма обеих переменных.

Заключение

Мы надеемся, что эта статья будет легкой для понимания и поможет вам понять идею статических переменных в языке C через операционную систему Linux.

c++ — Статические переменные в C ++

Извините, когда я отвечаю на ваши вопросы не по порядку, это облегчает понимание таким образом.

Когда статическая переменная объявлена в заголовочном файле, ее область действия ограничивается файлом .h или для всех модулей.

Нет такой вещи как «область заголовочного файла». Заголовочный файл включается в исходные файлы. Единицей перевода является исходный файл , включающий текст из заголовочных файлов. Все, что вы пишете в заголовочном файле, копируется в каждый включающий исходный файл.

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

Поскольку объявление переменной static таким образом означает внутреннюю связь, каждая единица перевода #includeing вашего заголовочного файла получает свою переменную собственную, индивидуальную (которая не видна за пределами вашей единицы перевода). Обычно это не то, что вы хотите.

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

В объявлении класса static означает, что все экземпляры класса разделяют эту переменную-член; то есть у вас может быть сотни объектов этого типа, но всякий раз, когда один из этих объектов ссылается на переменную static (или «class»), это значение одинаково для всех объектов. Вы можете думать об этом как о «глобальном классе».

Также обычно статическая переменная инициализируется в файле .cpp при объявлении в классе, верно?

Да, одна (и только одна ) единица перевода должна инициализировать класс переменная.

Так что же означает, что область действия статической переменной ограничена двумя единицами компиляции?

Как я сказал:

Заголовок не является модулем компиляции,
static означает совершенно разные вещи в зависимости от контекста.

Глобальное static ограничивает область применения единицей перевода. Класс static означает глобальный для всех экземпляров.

Надеюсь, это поможет.

PS: Проверьте последний абзац ответа Chubsdad о том, как не следует использовать static в C++ для обозначения внутренней связи, но для анонимных пространств имен. (Потому что он прав. ;-))

Где хранятся статические переменные в C и C ++?

Я пробовал это с objdump и gdb, вот результат, который я получаю:

 (gdb) disas fooTest
Dump of assembler code for function fooTest:
   0x000000000040052d <+0>: push   %rbp
   0x000000000040052e <+1>: mov    %rsp,%rbp
   0x0000000000400531 <+4>: mov    0x200b09(%rip),%eax        # 0x601040 <foo>
   0x0000000000400537 <+10>:    add    $0x1,%eax
   0x000000000040053a <+13>:    mov    %eax,0x200b00(%rip)        # 0x601040 <foo>
   0x0000000000400540 <+19>:    mov    0x200afe(%rip),%eax        # 0x601044 <bar.2180>
   0x0000000000400546 <+25>:    add    $0x1,%eax
   0x0000000000400549 <+28>:    mov    %eax,0x200af5(%rip)        # 0x601044 <bar.2180>
   0x000000000040054f <+34>:    mov    0x200aef(%rip),%edx        # 0x601044 <bar.2180>
   0x0000000000400555 <+40>:    mov    0x200ae5(%rip),%eax        # 0x601040 <foo>
   0x000000000040055b <+46>:    mov    %eax,%esi
   0x000000000040055d <+48>:    mov    $0x400654,%edi
   0x0000000000400562 <+53>:    mov    $0x0,%eax
   0x0000000000400567 <+58>:    callq  0x400410 <printf@plt>
   0x000000000040056c <+63>:    pop    %rbp
   0x000000000040056d <+64>:    retq   
End of assembler dump.

(gdb) disas barTest
Dump of assembler code for function barTest:
   0x000000000040056e <+0>: push   %rbp
   0x000000000040056f <+1>: mov    %rsp,%rbp
   0x0000000000400572 <+4>: mov    0x200ad0(%rip),%eax        # 0x601048 <foo>
   0x0000000000400578 <+10>:    add    $0x1,%eax
   0x000000000040057b <+13>:    mov    %eax,0x200ac7(%rip)        # 0x601048 <foo>
   0x0000000000400581 <+19>:    mov    0x200ac5(%rip),%eax        # 0x60104c <bar.2180>
   0x0000000000400587 <+25>:    add    $0x1,%eax
   0x000000000040058a <+28>:    mov    %eax,0x200abc(%rip)        # 0x60104c <bar.2180>
   0x0000000000400590 <+34>:    mov    0x200ab6(%rip),%edx        # 0x60104c <bar.2180>
   0x0000000000400596 <+40>:    mov    0x200aac(%rip),%eax        # 0x601048 <foo>
   0x000000000040059c <+46>:    mov    %eax,%esi
   0x000000000040059e <+48>:    mov    $0x40065c,%edi
   0x00000000004005a3 <+53>:    mov    $0x0,%eax
   0x00000000004005a8 <+58>:    callq  0x400410 <printf@plt>
   0x00000000004005ad <+63>:    pop    %rbp
   0x00000000004005ae <+64>:    retq   
End of assembler dump.

вот результат objdump

 Disassembly of section .data:

0000000000601030 <__data_start>:
    ...

0000000000601038 <__dso_handle>:
    ...

0000000000601040 <foo>:
  601040:   01 00                   add    %eax,(%rax)
    ...

0000000000601044 <bar.2180>:
  601044:   02 00                   add    (%rax),%al
    ...

0000000000601048 <foo>:
  601048:   0a 00                   or     (%rax),%al
    ...

000000000060104c <bar.2180>:
  60104c:   14 00                   adc    $0x0,%al

Итак, ваши четыре переменные находятся в разделе данных с одинаковым именем, но с разным смещением.

Статические члены класса в C++

Члены класса могут использоваться с ключевым словом static. Когда член класса объявляется как статический, то тем самым компилятору дается указание, что эта переменная не динамическая, т.е. принадлежит только классу и не даётся объектам этого класса. Статическая переменная существовует только в классе, т.е. всегда будет только одна копия этого члена, сколько бы объектов этого класса ни создавалось. Проще говоря, статические члены принадлежат только классу, а не его объектам, сколько бы их не было. Объекты класса не содержат эти статические члены класса, и вообще объекты класса никак не пересекаются со статическими членами класса. Объектам даются только динамические члены класса, а статические члены класса остаются в классе, для них класс является пространством имён. Получается что статические члены класса это просто переменные, которые объявлены в пространсве имён класса.

Извне доступ к статическим членам класса получается с помощью оператора доступа к члену пространства имён, где в качестве пространства имён выступает класс. При обращении к статическому члену класса используется оператор области видимости для того, чтобы идентифицировать тот класс, к которому принадлежит переменная. Внутри методов класса доступ к статическим членам класса осуществляется также как и ко всем остальным членам класса — просто указав название переменной (без оператора простраства имён и указания класса в качестве пространства имён).
В отличии от более новых и продвинутых Java, C#, PHP и прочих Си-подобных языков программирования, в олдскульном C++ со статическими переменными не всё так просто. Статические переменные класса C++ задаются чуть сложнее. В C++ нельзя просто взять и определить в классе статическую переменную, как это делается в вышеуказанных лангах программирования. В C++ все статические данные инициализируются нулями при создании первого объекта, и другая инициализация не предусмотрена. При объявлении статического члена данных класса этот член не определяется. Необходимо обеспечить для него определение вне класса в глобальном скопе и только так. Это делается путем нового объявления статической переменной. Это необходимо для того, чтобы под статическую переменную была выделена память. В общем, в C++ статическую переменную класса надо определять дважды — в классе и в глобальной области видимости, иначе никак. Причём дублировать объявление статической переменной можно только в глобальном скопе и больше нигде, ни в кострукторе, ни в списке инициализаци констурктора, ни где либо ещё, только в глобальном скопе.

Пример
class Counter { static int count; public: void setcount(int i) {count = i;}; void showcount() {cout
Статическая переменная count типа int объявляется в двух местах: в классе Counter и затем в глобальном скопе как переменная в пространсве имён (в классе) Counter. Borland C++ инициализирует count нулем. Именно поэтому первый вызов showcount() выводит в качестве результата нуль. Затем объект а устанавливает count равным 10. После этого оба объекта а и b выводят с помощью функции showcount() одну и ту же величину, равную 10. Поскольку существует только одна копия count, используемая совместно объектами а и b, то на экран выводится в обоих случаях значение 10.

Где хранятся статические переменные в C и c++?
Я пробовал это с objdump и gdb, вот результат, который я получаю:
(gdb) disas fooTest Dump of assembler code for function fooTest: 0x000000000040052d <+0>: push %rbp 0x000000000040052e <+1>: mov %rsp,%rbp 0x0000000000400531 <+4>: mov 0x200b09(%rip),%eax # 0x601040 <foo> 0x0000000000400537 <+10>: add x1,%eax 0x000000000040053a <+13>: mov %eax,0x200b00(%rip) # 0x601040 <foo> 0x0000000000400540 <+19>: mov 0x200afe(%rip),%eax # 0x601044 <bar.2180> 0x0000000000400546 <+25>: add x1,%eax 0x0000000000400549 <+28>: mov %eax,0x200af5(%rip) # 0x601044 <bar.2180> 0x000000000040054f <+34>: mov 0x200aef(%rip),%edx # 0x601044 <bar.2180> 0x0000000000400555 <+40>: mov 0x200ae5(%rip),%eax # 0x601040 <foo> 0x000000000040055b <+46>: mov %eax,%esi 0x000000000040055d <+48>: mov x400654,%edi 0x0000000000400562 <+53>: mov x0,%eax 0x0000000000400567 <+58>: callq 0x400410 <printf@plt> 0x000000000040056c <+63>: pop %rbp 0x000000000040056d <+64>: retq End of assembler dump. (gdb) disas barTest Dump of assembler code for function barTest: 0x000000000040056e <+0>: push %rbp 0x000000000040056f <+1>: mov %rsp,%rbp 0x0000000000400572 <+4>: mov 0x200ad0(%rip),%eax # 0x601048 <foo> 0x0000000000400578 <+10>: add x1,%eax 0x000000000040057b <+13>: mov %eax,0x200ac7(%rip) # 0x601048 <foo> 0x0000000000400581 <+19>: mov 0x200ac5(%rip),%eax # 0x60104c <bar.2180> 0x0000000000400587 <+25>: add x1,%eax 0x000000000040058a <+28>: mov %eax,0x200abc(%rip) # 0x60104c <bar.2180> 0x0000000000400590 <+34>: mov 0x200ab6(%rip),%edx # 0x60104c <bar.2180> 0x0000000000400596 <+40>: mov 0x200aac(%rip),%eax # 0x601048 <foo> 0x000000000040059c <+46>: mov %eax,%esi 0x000000000040059e <+48>: mov x40065c,%edi 0x00000000004005a3 <+53>: mov x0,%eax 0x00000000004005a8 <+58>: callq 0x400410 <printf@plt> 0x00000000004005ad <+63>: pop %rbp 0x00000000004005ae <+64>: retq End of assembler dump.

вот результат objdump
Disassembly of section .data: 0000000000601030 <__data_start>: ... 0000000000601038 <__dso_handle>: ... 0000000000601040 <foo>: 601040: 01 00 add %eax,(%rax) ... 0000000000601044 <bar.2180>: 601044: 02 00 add (%rax),%al ... 0000000000601048 <foo>: 601048: 0a 00 or (%rax),%al ... 000000000060104c <bar.2180>: 60104c: 14 00 adc x0,%al
Итак, то есть ваши четыре переменные расположены в событии раздела данных с тем же именем, но с другим смещением.
Использование ключевого слова static в C — Embedded blog — System
Имейте в виду, что есть две области данных — инициализированные («int foo = 5;») и BSS («int bar;»)
У меня нет время в этот момент, чтобы откопать это, но стандарт C указывает, что BSS устанавливается на 0 перед вызовом main ().
volatile означает, что переменная может измениться, и компилятор НЕ должен предполагать, что она останется прежним — это применяется при оптимизации. Например, если значение представляет собой регистр состояния оборудования, отображаемый в памяти в адресное пространство, значение может изменяться по мере работы устройства.Ключевое слово volatile было добавлено из-за C во встроенных системах.
изменчивый uint8_t * stat_reg = 0x1234; // Создаем указатель на регистр статуса, адрес 0x1234
uint8_t stat; // создаем переменную
stat = * stat_reg; // считываем регистр состояния
while (* stat_reg & STAT_BUSY) / * WAIT * /; // ждем, пока устройство не будет занято — статус может измениться
const объявляет, что вещь постоянная и не подлежит изменению.это может быть указатель или объект, на который указывает. Честно говоря, мне всегда нужно искать его использование, например
const char const * foo;
char const * foo;
cost char * foo;
все разные. Как я понимаю, это то, что справа от const — это вещь const. НО — несмотря на то, что я использую C более 30 лет, мне потребовалось несколько ударов, чтобы понять это правильно. Компилятор пожалуется, если вы ошиблись.
Во встроенных системах это позволяет вам контролировать, где хранятся значения — в RAM или FLASH (EEPROM).ПРИМЕЧАНИЕ: каждая встроенная система (семейство MPU) немного отличается!
int foo = 5; // копируется из FLASH в RAM перед main ()
const int bar = 6; // сохраняем 6 во FLASH, а bar имеет адрес flash.
«int foo = 5;» случай интересный. 5 сохраняется во FLASH, затем при загрузке копируется в RAM по адресу ‘foo «. Вы можете изменить значение RAM по своему желанию. НО при перезагрузке копия FLASH не изменяется, поэтому снова foo = 5.
Global Переменные, extern, static, const
Глобальные переменные, extern, static, const
Локальные переменные
Локальная переменная — это переменная, которая встречается в определенной области.Они существуют только в той функции, в которой они созданы.
Иногда их называют
автоматическими переменными , потому что они автоматически создается, когда функция начинает выполнение, и автоматически прочь, когда функция завершит выполнение.
Ключевое слово auto может использоваться для явного создания этих переменных, но не требуется, поскольку по умолчанию используется auto.
Глобальные переменные и внешние
Глобальная переменная — это переменная, которая определяется вне всех функций и доступен для всех функций.
Эти переменные не зависят от области действия и всегда доступны, что означает что глобальная переменная существует до завершения программы.
Можно создать глобальную переменную в одном файле и получить к ней доступ из другой файл. Для этого переменная должна быть объявлена в обоих файлах, но ключевое слово extern должно предшествовать «второму» объявлению.
Статические переменные
Статическая переменная
может быть глобальной или локальной переменной.Оба создается путем предшествования объявлению переменной ключевого слова static .
Локальная статическая переменная — это переменная, которая может сохранять свое значение из одна функция вызывает другую, и она будет существовать до завершения программы.
Когда создается локальная статическая переменная, ей должно быть присвоено начальное значение. В противном случае значение по умолчанию будет 0.
Глобальная статическая переменная — это та, к которой можно получить доступ только в файле где он создан.Считается, что эта переменная имеет область видимости файла .
Постоянные переменные
В C директива препроцессора #define использовалась для создания переменной с постоянное значение. Это все еще работает в C ++, но могут возникнуть проблемы.
Когда используется #define, препроцессор выполнит код и заменит каждый экземпляр переменной #defined с соответствующим значением. Ну, так как переменная #defined существует только в том файле, где она создана, это возможно иметь такое же определение в другом файле с совершенно другим значением.Этот может привести к плачевным последствиям.
Чтобы решить эту проблему, концепция именованной константы, которая похожа на переменная была введена в C ++.
Чтобы создать постоянную переменную в C ++, перед объявлением переменной укажите ключевое слово const . Это сообщает компилятору, что «переменная была создано, значение которого не может быть изменено «
При создании постоянной переменной ей ДОЛЖНО быть присвоено значение.
Static в программировании на C
В этом руководстве мы объясним ключевое слово static, применяя его в переменных и функциях.Статический — это ключевое слово, используемое в программировании на C, и его можно применять, используя следующий синтаксис:
статический {тип данных} {имя переменной}
Статические локальные переменные
Когда переменная в функции статична, переменная сохраняет свое значение между вызовами функции.
//Example1.c

#include

int fun1 ()
{
int count = 0;
count ++;
счетчик возврата;
}

int fun2 ()
{
static int count = 0;
count ++;
счетчик возврата;
}

int main ()
{
printf («fun1 1-й вызов возвращает:% d \ n», fun1 ());
printf («2-й вызов fun1 возвращает:% d \ n \ n», fun1 ());

printf («fun2 1-й вызов возвращает:% d \ n», fun2 ());
printf («2-й вызов fun2 возвращает:% d \ n», fun2 ());

возврат 0;
}

В примере 1.c, у нас есть две функции: fun1 () и fun2 () . В fun1 () мы объявляем одну переменную (count) и инициализируем ее значением 0. Затем мы увеличиваем значение переменной count и возвращаем полученное значение. Используя main () , мы дважды вызываем fun1 () , и каждый раз возвращается значение 1, потому что переменная count очищается после завершения вызова fun1 () . В fun2 () мы объявили переменную count как статическую переменную. Таким образом, его ценность сохраняется.Используя main () , мы дважды вызываем fun2 () : в первый раз возвращается значение 1, а во второй раз возвращается значение 2.
Статические глобальные переменные
Статическая глобальная переменная ведет себя так же, как и другие глобальные переменные, но к ней нельзя получить доступ из другой программы C.
Статические функции
В языке C функции по умолчанию являются глобальными. Однако, если мы объявляем статическую функцию, тогда функция будет локальной и к ней нельзя будет получить доступ из другой программы C.
Инициализация статических переменных
Если статическая переменная не инициализирована явно, то она инициализируется как 0.
//Example2.c

#include

int main ()
{
статический int i;

printf («Значение i:% d \ n», i);

возврат 0;
}

В Example2.c мы объявили статическую переменную i, которая не инициализирована. Однако, поскольку переменная статична, она автоматически инициализируется значением 0.
Важно отметить, что статическая переменная должна быть инициализирована константным литералом; мы не можем использовать возвращаемое значение функции для инициализации статической переменной.
//Example3.c

#include

int fun1 ()
{
возврат 5;
}

int main ()
{
статический int i = fun1 ();
printf («Значение i:% d \ n», i);
возврат 0;
}

В Example3.c мы пытаемся инициализировать статическую переменную, используя возвращаемое значение fun1 () .Однако, как видите, при компиляции кода возвращается ошибка.
Резюме
Время жизни статической переменной и время жизни программы равны.
Если статическая переменная не инициализирована, она примет значение по умолчанию 0.
Ни глобальная статическая переменная, ни статическая функция недоступны из программы, отличной от той, в которой она была определена.
константных и статических переменных в C: C_Programming
Мне нужно знать, о чем именно вы говорите, чтобы отвечать на комментарии StackOverflow.
const просто означает, что аспект переменной не будет изменен в области объявления. например
const int a = 2;
Значение на нельзя переназначить с этого момента.
const int * ptr;
Память, на которую указывает ptr , не может быть изменена с помощью этой переменной.
int * const ptr = & a;
Значение указателя ptr нельзя изменить, чтобы указать на что-то еще, хотя память, на которую он указывает, можно изменить (например,грамм. * ptr = 1; ).
const int * const ptr = & a;
Значение указателя ptr или память, на которую он указывает, не могут быть изменены с помощью этой переменной.
Вы можете избежать константности, отбросив ее, но это не совсем важно для того, что она означает.
статический имеет разные значения в зависимости от того, где он используется. Если он находится в глобальной области видимости, это означает, что переменная является частью модуля компиляции и не может быть связана извне (другие глобальные переменные могут быть доступны другим модулям компиляции, если есть объявление, информирующее компилятор о существовании переменной, и они будут связаны позже).Использование static для такой переменной означает, что она не будет связана с другими единицами компиляции. Проще говоря, это означает, что переменная находится «только в текущем файле».
Это также означает, что если у вас есть две статические переменные с одинаковым именем и типом в разных единицах компиляции, они будут фактически разными. Вы можете использовать это для дублирования переменных, поместив объявление static в заголовок, включенный в несколько исходных файлов, но в большинстве случаев вам вряд ли понадобится это делать.Это также может сбить вас с толку, если вы не сделаете это намеренно.
Если вы используете static для переменной в теле функции, это означает, что у нее есть статическое хранилище, поэтому вместо того, чтобы храниться в стеке и выделяться / освобождаться на основе входа / выхода функции, он вместо этого сохраняется в глобальной памяти поверх время жизни вашей программы, которая ведет себя как глобальная переменная, но получить доступ к ней можно только из содержащей ее функции. Он также имеет дополнительную функциональность, заключающуюся в том, что он «инициализируется один раз», что означает, что если вы инициализируете его в той же строке, что и объявление, это произойдет ровно один раз, когда строка будет выполнена в первый раз.При дальнейших казнях он будет пропущен.
Статическая переменная — обзор
7.2 Назначение мест хранения
В рамках трансляции компилятор должен назначить место хранения каждому значению, производимому кодом. Компилятор должен понимать тип значения, его размер, видимость и время жизни. Компилятор должен учитывать структуру памяти во время выполнения, любые ограничения исходного языка на компоновку областей данных и структур данных, а также любые ограничения целевого процессора на размещение или использование данных.Компилятор решает эти проблемы, определяя ряд соглашений и следуя им.
Типичная процедура вычисляет много значений. Некоторые из них, такие как переменные в языке, подобном Алголу, имеют явные имена в исходном коде. Другие значения имеют неявные имена, например значение i — 3 в выражении A [i — 3, j + 2].
■
Время жизни именованного значения определяется правилами исходного языка и фактическим использованием в коде. Например, значение статической переменной должно сохраняться при нескольких вызовах ее определяющей процедуры, в то время как локальная переменная той же процедуры требуется только от ее первого определения до последнего использования в каждом вызове.
■
Напротив, компилятор имеет больше свободы в том, как он обрабатывает безымянные значения, такие как i — 3. Он должен обрабатывать их способами, которые согласуются со смыслом программы, но он имеет большую свободу действий в определение того, где находятся эти ценности и как долго их хранить.
Параметры компиляции также могут влиять на размещение; например, код, скомпилированный для работы с отладчиком, должен сохранять все значения, которые отладчик может назвать — обычно именованные переменные.
Компилятор также должен решить для каждого значения, хранить ли его в регистре или в памяти. Как правило, компиляторы используют «модель памяти» — набор правил, которыми они руководствуются при выборе местоположения для значений. Две общие политики — это модель «память-память» и модель «регистр-регистр». Выбор между ними имеет большое влияние на код, создаваемый компилятором.
В модели «память-память» компилятор предполагает, что все значения находятся в памяти. Значения загружаются в регистры по мере необходимости, но код сохраняет их обратно в память после каждого определения.В модели «память-память» ir обычно использует имен физических регистров . Компилятор гарантирует, что потребность в регистрах не превышает предложение в каждом операторе.
Физический регистр
именованный регистр в целевой isa
В модели регистр-регистр компилятор предполагает, что у него достаточно регистров для выражения вычислений. Он изобретает отдельное имя, виртуальный регистр , для каждого значения, которое может легально находиться в регистре. Скомпилированный код будет сохранять значение виртуального регистра в памяти только тогда, когда это абсолютно необходимо, например, когда оно передается как параметр или возвращаемое значение, или когда распределитель регистров передает его.
Виртуальный регистр
символическое имя, используемое в ir вместо имени физического регистра
Выбор модели памяти также влияет на структуру компилятора. Например, в модели «память-память» распределитель регистров — это оптимизация, улучшающая код. В модели памяти «регистр-регистр» выделение регистров является обязательной фазой, которая снижает потребность в регистрах и отображает имена виртуальных регистров на имена физических регистров.
7.2.1 Размещение структур данных времени выполнения
Чтобы выполнить назначение памяти, компилятор должен понимать общесистемные соглашения о распределении и использовании памяти.Компилятор, операционная система и процессор взаимодействуют друг с другом, чтобы обеспечить безопасное выполнение нескольких программ на чередующейся (с временным интервалом) основе. Таким образом, многие решения о том, как размещать, манипулировать и управлять адресным пространством программы, лежат за пределами компетенции автора компилятора. Однако решения сильно влияют на код, который генерирует компилятор. Таким образом, разработчик компилятора должен хорошо разбираться в этих проблемах.
На рис. 7.2 показан типичный макет адресного пространства, используемого одной скомпилированной программой.Макет размещает области кода и данных фиксированного размера в нижней части адресного пространства. Код находится внизу адресного пространства; смежная область, помеченная как Static , содержит как статические, так и глобальные области данных, а также любые данные фиксированного размера, созданные компилятором. Область над этими статическими областями данных предназначена для областей данных, которые расширяются и сжимаются. Если компилятор может размещать ars в стеке, ему потребуется стек времени выполнения. В большинстве языков также потребуется куча для динамически размещаемых структур данных.Чтобы обеспечить эффективное использование пространства, куча и стопка должны быть размещены на противоположных концах открытого пространства и увеличиваться по направлению друг к другу. На чертеже куча увеличивается в сторону более высоких адресов, а стек растет в сторону более низких адресов. Противоположное расположение работает одинаково хорошо.
Рисунок 7.2. Схема логического адресного пространства.
Компилятор может создавать дополнительные области статических данных для хранения постоянных значений, таблиц переходов и отладочной информации.
С точки зрения компилятора, это логическое адресное пространство представляет собой полную картину.Однако современные компьютерные системы обычно выполняют множество программ с чередованием. Операционная система отображает несколько логических адресных пространств в одно физическое адресное пространство, поддерживаемое процессором. Рисунок 7.3 показывает эту большую картину. Каждая программа изолирована в собственном логическом адресном пространстве; каждый может вести себя так, как будто у него есть собственная машина.
Рисунок 7.3. Различные взгляды на адресное пространство.
Одно логическое адресное пространство может занимать непересекающиеся страницы в физическом адресном пространстве; таким образом, адреса 100000 и 200000 в логическом адресном пространстве программы не обязательно должны находиться на расстоянии 100000 байтов в физической памяти.Фактически, физический адрес, связанный с логическим адресом 100000, может быть больше, чем физический адрес, связанный с логическим адресом 200000. Отображение логических адресов в физические адреса поддерживается совместно оборудованием и операционной системой. Это почти во всех отношениях выходит за рамки компетенции компилятора.
Page
Единица распределения в виртуальном адресном пространстве
Операционная система отображает виртуальные страницы в физические страничные фреймы.
7.2.2 Схема для областей данных
Для удобства компилятор группирует хранилище для значений с одинаковыми сроками жизни и видимостью; он создает для них отдельные области данных. Размещение этих областей данных зависит от языковых правил, касающихся времени жизни и видимости значений. Например, компилятор может разместить автоматическое хранилище локальной процедуры внутри записи активации процедуры именно потому, что время жизни таких переменных совпадает со временем жизни ar. Напротив, он должен размещать локальное для процедуры статическое хранилище там, где оно будет существовать при вызовах — в «статической» области памяти.На рис. 7.4 показан типичный набор правил для присвоения переменной определенной области данных. Объектно-ориентированные языки подчиняются другим правилам, но проблемы не более сложные.
Рисунок 7.4. Присвоение имен областям данных.
Размещение локальных автоматических переменных в ar приводит к эффективному доступу. Поскольку коду уже требуется arp в регистре, он может использовать смещения относительно arp для доступа к этим значениям с такими операциями, как loadAI или loadAO. Частый доступ к ar, скорее всего, сохранит его в кэше данных.Компилятор помещает переменные со статическим временем жизни или глобальной видимостью в области данных в «статической» области памяти. Доступ к этим значениям требует немного больше работы во время выполнения; компилятор должен убедиться, что у него есть адрес для области данных в регистре.
Чтобы установить адрес статической или глобальной области данных, компилятор обычно загружает перемещаемую метку языка ассемблера.
Значения, хранящиеся в куче, имеют время жизни, которое компилятор не может легко предсказать.Значение может быть помещено в кучу двумя различными механизмами. Программист может явно выделить память из кучи; компилятор не должен отменять это решение. Компилятор может поместить значение в кучу, когда обнаружит, что значение может пережить процедуру, которая его создала. В любом случае значение в куче представлено полным адресом, а не смещением от некоторого базового адреса.
Учебник по кэш-памяти
Один из способов, которым архитекторы пытаются преодолеть разрыв между скоростью процессора и скоростью памяти, — это использование кэш-памяти .Кэш — это небольшая быстрая память, размещаемая между процессором и основной памятью. Кэш разделен на серию кадров равного размера . Каждый кадр имеет адресное поле, называемое тегом , в котором хранится адрес основной памяти.
Аппаратное обеспечение автоматически сопоставляет ячейки памяти с кадрами кэша. Простейшее отображение, используемое в кэше с прямым отображением, вычисляет адрес кеша как адрес основной памяти по модулю размера кеша. Это разбивает память на линейный набор блоков, каждый размером с фрейм кэша.Строка — это блок памяти, который отображается в кадр. В любой момент времени каждый кадр кэша содержит копию данных из одного из своих блоков. Его поле тега содержит адрес в памяти, где обычно находятся эти данные.
При каждом доступе на чтение к памяти оборудование проверяет, есть ли уже запрошенное слово в его кадре кэша. Если да, запрошенные байты возвращаются процессору. В противном случае блок, который в данный момент находится в кадре, удаляется, а запрошенный блок помещается в кэш.
Некоторые кэши используют более сложные сопоставления. Кэш-память с ассоциативным набором использует несколько кадров для каждой строки кэша, обычно два или четыре кадра на строку. Полностью ассоциативный кеш может помещать любой блок в любой кадр. Обе эти схемы используют ассоциативный поиск по тегам, чтобы определить, находится ли блок в кэше. Ассоциативные схемы используют политику, чтобы определить, какой блок выселять; распространенными схемами являются случайная замена и замена наименее недавно использованного (LRU).
На практике эффективная скорость памяти определяется пропускной способностью памяти, длиной блока кэша, отношением скорости кэш-памяти к скорости памяти и процентом обращений, попавших в кэш.С точки зрения компилятора, первые три исправлены. Усилия на основе компилятора по повышению производительности памяти сосредоточены на увеличении соотношения попаданий в кэш и промахов, называемого коэффициентом попаданий.
Некоторые архитектуры предоставляют инструкции, которые позволяют программе давать подсказки кешу относительно того, когда определенные блоки должны быть помещены в память ( предварительно загружено, ) и когда они больше не нужны ( сброшено, ).
Назначение смещений
В случае локальных, статических и глобальных областей данных компилятор должен назначить каждому имени смещение внутри области данных.Target isas ограничивает размещение элементов данных в памяти. Типичный набор ограничений может указывать, что 32-битные целые числа и 32-битные числа с плавающей запятой начинаются на границах слов (32-битных), что 64-битные целые числа и данные с плавающей запятой начинаются на границах двойных слов (64-битных), и эти строковые данные начинаются на границах половинного слова (16 бит). Мы называем эти правила выравнивания.
Некоторые процессоры предоставляют операции для реализации вызовов процедур помимо простой операции перехода. Такая поддержка часто добавляет дополнительные ограничения выравнивания.Например, isa может диктовать формат ar и выравнивание начала каждого ar. У компьютеров dec vax была особенно сложная инструкция вызова; он хранит регистры и другие части состояния процессора на основе битовой маски для конкретного вызова, созданной компилятором.
Для каждой области данных компилятор должен вычислить макет, который присваивает каждой переменной в области данных ее смещение. Этот макет должен соответствовать правилам выравнивания isa. Компилятору может потребоваться вставить отступ между некоторыми переменными, чтобы получить правильное выравнивание.Чтобы свести к минимуму бесполезное пространство, компилятор должен упорядочить переменные по группам, от тех, у которых правила выравнивания самые строгие, до тех, у которых меньше всего. (Например, выравнивание двойного слова является более строгим, чем выравнивание слов.) Затем компилятор назначает смещения для переменных в наиболее ограниченной категории, за которым следует следующий наиболее ограниченный класс, и так далее, пока все переменные не будут иметь смещения. Поскольку правила выравнивания почти всегда указывают степень двойки, конец каждой категории, естественно, соответствует ограничению для следующей категории.
В большинстве языков ассемблера есть директивы, определяющие выравнивание начала области данных, например границы двойного слова.
Относительные смещения и производительность кэша
Широкое использование кэш-памяти в современных компьютерных системах имеет тонкие последствия для размещения переменных в памяти. Если два значения используются в коде рядом, компилятор хотел бы убедиться, что они могут находиться в кэше одновременно. Этого можно добиться двумя способами.В лучшем случае два значения будут совместно использовать один блок кеша, что гарантирует, что значения будут извлечены из памяти в кеш вместе. Если они не могут совместно использовать блок кеша, компилятор хотел бы убедиться, что две переменные отображаются в разные строки кеша. Компилятор может добиться этого, контролируя расстояние между их адресами.
Если рассматривать только две переменные, управление расстоянием между ними кажется управляемым. Однако, когда рассматриваются все активные переменные, проблема оптимального расположения кэша оказывается np-полной.Большинство переменных взаимодействуют со многими другими переменными; это создает сеть отношений, которую компилятор не сможет удовлетворить одновременно. Если мы рассмотрим цикл, который использует несколько больших массивов, проблема организации взаимного невмешательства становится еще хуже. Если компилятор может обнаружить взаимосвязь между различными ссылками на массивы в цикле, он может добавить заполнение между массивами, чтобы повысить вероятность того, что ссылки попадут в разные строки кэша и, таким образом, не будут мешать друг другу.
Как мы видели ранее, отображение логического адресного пространства программы на физическое адресное пространство оборудования не обязательно должно сохранять расстояние между конкретными переменными. Доводя эту мысль до логического завершения, читатель должен спросить, как компилятор может гарантировать что-либо в отношении относительных смещений, превышающих размер страницы виртуальной памяти. Кэш процессора может использовать виртуальные или физические адреса в своих полях тегов. Кэш с виртуальным адресом сохраняет интервалы между значениями, создаваемыми компилятором; с таким кешем компилятор может планировать невмешательство между большими объектами.При физически адресуемом кэше расстояние между двумя местоположениями на разных страницах определяется сопоставлением страниц (если размер кеша не превышает размер страницы). Таким образом, решения компилятора о расположении памяти имеют незначительный эффект, если вообще влияют, за исключением одной страницы. В этой ситуации компилятор должен сосредоточиться на получении объектов, на которые ссылаются вместе, на одной странице и, если возможно, в той же строке кэша.
7.2.3 Сохранение значений в регистрах
В модели памяти «регистр-регистр» компилятор пытается присвоить как можно больше значений виртуальным регистрам.В этом подходе компилятор полагается на распределитель регистров для сопоставления виртуальных регистров в ir с физическими регистрами на процессоре, а передает на память любого виртуального регистра, который он не может сохранить в физическом регистре. Если компилятор хранит статическое значение в регистре, он должен загрузить это значение перед первым использованием в процедуре и сохранить его обратно в память перед выходом из процедуры, либо на выходе из процедуры, либо в любом месте вызова внутри процедуры.
Spill
Когда распределитель регистров не может назначить некоторый виртуальный регистр физическому регистру, он пропускает значение , сохраняя его в RAM после каждого определения и загружая во временный регистр перед каждым использованием.
В большинстве примеров в этой книге мы следуем простому методу назначения виртуальных регистров значениям. Каждое значение получает свой собственный виртуальный регистр с отдельным индексом. Эта дисциплина предоставляет наибольший набор значений для последующего анализа и оптимизации. На самом деле он может использовать слишком много имен. (См. Отступление «Влияние именования» на стр. 248.) Однако у этой схемы есть три основных преимущества. Это просто. Это может улучшить результаты анализа и оптимизации.Это предотвращает включение в код писателем компилятора ограничений, зависящих от процессора, перед оптимизацией, тем самым повышая переносимость. Сильный распределитель регистров может управлять пространством имен и точно адаптировать его к потребностям приложения и ресурсам, доступным на целевом процессоре.
Значение, которое компилятор может сохранить в регистре, называется однозначным значением ; значение, которое может иметь более одного имени, называется неоднозначным значением . Неоднозначность возникает по нескольким причинам.Значения, хранящиеся в переменных, основанных на указателях, часто неоднозначны. Взаимодействие между формальными параметрами, вызываемыми по ссылке, и правилами области видимости имен может сделать формальные параметры неоднозначными. Многие компиляторы рассматривают значения элементов массива как неоднозначные значения, потому что компилятор не может определить, могут ли две ссылки, такие как A [i, j] и A [m, n], когда-либо ссылаться на одно и то же место. Как правило, компилятор не может сохранять неоднозначное значение в регистре ни при определении, ни при использовании другого неоднозначного значения.
Однозначное значение
Значение, к которому можно получить доступ только с одним именем, — однозначное значение .
Неоднозначное значение
Любое значение, к которому можно получить доступ по нескольким именам, — это неоднозначное .
При тщательном анализе компилятор может устранить неоднозначность некоторых из этих случаев. Рассмотрим последовательность присвоений на полях, предполагая, что и a, и b неоднозначны. Если a и b относятся к одному и тому же местоположению, тогда c получает значение 26; в противном случае он получает m + n + 13. Компилятор не может сохранить a в регистре при назначении другой неоднозначной переменной, если он не может доказать, что набор местоположений, на которые могут ссылаться два имени, не пересекается.Этот вид сравнительного попарного анализа дорогостоящий, поэтому компиляторы обычно переносят неоднозначные значения в память с загрузкой перед каждым использованием и сохранением после каждого определения.
a ← m + n;
б ← 13;
c ← a + b;
Таким образом, анализ неоднозначности фокусируется на доказательстве того, что данное значение не является неоднозначным. Анализ может быть поверхностным и локальным. Например, в c любая локальная переменная, адрес которой никогда не берется, однозначна в процедуре, в которой она объявлена.Более сложные анализы создают наборы возможных имен для каждой переменной-указателя; любая переменная, набор которой состоит только из одного элемента, однозначен. К сожалению, анализ не может разрешить все неоднозначности. Таким образом, компилятор должен быть готов к осторожной и правильной обработке неоднозначных значений.
Функции языка могут повлиять на способность компилятора анализировать неоднозначность. Например, ansi c включает два ключевых слова, которые напрямую передают информацию о неоднозначности. Ключевое слово restrict сообщает компилятору, что указатель однозначен.Он часто используется, когда процедура передает адрес непосредственно на место вызова. Ключевое слово volatile позволяет программисту объявить, что содержимое переменной может изменяться произвольно и без предварительного уведомления. Он используется для регистров аппаратного устройства и для переменных, которые могут быть изменены подпрограммами обслуживания прерываний или другими потоками управления в приложении.
Обзор раздела
Компилятор должен определить для каждого значения, вычисляемого в программе, где оно должно быть сохранено: в памяти или регистре и, в любом случае, в конкретном месте.Он должен присвоить каждому значению местоположение, которое соответствует как его времени жизни (см. Раздел 6.3), так и его адресуемости (см. Раздел 6.4.3). Таким образом, компилятор сгруппирует значения в области данных, в которых каждое значение имеет один и тот же класс хранения.
Назначение хранилища предоставляет компилятору ключевую возможность кодировать информацию в ir для использования на более поздних этапах. В частности, различие между неоднозначным значением и однозначным значением может быть трудно вывести путем анализа ir.Если, однако, компилятор присваивает каждому однозначному значению свой собственный виртуальный регистр на все время его существования, последующие этапы компилятора могут использовать место хранения значения, чтобы определить, является ли ссылка неоднозначной. Эти знания упрощают последующую оптимизацию.
комиссия за аннулирование () {
int a, * b;
…
b = & a;
…
}
Контрольные вопросы
1.
Изобразите алгоритм, назначающий смещения списку статических переменных в одном файле из программы на языке Си.Как он упорядочивает переменные? С какими ограничениями выравнивания может столкнуться ваш алгоритм?
2.
Рассмотрим короткий фрагмент c на полях. В нем упоминаются три значения: a, b и * b. Какие значения неоднозначны? Какие однозначные?
Являются ли статические переменные файловой области в C так же плохо, как глобальные переменные extern?
На мой взгляд, все это привязано к области видимости переменной (не константа, что-то изменяемое). Эта точка зрения, по общему признанию, лишена каких-то нюансов, но это прагматичный контраргумент и призыв вернуться к самым основным фундаментальным принципам для тех, кто говорит: «Это абсолютное зло!» только затем, чтобы столкнуться с проблемами, похожими на те, которые связаны с тем, что они критикуют, например, с условиями гонки.
Представьте, что у вас есть 50 000-строчная функция со всеми видами переменных, объявленными вверху, и операторами goto , которые можно перемещать повсюду. Это не очень приятно с такой чудовищной областью видимости переменных, и пытаться рассуждать о функции и о том, что происходит с такими переменными, будет чрезвычайно сложно. В таком чудовищном случае обычное различие между «внешним» и «внутренним» побочным эффектом теряет свою практическую ценность.
Представьте, что у вас есть простая программа из 80 строк, которую вы просто пишете один раз и запускаете с глобальной переменной (либо с внутренней связью и областью файла, либо с внешней связью, но в любом случае программа маленькая).Это не так уж и плохо.
Представьте, что у вас есть чудовищный класс на объектно-ориентированном языке, который содержит всю логику вашей программы с тысячами и тысячами строк кода для ее реализации. В этом случае его переменные-члены более проблематичны, чем глобальные переменные в приведенной выше 80-строчной программе.
Если вы хотите иметь возможность лучше и увереннее рассуждать о своем коде, его поточной безопасности (или ее отсутствии), сделать его более предсказуемым, убедитесь, что ваши тесты имеют хорошее покрытие без пропуска всех видов потенциальных крайних случаев, и т.д., то это помогает сузить доступ к переменным.
Статика области видимости файла будет иметь более узкую область действия, чем статика с внешней связью, но опять же, если ваш исходный файл состоит из 100 000 строк кода, это все равно чертовски велико. Итак, что касается статики области видимости файла, если вы не можете избежать ее, я бы попытался ограничить их область действия, не делая ваш исходный файл, который может получить к ним доступ, огромным, поскольку в этом случае уменьшение области действия связано с уменьшением размера и области дизайна. исходного файла, в отличие от функции (для локальных переменных, включая параметры), класса (для переменных-членов) или, возможно, модуля (для глобальных объектов с внешней связью, но доступных только внутри модуля) или даже всего программного обеспечения (для глобальных переменных с внешняя связь, доступная для всего программного обеспечения).
Статические и нестатические переменные на языке C
В качестве ключевого слова в языке C static часто используется для изменения переменных и функций.
Статически измененные переменные:
1. Глобальная статическая переменная: добавьте ключевое слово static перед глобальной переменной, и глобальная переменная будет определена как глобальная статическая переменная.
(1) Место в памяти: статическая область хранения.
(2) Область действия: Это видно повсюду в программе.
2.Локальная статическая переменная: добавьте ключевое слово static перед локальной переменной, и локальная переменная будет определена как локальная статическая переменная.
(1) Место в памяти: статическая область хранения. (После добавления статической переменной к глобальной переменной ее место хранения изменяется со стека на область статического хранения)
(2) Объем: Виден только внутри функции.

Статические переменные инициализируются только один раз во время инициализации.Разница между статическими глобальными переменными и статическими локальными переменными:
Область действия нестатических глобальных переменных — это вся исходная программа, а статическая глобальная переменная ограничивает ее область действия, то есть она действительна только в исходном файле, который определяет переменную, и другие исходные файлы в той же исходной программе интегрированы. . Не могу его использовать.
Время существования статической локальной переменной — это программа integerSource, но ее можно использовать только в функции, определяющей переменную. Его нельзя использовать после выхода из функции.
Переменные, объявленные статически, имеют следующие характеристики:
(1) Переменная будет помещена в область данных программы, так что исходное присвоение может быть сохранено при следующем вызове.
(2) Переменная использует static, чтобы сообщить компилятору, что она видна только в области видимости переменной, которая является разницей между ней и глобальной переменной.

Штирлиц — Сеть печатных салонов в Перми

Статические переменные в си: Статические переменные | Программирование на C и C++

Статические переменные в C

Синтаксис

Пример 01

Пример 02

Заключение

c++ — Статические переменные в C ++

Где хранятся статические переменные в C и C ++?

Статические члены класса в C++

Пример

Где хранятся статические переменные в C и c++?

Использование ключевого слова static в C — Embedded blog — System

Global Переменные, extern, static, const

Static в программировании на C

Статические локальные переменные

Статические глобальные переменные

Статические функции

Инициализация статических переменных

Резюме

константных и статических переменных в C: C_Programming

Статическая переменная — обзор

7.2 Назначение мест хранения

Физический регистр

Виртуальный регистр

7.2.1 Размещение структур данных времени выполнения

Page

7.2.2 Схема для областей данных

Учебник по кэш-памяти

Назначение смещений

Относительные смещения и производительность кэша

7.2.3 Сохранение значений в регистрах

Spill

Однозначное значение

Неоднозначное значение

Обзор раздела

Контрольные вопросы

Являются ли статические переменные файловой области в C так же плохо, как глобальные переменные extern?

Статические и нестатические переменные на языке C

Добавить комментарий Отменить ответ