C++ Классы хранения

Классы хранения определяют область действия (видимость) и время жизни переменных/функций в программах на C++. Эти спецификаторы размещаются перед типом, который они изменяют. Ниже перечислены классы хранения, доступные в программах на C++:

  • auto: Это спецификатор класса хранения по умолчанию, и его обычно можно опустить. Переменные, указанные с помощью auto, имеют автоматическую продолжительность хранения, то есть их время жизни ограничено блоком, в котором они определены. Переменные auto обычно размещаются в стеке.

  • register: Используется, чтобы предложить компилятору хранить переменную в регистре процессора для повышения скорости доступа. В C++11 и более поздних версиях register — устаревшая возможность и больше не имеет практического эффекта.

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

  • extern: Используется для объявления переменных или функций с внешним связыванием, которые могут совместно использоваться несколькими файлами. По умолчанию глобальные переменные и функции имеют класс хранения extern. Использование extern в одном файле для объявления глобальной переменной или функции, определённой в другом файле, обеспечивает совместное использование между файлами.

  • mutable (C++11): Используется для модификации переменных-членов класса, позволяя изменять их значения в const-функциях-членах. Обычно применяется для таких данных, как кеши или счётчики, которые нужно изменять в const-контексте.

  • thread_local (C++11): используется для определения переменных с продолжительностью хранения, локальной для потока; каждый поток имеет собственную независимую копию. Время жизни thread-local переменной совпадает со временем жизни потока.

Начиная с C++17, ключевое слово auto больше не является спецификатором класса хранения C++, а ключевое слово register объявлено устаревшим.

Приведённые здесь спецификаторы класса хранения дают программистам средство управлять временем жизни и видимостью переменных и функций.

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

Начиная с C++11, register утратил свою первоначальную роль, тогда как mutable и thread_local — новые возможности, введённые для решения конкретных задач программирования.

Ниже приведён пример, демонстрирующий различные спецификаторы класса хранения:

Пример

#include <iostream>

// Глобальная переменная с внешним связыванием, класс хранения по умолчанию — extern
int globalVar;

void function() {
    // Локальная переменная с автоматической продолжительностью хранения, класс хранения по умолчанию — auto
    auto int localVar = 10;

    // Статическая переменная со статической продолжительностью хранения, время жизни охватывает всю программу
    static int staticVar = 20;

    const int constVar = 30; // переменная const по умолчанию имеет статическую продолжительность хранения

    // Попытка изменить переменную const, ошибка компиляции
    // constVar = 40;

    // Изменяемая переменная-член, может быть изменена в const-функциях-членах
    class MyClass {
    public:
        mutable int mutableVar;

        void constMemberFunc() const {
            mutableVar = 50; // Позволяет изменять mutable-переменную-член
        }
    };

    // Локальная для потока переменная, каждый поток имеет свою независимую копию
    thread_local int threadVar = 60;
}

int main() {
    extern int externalVar; // Объявление переменной с внешним связыванием

    функция();

    return 0;
}

auto класс памяти

Начиная с C++ 11,autoКлючевое слово используется в двух ситуациях: при объявлении переменной — для автоматического вывода типа переменной на основе выражения инициализации; при объявлении функции — в качестве заполнителя для возвращаемого значения функции.

В стандарте C++98 ключевое слово auto использовалось для объявления автоматических переменных, но поскольку оно использовалось редко и было избыточным, это использование было удалено в C++17.

Автоматически выводит тип объявленной переменной на основе выражения инициализации, например:

auto f=3.14; //double auto s("hello"); //const char* auto z = new auto(9); // int* auto x1 = 5, x2 = 5.0, x3='r';// Ошибка: должен быть инициализирован значением того же типа

класс памяти register

register — это класс памяти, используемый для объявления переменных и указания компилятору хранить эти переменные в регистрах для быстрого доступа.

Использование ключевого слова register может повысить скорость выполнения программы, поскольку оно сокращает количество обращений к памяти.

Однако учтите, что класс памяти register — это лишь подсказка; компилятор может её игнорировать, поскольку современные компиляторы обычно автоматически оптимизируют код и выбирают подходящее место хранения.

Синтаксис:

register data_type variable_name;
  • registerЭто ключевое слово класса памяти, используемое для указания компилятору хранить переменные в регистрах.
  • data_typeЭто тип данных переменной, который может быть любым допустимым типом данных C++.
  • variable_name— это имя переменной.
