В этой статье по C++ мы еще больше раскроем тему переменных и рассмотрим квалификаторы типов и классы хранения в C++. Хотя это небольшая тема, но она очень важна и значительна для программирования на C++.
Квалификаторы типов в C++ не меняют значения переменных или сущностей, с которыми они используются, а лишь добавляют дополнительную информацию к сущности.
Квалификаторы типов в C++
Квалификаторы типов в C++ добавляют к переменной дополнительные свойства. Квалификаторы типов выражают способ доступа к переменной или место ее хранения в памяти, сохраняя значение или интерпретацию переменной прежней. В каком-то смысле квалификаторы типов добавляют уточнения к переменным.
В C++ квалификатор типов указывается непосредственно перед спецификатором типа (типом данных) переменной.
Квалификаторы типов в C++:
1) const
Спецификатор типа «const» предназначен для определения объектов типа const. Константный объект или переменная не могут быть изменены после объявления. При попытке модифицировать константный объект или переменную компилятор выдает ошибку. Мы уже видели константы/литералы в нашей предыдущей статье.
Определение констант с использованием ключевого слова const соответствует квалификатору типа const.
2) volatile
Квалификатор типа «volatile» означает, что значение переменной, помеченной как volatile, может быть изменено другими способами, не указанными в программе. Изменяемые переменные обычно изменяются из-за каких-то внешних факторов и не обязательно из-за программы. Другими словами, они изменчивы по своей природе.
Например, переменная, которая считывает температуру в реальном режиме, может быть сделана энергозависимой, поскольку считываемая температура может не полностью контролироваться программой.
3) mutable
Квалификатор типа «mutable» делает члены или переменную изменяемыми.
Квалификатор mutable обычно применяется к нестатическим членам класса неконстантного и не ссылочного типа. В зависимости от конкретных ситуаций, нам может потребоваться, чтобы некоторые переменные оставались неизменными (не могли быть изменены), а некоторые переменные были изменяемыми. Этот тип квалификатора очень помогает, когда нам нужны изменяемые характеристики.
Классы хранения в C++
До сих пор мы подробно обсуждали все переменные C++, и вы видели, что переменные объявляются с соответствующими типами данных, а затем используются в программе. Чтобы полностью определить переменную, нам также потребуются классы хранения, помимо их типов данных.
Хотя мы до сих пор не указывали классы хранения для переменных, был класс хранения по умолчанию «auto», который применялся ко всем переменным.
Так что же такое классы хранения?
Классы хранения определяют, как компилятор должен обрабатывать переменную или функцию, и как память должна быть выделена для переменной. Он определяет видимость или область действия и время жизни переменной. Время жизни переменной — это то, как долго переменная будет оставаться активной.
Видимость или область действия переменной — это то, для каких функций или модулей она будет доступна. Эти классы хранения указываются перед типом данных переменной.
В C++ у нас есть следующие классы хранения:
1) Класс автоматического хранения
Это класс хранилища по умолчанию. Класс хранения «auto» применяется к локальным переменным и автоматически назначается компилятором локальным переменным. Локальные переменные, которым предшествует ключевое слово auto, остаются активными в функции, в которой они объявлены, и выходят из области видимости после выхода из функции.
Если переменные с классом хранения «auto» не инициализированы и им не присвоено какое-либо значение, то они имеют мусорные или неопределенные значения.
Давайте посмотрим на пример автоматических переменных в программе на C++:
|
1 2 3 4 5 6 7 8 9 10 |
#include <iostream> using namespace std; int main() { int i; float f; cout<<"Variable i = "<<i<<endl; cout<<"Variable f = "<<f<<endl; return 0; } |
Вывод данных:
- Variable i = 0
- Variable f = 0
Теперь мы видим, что I и f — это две локальные переменные, которые мы определили в функции main с классом хранения по умолчанию «auto».
Поскольку мы не присвоили им никаких значений, то они обе имеют значения = 0. Это полностью зависит от компилятора в отношении того, какие значения присваивать автоматической локальной переменной, если им еще не присвоено какое-либо значение в программе.
Начиная с C++ ключевое слово auto используется для определения типа. Это означает, что мы можем использовать такой код, как auto i=10, а тип данных I будет напрямую выведен из инициализатора, используемого для i. Следовательно, если мы объявим что-то вроде ‘auto float f;’, компилятор выдаст ошибку.
Таким образом, мы обычно не используем объявление для класса хранения auto, так как подразумевается, что по умолчанию всегда будет класс хранения auto.
2) Класс хранения регистров
Когда у нас есть требование, чтобы переменная нуждалась в более быстром доступе, мы используем класс хранения регистров. Таким образом, вместо хранения переменных в оперативной памяти (ОЗУ) эти переменные хранятся в регистре ЦП и имеют размер, равный размеру регистра.
Кроме того, поскольку эти переменные не имеют ячейки памяти, мы не можем использовать оператор ‘ & ‘ с этими переменными.
Наличие переменной с классом хранения Register не гарантирует, что переменная всегда будет храниться в нем. Вместо этого он просто предполагает, что переменная может быть сохранена в регистре и полностью зависит от аппаратного обеспечения и реализации.
Переменные регистра имеют область действия и время жизни, аналогичные автоматическим переменным.
Например,
|
1 2 3 4 5 6 7 8 9 10 |
#include <iostream> using namespace std; int main() { int i; register float f; cout<<"Variable i = "<<i<<endl; cout<<"Variable f = "<<f<<endl; return 0; } |
Приведенный выше код с одной регистровой переменной даст тот же результат, что и код с автоматическим классом хранения.
Вывод данных:
- Variable i = 0
- Variable f = 0
3) Класс внешнего хранилища
Класс хранения extern требуется, когда переменные должны быть общими для нескольких файлов. Внешние переменные имеют глобальную область видимости, и эти переменные видны за пределами файла, в котором они объявлены.
Поскольку внешние переменные — это переменные, объявленные и определенные снаружи в другом файле, они не инициализируются.
Внешние переменные имеют глобальную область действия, и время жизни внешних переменных равно продолжительности программы, в которой они объявлены как завершенные.
Внешние переменные могут быть объявлены следующим образом:
|
1 2 |
extern int temp; int temp; |
В приведенном выше примере у нас есть два объявления переменных с одинаковыми именами, но первое из них — переменная extern, определенная в другом месте. Эта переменная extern будет полезна, когда мы включим в нашу программу исходный файл, в котором определена переменная extern temp.
4) Статический класс хранения
Статический класс хранения указывает компилятору сохранять значение переменной на протяжении всего жизненного цикла программы. Статические переменные аналогичны локальным переменным, но им предшествует ключевое слово ‘static’.
В отличие от локальных переменных, которые выходят из области видимости после выхода из функции, статические переменные не выходят из области видимости при выходе из функции или блока, и их значения сохраняются между вызовами функций.
Статические переменные инициализируются, и память для них выделяется только один раз за время жизни программы. Статические переменные инициализируются 0, если они уже не инициализированы во время объявления.
Давайте посмотрим на следующий пример, чтобы лучше понять класс статического хранилища:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 |
#include <iostream> using namespace std; void printvar() { static int var; var++; cout<<"static variable var = "<<var<<endl; } int main() { cout<<"printvar call 1: "; printvar(); cout<<"printvar call 2: "; printvar(); cout<<"printvar call 3: "; printvar(); cout<<"printvar call 4: "; printvar(); return 0; } |
Вывод данных:
- printvar call 1: static variable var = 1
- printvar call 2: static variable var = 2
- printvar call 3: static variable var = 3
- printvar call 4: static variable var = 4
В приведенном выше коде у нас есть функция printvar, в которой мы объявили статическую переменную var типа int. Затем мы увеличиваем эту переменную и печатаем ее. В основной функции мы вызываем функцию printvar четыре раза.
Теперь проверьте вывод. Вывод показывает, что при каждом вызове функции статическая переменная var увеличивается на 1 по сравнению с предыдущим значением. Это статический класс хранения, который помогает переменной сохранять свое значение между вызовами функций. Статическая переменная не инициализируется повторно при каждом вызове функции.
Также должны заметить, что в функции printvar мы только объявили статическую переменную, а не инициализировали ее. Примечательно, что когда мы не инициализируем статические переменные, им присваивается начальное значение 0.
Статический класс хранения также можно применять к глобальным переменным. В этом случае переменная будет иметь глобальную область видимости и дополнительное статическое хранилище.
5) Изменяемый класс хранения
Класс изменяемого хранилища применяется только к объектам класса. Применяя изменяемый класс хранения, член объекта может переопределить функцию-член ‘const’. Это означает, что изменяемый элемент или объект может быть изменен функцией-членом, которая является «const».
Вы узнаете больше о константных функциях и объектах, а также об изменяемых членах в наших следующих статьях, когда будем изучать объектно-ориентированное программирование на C++.
Вывод
На этом наша статья о спецификаторах типов и классах хранения в C++ заканчивается. Мы надеемся, что нам удалось прояснить все концепции классов хранения и спецификаторов типов.
В нашей следующей статье мы расскажем о различных операторах, используемых в C++, а также об их использовании.
С Уважением, МониторБанк