Я немного путаюсь в переменных static, auto, global и local.
Где-то я читал, что переменную static можно получить только внутри функции, но они все еще существуют (остаются в памяти) после возвращения функции.
Однако я также знаю, что переменная local также делает то же самое, так в чем же разница?
Здесь есть две отдельные концепции:
Локальные переменные (педантично, переменные с областью блока) доступны только в блоке кода, в котором они объявлены:
void f() {
int i;
i = 1; // OK: in scope
}
void g() {
i = 2; // Error: not in scope
}
Глобальные переменные (педантично, переменные с областью файлов (в C) или область пространства имен (на С++)) доступны в любой момент после их объявления:
int i;
void f() {
i = 1; // OK: in scope
}
void g() {
i = 2; // OK: still in scope
}
(В С++ ситуация более сложная, так как пространства имен могут быть закрыты и повторно открыты, а к областям, кроме текущего, можно получить доступ, а имена также могут иметь классную область, но это становится очень не по теме.)
Автоматические переменные (педантически, переменные с продолжительностью автоматического хранения) - это локальные переменные, срок жизни которых заканчивается, когда выполнение выходит из области действия и воссоздается при повторной вводе области.
for (int i = 0; i < 5; ++i) {
int n = 0;
printf("%d ", ++n); // prints 1 1 1 1 1 - the previous value is lost
}
Статические переменные (педантично, переменные со статической продолжительностью хранения) имеют срок службы, который длится до конца программы. Если они являются локальными переменными, то их значение сохраняется, когда выполнение выходит из области действия.
for (int i = 0; i < 5; ++i) {
static int n = 0;
printf("%d ", ++n); // prints 1 2 3 4 5 - the value persists
}
Обратите внимание, что ключевое слово static имеет различные значения, кроме статической продолжительности хранения. По глобальной переменной или функции она дает внутреннюю связь, чтобы она не была доступна из других единиц перевода; на члене класса С++, это означает, что один экземпляр для каждого класса, а не один объект. Кроме того, в С++ ключевое слово auto больше не означает автоматическую продолжительность хранения; теперь это означает автоматический тип, выводимый из инициализатора переменной.
Прежде всего, я говорю, что вы должны это сделать Google, поскольку он подробно определен во многих местах
Local
Эти переменные существуют только внутри конкретной функции, которая их создает. Они неизвестны другим функциям и основной программе. Таким образом, они обычно реализуются с использованием стека. Локальные переменные перестают существовать после завершения функции, которая их создала. Они воссоздаются каждый раз, когда функция выполняется или вызывается.
Global
Эти переменные могут быть доступны (т.е. известны) любой функцией, содержащей программу. Они реализуются путем связывания мест памяти с именами переменных. Они не воссоздаются, если функция вызывается.
/* Demonstrating Global variables */
#include <stdio.h>
int add_numbers( void ); /* ANSI function prototype */
/* These are global variables and can be accessed by functions from this point on */
int value1, value2, value3;
int add_numbers( void )
{
auto int result;
result = value1 + value2 + value3;
return result;
}
main()
{
auto int result;
value1 = 10;
value2 = 20;
value3 = 30;
result = add_numbers();
printf("The sum of %d + %d + %d is %d\n",
value1, value2, value3, final_result);
}
Sample Program Output
The sum of 10 + 20 + 30 is 60
Сфера глобальных переменных может быть ограничена путем тщательного размещения объявления. Они видны из объявления до конца текущего исходного файла.
#include <stdio.h>
void no_access( void ); /* ANSI function prototype */
void all_access( void );
static int n2; /* n2 is known from this point onwards */
void no_access( void )
{
n1 = 10; /* illegal, n1 not yet known */
n2 = 5; /* valid */
}
static int n1; /* n1 is known from this point onwards */
void all_access( void )
{
n1 = 10; /* valid */
n2 = 3; /* valid */
}
Статический:
Статический объект - это объект, который сохраняется с момента его создания до конца программы. Таким образом, объекты стека и кучи исключены. Но глобальные объекты, объекты в области пространства имен, объекты, объявленные статическими внутри классов/функций, и объекты, объявленные в области файла, включены в статические объекты. Статические объекты уничтожаются, когда программа перестает работать.
Я предлагаю вам посмотреть этот список учебников
АВТО:
C, С++
(Вызываемые автоматические переменные.)
Все переменные, объявленные в блоке кода, автоматически по умолчанию, но это можно сделать явным с ключевым словом auto. [note 1] Неинициализированная автоматическая переменная имеет значение undefined, пока ей не будет присвоено действительное значение ее тип. [1]
Использование регистра класса хранения вместо auto - это подсказка для компилятора для кэширования переменной в регистре процессора. Помимо того, что оператор ссылки (&) не используется для переменной или любого из ее подкомпонентов, компилятор может игнорировать подсказку.
В С++ конструктор автоматических переменных вызывается, когда выполнение достигает места объявления. Деструктор вызывается, когда он достигает конца данного программного блока (программные блоки окружены фигурными скобками). Эта функция часто используется для управления распределением ресурсов и освобождением, такими как открытие, а затем автоматическое закрытие файлов или освобождение памяти. СМОТРИТЕ WIKIPEDIA
Разница - это статические переменные - это те переменные, которые позволяют сохранить значение от одного вызова функции к другому. Но в случае локальных переменных область действия до времени жизни блока/функции.
Пример:
#include <stdio.h>
void func() {
static int x = 0; // x is initialized only once across three calls of func()
printf("%d\n", x); // outputs the value of x
x = x + 1;
}
int main(int argc, char * const argv[]) {
func(); // prints 0
func(); // prints 1
func(); // prints 2
return 0;
}
Локальные переменные не существуют в памяти после завершения функции.
Однако static переменные остаются выделенными в памяти на протяжении всего жизненного цикла программы независимо от любой функции.
В дополнение к вашему вопросу переменные static могут быть объявлены локально в class или в области функций и глобально в namespace или в области файлов. Они выделяют память от начала до конца, это просто инициализация, которая происходит рано или поздно.
static - сильно перегруженное слово в C и С++. static переменными в контексте функции являются переменные, которые сохраняют свои значения между вызовами. Они существуют на протяжении всей программы.
локальные переменные сохраняются только для времени жизни функции или любого из их охватывающих областей. Например:
void foo()
{
int i, j, k;
//initialize, do stuff
} //i, j, k fall out of scope, no longer exist
Иногда это определение цели используется с целями { }:
{
int i, j, k;
//...
} //i, j, k now out of scope
существуют глобальные переменные на протяжении всей программы.
auto теперь отличается от C и С++. auto в C был (лишним) способом задания локальной переменной. В С++ 11 auto теперь используется для автоматического получения типа значения/выражения.
Когда переменная объявляется static внутри класса, она становится общей переменной для всех объектов этого класса, что означает, что эта переменная более специфична для любого объекта. Например: -
#include<iostream.h>
#include<conio.h>
class test
{
void fun()
{
static int a=0;
a++;
cout<<"Value of a = "<<a<<"\n";
}
};
void main()
{
clrscr();
test obj1;
test obj2;
test obj3;
obj1.fun();
obj2.fun();
obj3.fun();
getch();
}
Эта программа будет генерировать следующий вывод: -
Value of a = 1
Value of a = 2
Value of a = 3
То же самое относится к объявленной во всем мире статической переменной. Вышеприведенный код будет генерировать тот же результат, если мы объявим переменную внешней функцией void fun()
Если u удаляет ключевое слово static и объявляет a как нестатистическую локальную/глобальную переменную, то вывод будет следующим: -
Value of a = 1
Value of a = 1
Value of a = 1