void loop() { register int i; for (i = 0; i < 1000; ++i) { // Тело цикла } }

Класс памяти register используется для того, чтобы подсказать компилятору хранить переменные в регистрах для повышения скорости доступа. Однако благодаря возможностям автоматической оптимизации современных компиляторов использование ключевого слова register не обязательно и редко применяется на практике.

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

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

static класс памяти

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

Модификатор static также можно применять к глобальным переменным. Когда static изменяет глобальную переменную, он ограничивает область видимости переменной файлом, в котором она объявлена.

В C++ при использовании static для элемента данных класса получается только одна копия этого элемента, совместно используемая всеми объектами класса.

Пример

#include <iostream> // Объявление функции void func(void); static int count = 10; /*Глобальные переменные*/ int main() { while(count--) { func(); } return 0; } // Определение функции void func( void ) { static int i = 5; // Локальная статическая переменная i++; std::cout << "Переменная i равна" << i ; std::cout << ", переменная count равна" << count << std::endl; }

Когда приведенный выше код скомпилирован и выполнен, он выдает следующие результаты:

变量 i 为 6 , 变量 count 为 9
变量 i 为 7 , 变量 count 为 8
变量 i 为 8 , 变量 count 为 7
变量 i 为 9 , 变量 count 为 6
变量 i 为 10 , 变量 count 为 5
变量 i 为 11 , 变量 count 为 4
变量 i 为 12 , 变量 count 为 3
变量 i 为 13 , 变量 count 为 2
变量 i 为 14 , 变量 count 为 1
变量 i 为 15 , 变量 count 为 0

extern класс памяти

externЭтот класс памяти используется для предоставления ссылки на глобальную переменную, видимую всем программным файлам. Когда вы используете 'extern' для переменной, которую нельзя инициализировать, он указывает имя переменной на ранее определённое место хранения.

Когда у вас есть несколько файлов и вы определяете глобальную переменную или функцию, которую можно использовать в других файлах, вы можете использовать её в других файлах.externчтобы получить ссылку на определённую переменную или функцию. Это можно понять так:externОн используется для объявления глобальной переменной или функции в другом файле.

Модификатор extern обычно используется, когда два или более файлов совместно используют одни и те же глобальные переменные или функции, как показано ниже:

Первый файл: main.cpp

Пример

#include <iostream> int count ; extern void write_extern(); int main() { count = 5; write_extern(); }

Второй файл: support.cpp

Пример

#include <iostream> extern int count; void write_extern(void) { std::cout << "Count is " << count << std::endl; }

Здесь, во втором файле, ключевое словоexternиспользуется для объявления count, который уже был определён в первом файле main.cpp. Теперь скомпилируйте эти два файла следующим образом:

$ g++ main.cpp support.cpp -o write

Это создастwriteисполняемую программу, попробуйте выполнитьwrite, это даст следующие результаты:

$ ./write
Count is 5

mutable класс памяти

mutable — это ключевое слово, используемое для изменения переменных-членов класса, чтобы их можно было изменять в const-функциях-членах. Обычно const-функции-члены не могут изменять состояние объекта, но если переменная-член объявлена как mutable, её можно изменять в const-функциях.

Возможности:

  • Позволяет изменение:mutableпеременные-члены могут бытьconstфункция-член была изменена.
  • Назначение: Обычно используется в сценариях, требующих управления состоянием без изменения внешнего состояния объекта, таких как кэширование, ленивое вычисление и т. д.

Пример

#include <iostream>

class Example {
public:
    Example() : value(0), cachedValue(0) {}

    // функция-член const
    int getValue() const {
        return value; // Чтение const-члена
    }

    // Изменение mutable-члена
    void increment() {
        ++value;
        cachedValue = value * 2; // Изменение mutable-члена
    }

    int getCachedValue() const {
        return cachedValue; // Чтение mutable-члена
    }

private:
    int value;                 // Обычный член, не может быть изменён в константной функции
    mutable int cachedValue;   // Изменяемый член, может быть изменён в константных функциях
};

int main() {
    const Example ex;
    // ex.increment(); // Ошибка: нельзя вызвать неконстантную функцию у константного объекта
    // ex.value = 10; // Ошибка: нельзя изменить член константного объекта

    std::cout << "Значение: " << ex.getValue() << std::endl;
    std::cout << "Кэшированное значение: " << ex.getCachedValue() << std::endl; // Вывод равен 0

    return 0;
}

Применимые сценарии:

  • Кэширование: вconstВычислить и кэшировать результат в функции, не влияя на внешнее состояние объекта.
  • Отслеживание состояния: Например, счётчики логов, отслеживание такой информации, как количество вызовов, без навязчивых изменений в логике класса.

Примечания:

  • mutableСледует соблюдать осторожность при использовании переменной, чтобы избежать неожиданных изменений состояния, которые могут повлиять на читаемость и поддерживаемость кода.
  • mutableотносится к необходимостиconstЭто частный случай изменения состояния в среде, а не универсальный шаблон проектирования.

класс хранения thread_local

thread_local — это класс хранения, представленный в C++11, используемый для управления переменными, специфичными для потока, в многопоточной среде.

Переменные, объявленные с thread_local, имеют независимые экземпляры в каждом потоке, поэтому операции каждого потока с переменной не влияют на другие потоки.

  • Независимость: каждый поток имеет собственную независимую копию переменной, и операции чтения/записи между разными потоками не мешают друг другу.
  • Жизненный цикл:thread_localПеременная автоматически уничтожается при завершении её потока.
  • Инициализация:thread_localПеременные могут быть статически или динамически инициализированы и поддерживают инициализацию при объявлении.

thread_local подходит для сценариев, в которых необходимо хранить состояние потока, кэши или избегать гонок данных, например, пулы потоков, контексты запросов и т. д.

Ниже показаны переменные, которые можно объявить как thread_local:

#include <iostream> #include <thread> thread_local int threadSpecificVar = 0; // У каждого потока есть собственная threadSpecificVar void threadFunction(int id) { threadSpecificVar = id; // Задать переменную для конкретного потока std::cout << "Thread " << id << ": threadSpecificVar = " << threadSpecificVar << std::endl; } int main() { std::thread t1(threadFunction, 1); std::thread t2(threadFunction, 2); t1.join(); t2.join(); return 0; }

Примечания:

  • Производительность: поскольку каждый поток имеет независимую копию,thread_localСкорость доступа к переменной может быть немного ниже, чем у глобальных или статических переменных.
  • Статическое хранение:thread_localТип хранения переменной — статическое время жизни, поэтому она существует на протяжении всего времени выполнения программы.
Другие расширения