Как static влияет на локальные переменные?

Влияние Static на локальные переменные

Когда вы объявляете локальную переменную как static, вы изменяете её время жизни с автоматического (временная) на статическое (на всё время выполнения программы). Это один из самых полезных, но и наиболее непонятных моментов в C/C++.

Обычная локальная переменная

void function() {
    int x = 0;  // Локальная переменная
    x++;
    std::cout << x << std::endl;
}

int main() {
    function();  // Выведет: 1
    function();  // Выведет: 1
    function();  // Выведет: 1 (каждый раз новая переменная!)
}

Почему выводит 1? Потому что x создаётся в каждом вызове функции заново, инициализируется нулём, увеличивается на 1, а затем уничтожается.

Static локальная переменная

void function() {
    static int x = 0;  // Static переменная
    x++;
    std::cout << x << std::endl;
}

int main() {
    function();  // Выведет: 1
    function();  // Выведет: 2
    function();  // Выведет: 3 (переменная сохраняет значение!)
}

Здесь:

• static int x = 0; инициализируется только один раз при первом вызове функции
• При последующих вызовах инициализация пропускается
• Переменная сохраняет своё значение между вызовами

Где хранится static переменная?

int global = 0;          // Сегмент данных программы (.data)
const int constant = 10; // Сегмент константных данных (.rodata)

void function() {
    static int local = 0;    // ТАКЖЕ сегмент .data (не стек!)
    int regular = 0;         // Стек (stack)
}

Ключевое отличие:

• Обычная локальная переменная: стек (быстро, но ограниченный размер)
• Static локальная переменная: сегмент данных (живёт всё время программы)

Счётчик вызовов функции

int call_count() {
    static int count = 0;
    return ++count;
}

int main() {
    std::cout << call_count() << std::endl;  // Выведет: 1
    std::cout << call_count() << std::endl;  // Выведет: 2
    std::cout << call_count() << std::endl;  // Выведет: 3
    std::cout << call_count() << std::endl;  // Выведет: 4
}

Кэширование результатов

int expensive_calculation() {
    static int result = -1;
    
    if (result == -1) {  // Вычислили только один раз
        std::cout << "Вычисляю..." << std::endl;
        result = 0;
        for (int i = 0; i < 1000000; i++) {
            result += i;
        }
    }
    
    return result;
}

int main() {
    std::cout << expensive_calculation() << std::endl;  // Выведет: "Вычисляю..." и результат
    std::cout << expensive_calculation() << std::endl;  // Только результат (кэш)
    std::cout << expensive_calculation() << std::endl;  // Только результат (кэш)
}

Static в циклах

void function() {
    for (int i = 0; i < 3; i++) {
        static int count = 0;  // Инициализируется один раз
        count++;
        std::cout << count << std::endl;
    }
}

int main() {
    function();  // Выведет: 1 2 3
    function();  // Выведет: 4 5 6 (count продолжает считать!)
}

Область видимости vs время жизни

Это разные концепции:

void function() {
    int regular = 0;      // Область видимости: функция, время жизни: вызов функции
    static int st = 0;    // Область видимости: функция, время жизни: программа
}

// regular не видна здесь
// st тоже не видна здесь (но она существует в памяти!)

Запомни:

• Static переменная видна только в той области, где объявлена (область видимости)
• Но существует в памяти всё время выполнения программы (время жизни)

Инициализация в многопоточности (важно!)

В C++11 и позже инициализация static локальной переменной гарантирована быть потокобезопасной:

#include <thread>

class Logger {
public:
    static Logger& get_instance() {
        static Logger instance;  // Инициализируется один раз, потокобезопасно!
        return instance;
    }
};

int main() {
    std::thread t1([] { Logger::get_instance(); });
    std::thread t2([] { Logger::get_instance(); });
    t1.join();
    t2.join();
}

Даже если два потока вызовут get_instance() одновременно, Logger будет создан только один раз!

Типичные проблемы

// ❌ ПРОБЛЕМА 1: сложно отлаживать
void function() {
    static int hidden_state = 0;
    hidden_state++;
    // Где начинается счёт? Неясно без контекста!
}

// ✅ ЛУЧШЕ: явное состояние
class Counter {
    int state = 0;
public:
    int increment() { return ++state; }
};

// ❌ ПРОБЛЕМА 2: непредсказуемый порядок инициализации
static int x = 0;

void function() {
    static int y = x;  // x может быть не инициализирован!
}

// ❌ ПРОБЛЕМА 3: сложно тестировать
void function() {
    static int counter = 0;
    // Как обнулить счётчик для нового теста?
}

// ✅ ЛУЧШЕ: передай состояние через параметры или класс

Практический пример: Безопасный синглтон

class DatabaseConnection {
private:
    std::string connection_string;
    
    DatabaseConnection(const std::string& cs) : connection_string(cs) {}
    
public:
    static DatabaseConnection& get_instance() {
        static DatabaseConnection instance("server=localhost");
        return instance;
    }
    
    void query(const std::string& sql) {
        std::cout << "Executing: " << sql << std::endl;
    }
};

int main() {
    DatabaseConnection::get_instance().query("SELECT * FROM users");
    DatabaseConnection::get_instance().query("SELECT * FROM posts");
}

Сравнение с другими подходами

// ❌ ПЛОХО: глобальная переменная
int counter = 0;
void increment() { counter++; }

// ⚠️ НЕЙТРАЛЬНО: параметр функции
void increment(int& counter) { counter++; }

// ✅ ХОРОШО: member переменная класса
class Counter {
private:
    int value = 0;
public:
    void increment() { value++; }
};

// ✅ ОТЛИЧНО: static локальная переменная (для синглтонов)
class Singleton {
public:
    static Singleton& instance() {
        static Singleton s;
        return s;
    }
};

Итоговые выводы

Static локальная переменная:

• Инициализируется один раз при первом вызове функции
• Сохраняет значение между вызовами
• Область видимости: функция, где объявлена
• Время жизни: вся программа
• Хранилище: сегмент данных, не стек
• Потокобезопасна в C++11+ при инициализации
• Полезна для кэширования, счётчиков, синглтонов
• Может усложнить отладку — используй разумно