В чем разница между static в C и C++?

Различия между static в C и C++

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

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

1. Static переменные (Duration of storage)

В обоих языках static переменная имеет static storage duration — существует на всё время программы, не удаляется при выходе из функции/блока.

В C:

void increment() {
    static int counter = 0;  // Инициализируется один раз
    counter++;               // Сохраняет значение между вызовами
    printf("%d", counter);   // 1, 2, 3, ...
}

int main() {
    increment();  // Печатает 1
    increment();  // Печатает 2
    increment();  // Печатает 3
}

В C++:

Работает аналогично, но с дополнительными гарантиями:

void increment() {
    static std::vector<int> history;  // Конструктор вызывается один раз
    history.push_back(rand());
}  // Деструктор вызывается в конце программы

В C++ компилятор гарантирует:

• Конструктор вызывается ровно один раз (даже в многопоточной программе)
• Деструктор вызывается при завершении программы в обратном порядке инициализации

2. Static функции (Internal linkage)

Это основное различие. static перед функцией означает внутренняя связь (internal linkage).

В C:

// file1.c
static void helper() {  // видна только в file1.c
    printf("Helper\n");
}

void public_func() {
    helper();  // OK
}

// file2.c
extern void helper();  // ОШИБКА: не найдёт функцию
// Функция helper не видна снаружи

В C++:

Р работает аналогично, но используется anonymous namespace как современный способ:

// file1.cpp
namespace {  // anonymous namespace, вместо static
    void helper() {
        std::cout << "Helper\n";
    }
}

void public_func() {
    helper();  // OK
}

// file2.cpp
extern void helper();  // ОШИБКА: не найдёт
// Каждый файл имеет свой anonymous namespace

Почему так? Потому что:

• static синтаксис при использовании как linkage спецификатор — это наследие C
• В C++ есть лучший способ через anonymous namespace
• static для внутренней связи считается deprecated в C++

3. Static переменные в классе (Class members)

Полностью явление C++, нет прямого аналога в C.

Static data member

class Counter {
private:
    static int instance_count;  // Общая для всех экземпляров
    int id;
    
public:
    Counter() {
        id = ++instance_count;
    }
    
    static int get_count() {
        return instance_count;
    }
};

// Инициализация в .cpp файле
int Counter::instance_count = 0;

int main() {
    Counter c1, c2, c3;
    std::cout << Counter::get_count();  // 3
    // c1.id = 1, c2.id = 2, c3.id = 3
}

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

Static member function

class Config {
private:
    static std::string database_url;
    
public:
    // Может быть вызвана без объекта
    static void set_database(const std::string& url) {
        database_url = url;
    }
    
    static std::string get_database() {
        return database_url;
    }
};

// Использование:
Config::set_database("postgresql://localhost");
std::cout << Config::get_database();
// Нет необходимости в объекте класса

Важно: static методы не имеют this указателя, не могут обращаться к non-static членам.

4. Итоговая таблица

5. Современный C++ подход

Вместо static функции для internal linkage:

// OLD (не рекомендуется)
static void helper() { }

// NEW (рекомендуется)
namespace {
    void helper() { }
}

Вместо static переменной в файле:

// OLD
static std::map<int, string> cache;

// NEW
namespace {
    std::map<int, string> cache;  // internal linkage
}

6. Практический пример

// logger.cpp
#include <iostream>

namespace {  // internal linkage
    void log_internal(const std::string& msg) {
        std::cerr << "[LOG] " << msg << "\n";
    }
}

class Logger {
private:
    static int log_count;  // class static
    
public:
    static void log(const std::string& msg) {  // static function
        log_internal(msg);  // вызываем internal функцию
        log_count++;
    }
    
    static int get_count() {
        return log_count;
    }
};

int Logger::log_count = 0;  // инициализация

// main.cpp
int main() {
    Logger::log("Started");
    Logger::log("Processing");
    Logger::log("Done");
    std::cout << "Total logs: " << Logger::get_count();  // 3
}

Резюме

static в C обозначает:

1. Переменная существует всю программу (static storage duration)
2. Функция видна только в текущем файле (internal linkage)
3. Переменная видна только в текущем файле (internal linkage)

static в C++ дополнительно означает:

1. Всё из пункта выше
2. Переменная в классе (shared на всех экземплярах)
3. Функция в классе (не требует объекта для вызова)

Совет: если пишешь на C++, используй anonymous namespace вместо static для internal linkage — это более явно и современно.