В чем разница между обычной глобальной переменной и static?

Разница между обычной глобальной переменной и static

Это один из часто неправильно понимаемых концептов в C++. Различие касается видимости и времени жизни переменных, а также сложности в многофайловых проектах.

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

Глобальная переменная объявляется вне любых функций и классов. Она имеет внешнюю связь (external linkage) по умолчанию, что означает, что её можно использовать в других файлах через extern.

// file1.cpp
int globalVar = 42;  // Обычная глобальная переменная

void printVar() {
    std::cout << globalVar << std::endl;
}

// file2.cpp
extern int globalVar;  // Объявляем, что переменная определена в другом файле

void useGlobalVar() {
    std::cout << globalVar << std::endl;  // Можно использовать
}

Визуально:

file1.cpp:        file2.cpp:
globalVar = 42    extern int globalVar
  |                       |
  +-------связь----------+

Static глобальная переменная

Static глобальная переменная имеет внутреннюю связь (internal linkage). Это означает, что переменная видна только в этом файле и никакой другой файл не может получить доступ к ней через extern.

// file1.cpp
static int staticVar = 42;  // Статическая глобальная переменная

void printVar() {
    std::cout << staticVar << std::endl;
}

// file2.cpp
extern int staticVar;  // ОШИБКА ЛИНКОВКИ!
                       // staticVar не доступна из file2.cpp

void useStaticVar() {
    std::cout << staticVar << std::endl;  // Не скомпилируется
}

Таблица сравнения

Практический пример проблемы

Сценарий 1: Коллизия имён с обычными глобалами

// math.cpp
int counter = 0;  // Обычная глобальная

void incrementMath() {
    counter++;
}

// logging.cpp
int counter = 0;  // ЕЩЁ ОДНА переменная с тем же именем!

void incrementLogger() {
    counter++;
}

// main.cpp
extern int counter;  // Что это? Counter из math.cpp или logging.cpp?

int main() {
    counter++;  // ОШИБКА ЛИНКОВКИ! Линкер не знает, какой counter выбрать
    return 0;
}

Ошибка линкера:

multiple definition of 'counter'
first defined here (math.cpp)

Сценарий 2: Правильное использование static

// math.cpp
static int counter = 0;  // Статическая — видна только в math.cpp

void incrementMath() {
    counter++;  // Работает
}

int getMathCounter() {
    return counter;
}

// logging.cpp
static int counter = 0;  // Статическая — видна только в logging.cpp
                          // Это ДРУГАЯ переменная, нет конфликта!
void incrementLogger() {
    counter++;
}

int getLoggerCounter() {
    return counter;
}

// main.cpp
int main() {
    incrementMath();      // counter в math.cpp = 1
    incrementLogger();    // counter в logging.cpp = 1
    
    std::cout << getMathCounter() << std::endl;    // 1
    std::cout << getLoggerCounter() << std::endl;  // 1
    
    return 0;
}

Static переменные в функциях

Есть ещё один случай использования static — внутри функций. Это создаёт переменную с длительностью жизни всей программы.

int getUniqueID() {
    static int counter = 0;  // Инициализируется только один раз!
    return ++counter;        // Каждый вызов увеличивает счётчик
}

int main() {
    std::cout << getUniqueID() << std::endl;  // 1
    std::cout << getUniqueID() << std::endl;  // 2
    std::cout << getUniqueID() << std::endl;  // 3
    return 0;
}

Важно: Static переменные в функциях не являются потокобезопасными в C++11-C++14. В C++17+ их инициализация потокобезопасна по умолчанию.

// C++17 гарантирует потокобезопасность
int& getInstance() {
    static int instance;  // Потокобезопасная инициализация
    return instance;
}

Static и const

Одна из лучших практик — комбинировать static с const для читаемых констант на уровне файла:

// config.cpp
static const int MAX_BUFFER_SIZE = 1024;  // Видна только в config.cpp
static const std::string DATABASE_URL = "localhost";  // Видна только здесь

void initializeConfig() {
    // Используем MAX_BUFFER_SIZE
}

Это предотвращает конфликты имён и обеспечивает инкапсуляцию.

Modern C++: namespace вместо static

В современном C++ вместо static глобальных переменных часто используют anonymous namespaces:

// file.cpp
namespace {
    int hiddenVar = 0;  // Эквивалентно static int hiddenVar = 0;
    
    void internalFunction() {
        hiddenVar++;
    }
}

void publicFunction() {
    internalFunction();
}

Это более явно показывает намерение скрыть переменную.

Best Practices

1. Избегайте глобальных переменных вообще:

// ПЛОХО
int globalCounter = 0;

void increment() {
    globalCounter++;
}

// ХОРОШО
class Counter {
    int value = 0;
public:
    void increment() { value++; }
    int getValue() const { return value; }
};

2. Если нужны глобалы на уровне файла, используйте static:

// ХОРОШО
static int internalCounter = 0;  // Видна только в этом файле

static void internalFunction() {
    internalCounter++;
}

3. Или anonymous namespace (C++11+):

namespace {
    int counter = 0;
    void internal() {}
}

// ... функции, которые используют counter

4. Для singleton используйте Meyers Singleton:

class Singleton {
    Singleton() {}
public:
    static Singleton& getInstance() {
        static Singleton instance;  // Потокобезопасно в C++17+
        return instance;
    }
};

Резюме

• Обычная глобальная: Доступна из других файлов через extern, может вызвать конфликты имён
• Static глобальная: Видна только в текущем файле, предотвращает конфликты
• Лучшее решение: Избегайте глобальных переменных, используйте классы и функции с передачей параметров