Для чего нужно ключевое слово static в C++?

О, блядь, вот это тема! Слушай, про static в C++ можно книгу писать, а можно просто объяснить на пальцах, чтобы даже мартышлюшка поняла. Ёпта, у этого слова аж четыре разных значения, и все они тебя так запутают, что ты сам от себя охуеешь. Смотри, разбираем по косточкам.

1. Статические переменные внутри функций (они же — «запомни меня, детка»)

Представь, ты вызываешь функцию, а она тебе что-то считает. Обычная переменная после вызова накрывается медным тазом — её как не бывало. А вот если навесить static, то она превращается в хитрожопую сущность, которая помнит всё.

void counter() {
    static int count = 0; // Инициализируется ОДИН раз, ёбана в рот!
    count++;
    std::cout << "Вызов №" << count << std::endl;
}

int main() {
    counter(); // Вызов №1
    counter(); // Вызов №2 — а count уже равен 1, потому что static!
    counter(); // Вызов №3 — и так далее, она не сбрасывается!
}

Вот в чём прикол: count инициализируется один раз при первом заходе в функцию, а потом живёт своей жизнью, как глобальная переменная, но видна только внутри этой функции. Удобно, если нужно что-то копить между вызовами, но не хочется светить это на весь проект.

2. Статические члены класса (общие на всех, как коммунальная квартира)

Тут вообще ёперный театр начинается. Представь класс — это как чертёж дома. Обычные поля — это комнаты в каждом отдельном доме (объекте). А статические поля — это, блядь, общий подвал, куда все жильцы могут складывать свой хлам. Один на всех!

class Logger {
private:
    static int instanceCount; // Объявление — эта штука ОБЩАЯ для всех объектов!

public:
    Logger() {
        instanceCount++; // Каждый новый объект увеличивает общий счётчик
    }

    static int getInstanceCount() { // Статический метод — работает БЕЗ объекта!
        return instanceCount; // Может трогать только статические поля
    }

    static void setLogLevel(int level) { // Ещё один статик-метод
        // Тут тоже можно только к статическим полям лезть
    }
};

// А вот это, сука, ОБЯЗАТЕЛЬНОЕ действие! Определение в .cpp файле.
// Без этого линкер тебе мозг выест, будет орать «неопределённый символ».
int Logger::instanceCount = 0;

int main() {
    Logger logger1, logger2, logger3; // Создали три объекта
    std::cout << Logger::getInstanceCount(); // Выведет 3! Вызов БЕЗ объекта, напрямую через класс!
}

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

3. Статик в области видимости файла (невидимка)

Это старый, добрый C-стиль. Если объявить глобальную переменную или функцию со static вне класса, то она становится невидимой для других файлов. Типа «моё, не твоё».

// file1.cpp
static int internalVariable = 42; // Видна ТОЛЬКО в этом файле, как будто её нет!
static void internalFunction() {   // И эта функция тоже только тут
    // ...
}

// file2.cpp
extern int internalVariable; // ОШИБКА линковки — не найдёт, потому что static в file1 спрятал!

Раньше это использовали, чтобы не засорять глобальное пространство имён. Сейчас чаще используют анонимные неймспейсы, но старый способ тоже работает. Если хочешь спрятать какую-то внутреннюю кухню от посторонних глаз — вот тебе инструмент.

4. Статические члены в шаблонах (каждый сам за себя)

А вот это уже высший пилотаж, ебушки-воробушки! У шаблонных классов каждый инстанцированный тип получает свою собственную копию статического поля. Не одну на всех, а каждому типу — свою!

template<typename T>
class TypeTracker {
public:
    static int creationCount; // Каждая специализация шаблона будет иметь свою отдельную переменную!
};

// Определение для каждой специализации — обязательно!
template<typename T>
int TypeTracker<T>::creationCount = 0;

int main() {
    TypeTracker<int>::creationCount++;   // Увеличили счётчик для int
    TypeTracker<double>::creationCount++; // Увеличили СОВСЕМ ДРУГОЙ счётчик для double
    // TypeTracker<int>::creationCount и TypeTracker<double>::creationCount — это РАЗНЫЕ переменные в памяти!
}

Представь, что шаблон — это фабрика по производству счётчиков. Заказал счётчик для int — получил один ящик. Заказал для double — получил совершенно другой ящик. Они независимы, как соседи по лестничной клетке, которые друг друга ненавидят.

Ключевые различия, чтобы не ебал мозг:

• Время жизни: все статические переменные живут от старта программы до её завершения, как глобальные. Не уничтожаются при выходе из scope.
• Область видимости: зависит от контекста — либо внутри функции, либо внутри класса, либо внутри файла.
• Память: статические члены класса не увеличивают размер каждого объекта! Они лежат где-то отдельно, а в объекте только неявная ссылка на них. Размер sizeof(Logger) будет без учёта статических полей.

Короче, static — это как швейцарский нож: в разных ситуациях работает по-разному. Главное — не путать контексты, а то получится пиздопроебибна в коде.