Как объявить константу в классе
Константные переменные — это такие переменные, которые непеременные переменные. Смысл константных сущностей — хранение одного и того же значения внутри своей личины. Понять это, как правило, легко, сложнее новичку принять, что они очень полезны. В случае с обычными переменными константы объявлять и использовать относительно просто. В случае с классами немного всё сложнее. Чтобы никого не запутать, сразу обозначу, что речь идёт о тех константах, которые как обычные переменные, но о таких константах внутри классов.
|
1 2 3 4 |
class MyClass{ const int x = 100; //<--- о вот такого вида константах речь в статье const unsigned length = 200; }; |
- Требования к знаниям для понимания описываемой темы:
- Одномерный массив в C++ для начинающих
- Классы. Первое знакомство
С++ язык развивающийся. Когда-то было запрещено писать так, как показано в коде выше. Нельзя было ни инициализировать значения напрямую, ни создавать таких констант. В С++11 разрешили инициализировать значения показанным выше способом, но несмотря на это, если, например, попробовать завернуть массив в класс, код компилироваться не будет:
Для проверки требуется поддержка от С++11
|
1 2 3 4 5 6 7 |
//Листинг #1 clang class MyArray{ const int N = 10; //<-- несмотря на то, что здесь всё хорошо int arr[N]; //<---здесь ошибка компиляции }; int main(){} |
Если ваш компилятор уже устаревший или настроен на компиляцию под устаревшие стандарты, то ошибку компиляции спровоцирует само объявление константы в таком виде. Как упоминалось, до некоторого времени так константы объявлять было нельзя. Но тем не менее, кому-то обязательно хочется использовать такой массив. Путей на самом деле несколько, один из которых — использовать указатель, на который завязать конструктор и деструктор, выделять память и чистить память вручную, например. Но С++ позволяет избрать путь попроще: использовать константы. Только-лишь к написанию самих констант нужно подойти немного иначе. Есть как минимум два варианта:
- Использовать enum
- Использовать static
Прямой путь ведёт к ошибкам компиляции, потому что сам по себе класс только описывает будущий объект, но не создаёт объекта, а константа требует себе значения существующего. Получается несходство. Пока объект не создан, хранит значение не в чем, а если нет хранилища, то константа не может взять значение, которого нет по причине отсутствия хранилища.
Использование перечисления enum оказывается очень удобным вариантом решения подобной проблемы.
|
1 2 3 4 5 6 7 8 9 |
//Листинг #2 константные переменные внутри класса #include <iostream> class MyArray{ enum {N=10}; //<-- теперь всё хорошо; int arr[N]; //<--- это работает! }; int main(){} |
Перечисления как классы могут иметь собственную область видимости. В листинге #2 как и прежде объект не создаётся, а только описывается. Доступ к такой константе можно получить с помощью операции разрешения контекста (двойного двоеточия).
Создадим такой массив:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 |
//Листинг #3.1 enum в качестве константы для переменных класса #include <iostream> using namespace std; class MyArray{ public: enum {N=10}; //<-- несмотря на то, что здесь всё хорошо; int arr[N]; //<---здесь ошибка компиляции }; int main(){ MyArray obj; for (int i=0; i<MyArray::N; i++) obj.arr[i] = i; for (int i=0; i<MyArray::N; i++) cout << obj.arr[i] << " "; cin.get(); } |
Листинг #3.1 стоило написать немного иначе, но я специально не стал ничего закрывать, чтобы было наглядно. Использованием двойного двоеточия к имени класса мы смогли вытащить константу, описанную в классе. Этот код будет работать во всех компиляторах. Исключение очень-очень старые, но там проблема не с перечислением, а с использованием заголовочных файлов и отсутствии пространства имён. Сам подход рабочий и этот путь верен для любого компилятора С++ вообще, но с условием, что константа будет целым числом.
Немного усложним код, сделав его более верным. Если код будет сложно понять, то его пока что можно пропустить. Он делает всё то же самое, но применяется чуть более верный подход.
- Для понимания кода нужно знать:
Параметры функции в C++ для начинающих
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 |
//Листинг #3.2 enum в качестве константы для переменных класса #include <iostream> using namespace std; class MyArray{ enum {N=10}; //<-- несмотря на то, что здесь всё хорошо; int arr[N]; //<---здесь ошибка компиляции public: int get_arr_size() const{ return N; //<--вытаскиваем константу } void set_value(const int position, const int value){ //функция записи значений в массив arr[position] = value; } int get_value(const int position) const{ //функция, вытаскивающая значения из массива return arr[position]; } }; int main(){ MyArray obj; const int MaxLen = obj.get_arr_size(); //<--запоминаем значение в отдельное хранилище for (int i=0; i<MaxLen; i++){ //<--- С помощью цикла obj.set_value(i, i+10); //записываем значения в массив объекта } for (int i=0; i<MaxLen; i++){ cout << "arr[" << i << "] == " << obj.get_value(i) << '\n'; //<--красиво выодим информацию на экран } cin.get(); } |
Иногда может быть удобно использовать немного другое описание класса:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 |
//Листинг #3.3 enum в качестве константы класса #include <iostream> using namespace std; class MyArray{ enum {N=10}; //<-- несмотря на то, что здесь всё хорошо; int arr[N]; //<---здесь ошибка компиляции public: int get_arr_size() const{ return N; //<--вытаскиваем константу } void set_value(const int position, const int value){ //функция записи значений в массив arr[position] = value; } void show(){ for (int i=0; i<N; i++){ cout << "arr[" << i << "] == " << arr[i] << '\n'; //<--красиво выодим информацию на экран } } }; int main(){ MyArray obj; const int MaxLen = obj.get_arr_size(); //<--запоминаем значение в отдельное хранилище for (int i=0; i<MaxLen; i++){ //<--- С помощью цикла obj.set_value(i, i+10); //записываем значения в массив объекта } obj.show(); //<-- можно сделать и так cin.get(); } |
Как бы вы ни делали, вы должны уловить саму суть того, что перечисление enum прекрасно справляется с ролью задания констант переменным класса.
Не забывайте и о том, что enum — это не отдельная константа, а список констант.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 |
//Листинг #4 class MyClass{ public: enum {ROW = 3, COL = 4}; //<-- перечисление констант int arr[ROW][COL]; //двумерный массив }; int main(){ MyClass my_object; const int ROW = MyClass::ROW; const int COL = MyClass::COL; int index = 0; for (int i=0; i<ROW; i++){ for (int j=0; j<COL; j++){ my_object.arr[i][j] = index++; } } } |
Не очень хочется громоздить кодами, да и вам подспорье переписать по подобию третьих листингов. Мысль только в том, что константы можно задавать одним списком в enum, после чего их использовать как самые обычные const значения.
К сожалению, на перечислениях enum постоянно какие-нибудь ограничения: это целочисленные константы. Коль скоро это целочисленные константы, на все случаи жизни они подойти не смогут. Второй способ использования констант в классе состоит в том, чтобы использовать static-константы. Статические переменные классов на самом деле глобальные переменные, но сокрытые областью видимости классов. Это можно удобно использовать для имитации константного элемента класса.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 |
//Листинг #5 static const для переменной класса #include <iostream> using std::cout; class MyClass{ public: static const int N = 10; //Навешивание static на const помогает int arr[N]; }; int main(){ MyClass my_object; const int MAX_LEN = MyClass::N; //запоминаем for (int i=0; i<MAX_LEN; i++) my_object.arr[i] = i; //записываем значения for (int i=0; i<MAX_LEN; i++) cout << "arr[" << i << "] == " << my_object.arr[i] << '\n'; //выводим значения } |
По использованию никаких отличий. Различие сокрыто только в том, что enum в показанном способе объекта не создаёт, а статическая переменная значит, что объект будет создан. Перечисление enum просто переписывает встречаемые обозначения на указанные значения.
Очень многие кодеры не запоминают значения в отдельную переменную, а сокращают их. Вот некоторые способы:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 |
//Листинг #6.1 #include <iostream> using std::cout; class MyClass{ public: enum {N = 10}; //Навешивание static на const помогает int arr[N]; }; int main(){ MyClass my_object; // int& MAX_LEN = MyClass::N; //Ошибка, потому что ссылка, привязанная к константному значению, должна быть константой const int& MAX_LEN = MyClass::N; //константной ссылкой сократили for (int i=0; i<MAX_LEN; i++) my_object.arr[i] = i; //записываем значения for (int i=0; i<MAX_LEN; i++) cout << "arr[" << i << "] == " << my_object.arr[i] << '\n'; //выводим значения } |
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 |
//Листинг #6.2 #include <iostream> using std::cout; class MyClass{ public: enum {N = 10}; //Навешивание static на const помогает int arr[N]; }; int main(){ MyClass my_object; // int& MAX_LEN = MyClass::N; //Ошибка, потому что ссылка, привязанная к константному значению, должна быть константой const int& MAX_LEN = MyClass::N; //константной ссылкой сократили for (int i=0; i<MAX_LEN; i++) my_object.arr[i] = i; //записываем значения for (int i=0; i<MAX_LEN; i++) cout << "arr[" << i << "] == " << my_object.arr[i] << '\n'; //выводим значения } |
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 |
//Листинг #6.3 #include <iostream> using std::cout; namespace MySpace{ //<--- завернули в область видимости, поименовали область видимости названием MySpace class MyClass{ public: enum {N = 10}; //обычная константа вне класса int arr[N]; }; } //закрыли пространство int main(){ MySpace::MyClass my_object; enum {MAX_LEN = MySpace::MyClass::N}; //можно сократить и вот так, если значение целое число for (int i=0; i<MAX_LEN; i++) my_object.arr[i] = i; //записываем значения for (int i=0; i<MAX_LEN; i++) cout << "arr[" << i << "] == " << my_object.arr[i] << '\n'; //выводим значения } |
Каким бы ни был подход к конечному написанию вашего кода сейчас, моя цель не показать все возможные ситуации, о которых я и сам мало знаю, а дать понять, как можно заюзать константы внутри классов.
Резюмируем:
- Для использования констант (одна константа на весь класс):
- Можно использовать перечисление enum
- Для использования констант (одна константа на весь класс):
- Можно использовать static-константу
Что мы узнали?:
- Перечисление enum представляет из себя только описание, объектов для него не создаётся. Показанные перечислению обозначения переписываются прямо в коде.
- static-константа, используемая вутри класса, требует для себя определения: ей нужен объект. На самом деле ваш компилятор может справиться и без определения объекта, но это будет работать не во всех компиляторах
- В С++11 разрешено инициализировать значения прямо на месте внутри класса, так можно даже создать константу, но такая константа имеет некоторые ограничения, из-за чего выбор static-константы или enum иногда предпочтительнее.
Использованные материалы:
2 комментария на «“Как объявить константу в классе”»
Добавить комментарий
Случайная книга в электронном формате
Ещё можно даже использовать не
, а
Да, если компилятор поддерживает С++11.