До сих пор все переменные, которые мы видели, были непостоянными, то есть их значения можно изменить в любое время. Например:
int x < 4 >; // инициализируем x значением 4 x = 5; // меняем значение x на 5
Однако иногда бывает полезно определять переменные со значениями, которые нельзя изменить. Например, рассмотрим ускорение свободного падения у поверхности Земли: 9,8 м/с 2 . Маловероятно, что в ближайшее время оно изменится (а если это произойдет, у вас, вероятно, возникнут более серьезные проблемы, чем изучение C++). Определение этого значения как константы помогает гарантировать, что оно не будет случайно изменено.
Чтобы сделать переменную константой, просто поместите ключевое слово const до или после типа переменной, например:
const double gravity < 9.8 >; // предпочтительное использование const перед типом int const sidesInSquare < 4 >; // хорошо, но не рекомендуется
Хотя C++ принимает const до или после типа, мы рекомендуем использовать константу перед типом, потому что это лучше соответствует соглашению обычного английского языка, согласно которому модификаторы ставятся перед изменяемым объектом (например, «green ball» (зеленый шар), а не «ball green» (шар зеленый)).
Константы и переменные. Определение, сравнение и примеры. Программирование для начинающих.
Константные переменные должны быть инициализированы, когда вы их определяете, после этого это значение не может быть изменено с помощью присваивания.
Объявление переменной как const предотвращает непреднамеренное изменение ее значения:
const double gravity < 9.8 >; gravity = 9.9; // не допускается, это вызовет ошибку компиляции
Определение константной переменной без ее инициализации также вызовет ошибку компиляции:
const double gravity; // ошибка компиляции, должна быть инициализирована при определении
Обратите внимание, что константные переменные могут быть инициализированы из других переменных (включая неконстантные):
std::cout ; std::cin >> age; const int usersAge < age >; // usersAge изменить нельзя
const часто используется с параметрами функции:
void printInteger(const int myValue)
Задание параметра функции константой делает две вещи. Во-первых, это сообщает человеку, вызывающему функцию, что функция не изменит значение myValue . Во-вторых, это гарантирует, что функция не изменит значение myValue .
Когда аргументы передаются по значению, нас обычно не волнует, изменяет ли функция значение параметра (поскольку это всего лишь копия, которая в любом случае будет уничтожена в конце функции). По этой причине мы обычно не делаем константными параметры, передаваемые по значению. Но позже мы поговорим о других типах параметров функций (где изменение значения параметра приведет к изменению значения переданного аргумента). Для этих типов параметров важно разумное использование const .
Константы времени выполнения и константы времени компиляции
На самом деле C++ имеет два разных типа констант.
Константы времени выполнения – это те, значения инициализации которых могут быть вычислены только во время выполнения (когда ваша программа работает). Такие переменные, как usersAge и myValue в приведенных выше фрагментах, являются константами времени выполнения, поскольку компилятор не может определить их начальные значения во время компиляции. usersAge полагается на ввод данных пользователем (который может быть предоставлен только во время выполнения), а myValue зависит от значения, переданного в функцию (которое известно только во время выполнения). Однако после инициализации значение этих констант изменить нельзя.
Что такое переменная в программировании.
Константы времени компиляции – это те, чьи значения инициализации могут быть вычислены во время компиляции (когда ваша программа компилируется). Переменная gravity выше является примером постоянной времени компиляции. Константы времени компиляции позволяют компилятору выполнять оптимизацию, недоступную для констант времени выполнения. Например, всякий раз, когда используется gravity , компилятор может просто заменить идентификатор gravity литералом 9.8 типа double .
Когда вы объявляете константную переменную, компилятор неявно отслеживает, является ли она константой времени выполнения или константой времени компиляции.
В большинстве случаев это не имеет значения, но есть несколько странных случаев, когда C++ требует константу времени компиляции вместо константы времени выполнения, например, при создании экземпляра типа – о чем мы поговорим позже.
constexpr
Чтобы обеспечить большую конкретность, в C++11 введено ключевое слово constexpr , которое гарантирует, что константа должна быть константой времени компиляции:
constexpr double gravity < 9.8 >; // хорошо, значение 9,8 может быть определено во время компиляции constexpr int sum < 4 + 5 >; // хорошо, значение 4 + 5 может быть определено во время компиляции std::cout ; std::cin >> age; constexpr int myAge < age >; // плохо, age не может быть определен во время компиляции
Переменные constexpr являются константными. Это станет важным, когда мы поговорим о других влияниях const в следующих уроках.
Лучшая практика
Любую переменную, которую нельзя изменять после инициализации, и инициализатор которой известен во время компиляции, следует объявлять как constexpr .
Любую переменную, которую нельзя изменять после инициализации, и инициализатор которой неизвестен во время компиляции, следует объявлять как const .
Именование ваших константных переменных
Некоторые программисты для константных переменных предпочитают использовать имена полностью из заглавных букв. Другие используют обычные имена переменных с префиксом ‘ k ‘. Однако мы будем использовать обычные соглашения об именах переменных, которые встречаются чаще. Константные переменные действуют точно так же, как обычные переменные во всех случаях, за исключением того, что им не может быть присвоено другое значение, поэтому нет особой причины, по которой они должны обозначаться как-то по-особенному.
Символьные константы
В предыдущем уроке «4.13 – Литералы» мы обсуждали «магические числа», которые представляют собой литералы, используемые в программе для представления постоянного значения. Что делать, если магические числа – это плохо? Ответ: используйте символические константы! Символьная константа – это имя, данное константному литеральному значению.
В C++ есть два способа объявить символьную константу. Один из них хороший, а один нет. Мы покажем вам оба.
Плохое решение: использование объекто-подобных макросов с параметром подстановки в качестве символьных констант
Сначала мы покажем вам менее желательный способ определения символьной константы. Этот метод обычно использовался во многих старых кодах, поэтому вы всё еще можете его увидеть.
В уроке «2.9 – Знакомство с препроцессором» вы узнали, что у объекто-подобных макросов есть две формы: одна не принимает параметр подстановки (обычно используется для условной компиляции), а другая имеет параметр подстановки. Здесь мы поговорим о случае с параметром подстановки. Он имеет следующую форму:
#define идентификатор подставляемый_текст
Каждый раз, когда препроцессор встречает эту директиву, любое дальнейшее появление идентификатора заменяется на подставляемый_текст . Идентификатор традиционно набирается заглавными буквами с использованием подчеркивания для обозначения пробелов.
Рассмотрим следующий фрагмент:
#define MAX_STUDENTS_PER_CLASS 30 int max_students < numClassrooms * MAX_STUDENTS_PER_CLASS >;
Когда вы компилируете свой код, препроцессор заменяет все экземпляры MAX_STUDENTS_PER_CLASS литеральным значением 30, которое затем компилируется в ваш исполняемый файл.
Вы, вероятно, согласитесь, что это по нескольким причинам гораздо более интуитивно понятно, чем использование магического числа. MAX_STUDENTS_PER_CLASS даже без комментария предоставляет контекст для того, что программа пытается сделать. Во-вторых, если количество студентов в классе изменяется, нам нужно изменить значение MAX_STUDENTS_PER_CLASS только в одном месте, и все экземпляры MAX_STUDENTS_PER_CLASS при следующей компиляции будут заменены новым литеральным значением.
Рассмотрим наш второй пример с использованием символьных констант #define :
#define MAX_STUDENTS_PER_CLASS 30 #define MAX_NAME_LENGTH 30 int max_students < numClassrooms * MAX_STUDENTS_PER_CLASS >; setMax(MAX_NAME_LENGTH);
В этом случае очевидно, что MAX_STUDENTS_PER_CLASS и MAX_NAME_LENGTH должны быть независимыми, даже если они имеют одно и то же значение (30). Таким образом, если нам нужно обновить размер класса, мы не сможем случайно изменить длину имени.
Так почему бы не использовать #define для создания символьных констант? Есть (по крайней мере) три основных проблемы.
Во-первых, поскольку макросы вычисляются препроцессором, который заменяет символьное имя определенным значением, символьные константы, определенные через #define , не отображаются в отладчике (который показывает ваш фактический код). Таким образом, хотя компилятор будет компилировать int max_students ; , в редакторе кода вы увидите int max_students ; , и MAX_STUDENTS_PER_CLASS не будет отслеживаться в отладчике. Вам нужно будет найти определение MAX_STUDENTS_PER_CLASS , чтобы узнать его фактическое значение. Это может затруднить отладку ваших программ.
Во-вторых, макросы могут конфликтовать с обычным кодом. Например:
#include «someheader.h» #include int main() < int beta < 5 >; std::cout
Если в someheader.h появляется определение с помощью #define макроса с именем beta , эта простая программа сломается, так как препроцессор заменит имя целочисленной переменной beta на какое-то значение макроса.
В-третьих, макросы не подчиняются обычным правилам области видимости, что означает, что в редких случаях макрос, определенный в одной части программы, может конфликтовать с кодом, написанным в другой части программы, с которой он не должен был взаимодействовать.
Предупреждение
Избегайте использования #define для создания макросов символьных констант.
Лучшее решение: используйте переменные constexpr
Лучший способ создать символьные константы – использовать переменные constexpr :
constexpr int maxStudentsPerClass < 30 >; constexpr int maxNameLength < 30 >;
Поскольку это обычные переменные, они доступны для отслеживания в отладчике, имеют обычную область видимости и позволяют избежать других странных форм поведения.
Лучшая практика
Используйте переменные constexpr , чтобы указать имя и контекст для ваших магических чисел.
Использование символьных констант в программе с несколькими исходными файлами
Во многих приложениях заданная символьная константа должна использоваться во всем коде (а не только в одном месте). Сюда могут входить неизменяемые физические или математические константы (например, число Пи или число Авогадро) или значения «настройки» для конкретного приложения (например, коэффициенты трения или силы тяжести). Вместо того чтобы переопределять их каждый раз, когда они необходимы, лучше объявить их один раз в центре и использовать везде, где это необходимо. Таким образом, если вам когда-нибудь понадобится изменить их, вам нужно будет изменить их только в одном месте.
В C++ есть несколько способов облегчить это, но, вероятно, самый простой из них будет следующим:
- создать заголовочный файл для хранения этих констант;
- внутри этого заголовочного файла объявить пространство имен (мы поговорим об этом подробнее в уроке «6.2 – Пользовательские пространства имен»);
- добавить все свои константы в это пространство имен (убедитесь, что они constexpr в C++11/14 или inline constexpr в C++17 или новее);
- включить с помощью #include этот заголовочный файл везде, где он вам нужен.
#ifndef CONSTANTS_H #define CONSTANTS_H // определяем собственное пространство имен для хранения констант namespace constants < constexpr double pi < 3.14159 >; constexpr double avogadro < 6.0221413e23 >; constexpr double my_gravity < 9.2 >; // m/s^2 — ускорение свободного падения // на этой планете меньше // . другие связанные константы > #endif
В C++17 лучше использовать inline constexpr :
constants.h (C++17 или новее):
#ifndef CONSTANTS_H #define CONSTANTS_H // определяем собственное пространство имен для хранения констант namespace constants < inline constexpr double pi < 3.14159 >; // inline constexpr — только для C++17 или новее inline constexpr double avogadro < 6.0221413e23 >; inline constexpr double my_gravity < 9.2 >; // m/s^2 — ускорение свободного падения // на этой планете меньше // . другие связанные константы > #endif
Для доступа к этим константам в файлах .cpp используйте оператор разрешения области видимости ( :: ):
#include «constants.h» #include int main() < std::cout ; std::cin >> radius; double circumference < 2.0 * radius * constants::pi >; std::cout
Если у вас есть и физические константы, и значения настроек для каждого приложения, вы можете выбрать использование двух наборов файлов: один для физических значений, которые никогда не изменятся, а другой для специфичных значений настроек отдельно для каждой программы. Таким образом, вы можете повторно использовать физические значения в любой программе.
Источник: radioprog.ru
Как объявить переменную в Java? Инициализация переменной в Java. Константы в Java
В этой статье мы рассмотрим, что такое Java-переменные, что значит инициализация переменных, а также как объявлять константу и зачем вообще нужны переменные и константы в Java.
Переменная — это контейнер, содержащий какое-либо значение. При этом под переменным значением понимают строковое, числовое или логическое значение. Само определение говорит нам о том, что переменная может изменяться по ходу выполнения программы. А вот если у нас задана константа, то это значение меняться не может. Но давайте обо всём по порядку.
Виды переменных в Java
Существуют следующие типы переменных в Java: 1) примитивные (целые — byte, short, char, int, long; дробные или с плавающей точкой — float, double, логические — boolean); 2) ссылочные (создаются с применением конструкторов классов и нужны для доступа к объектам).
Так как Java является строго типизированным языком программирования, каждая переменная, объявляемая разработчиком, должна иметь связанный с переменным значением тип данных.
Как объявлять переменные в Java?
Перед использованием переменной нужно её объявить. Для объявления переменной в Java используют следующий синтаксис:
тип данных переменная [ = значение], [переменная [= значение], . ] ;
Идём дальше: если нужно объявить больше чем одну переменную указанного типа, допускается применение списка с запятыми:
int a, b, c; // объявление трёх целых переменных a, b и c
Инициализация переменной
Перед использованием переменной, нужно задать ей начальное значение. Этот процесс называется инициализация. Без инициализации мы можем получить ошибку во время выполнения программы, поэтому инициализация очень важна.
Для инициализации переменной используют оператор присваивания. Слева указывается имя переменной, справа её значение.
Вот пример инициализации:
int x = 10; // объявление и инициализация переменной System.out.println(x); // 10
Ниже посмотрим другие примеры инициализации и объявления переменных в Java:
int a = 10, b = 10; // Пример инициализации переменных double pi = 3.14159; // Объявление переменной pi и присвоение ей величины «пи» byte b = 22; // Инициализация переменной b типа byte char a = ‘a’; // Переменной a типа char присваиваем значение ‘a’
Типы переменных в Java
Продолжаем наш небольшой урок для начинающих, посвящённый инициализации переменных в Java. Итак, можно выделить 3 типа переменных: — локальные; — статические (переменные класса); — переменные экземпляра.
Теперь давайте рассмотрим их подробнее.
Локальные переменные в Java
Свойства локальных переменных: — объявляются в методах, блоках или конструкторах; — создаются, когда метод, блок или конструктор запускаются; — уничтожаются после завершения метода, конструктора либо блока; — видимы лишь в пределах объявленного метода, блока либо конструктора; — реализуются на уровне стека внутри; — в Java не существует значений по умолчанию для локальных переменных, поэтому они должны объявляться и проходить этап инициализации непосредственно перед первым использованием; — для переменной нельзя использовать модификаторы доступа.
Пример локальных переменных
Итак, «age» — это наша переменная, определяемая внутри метода pupAge() , причём область её действия ограничивается лишь этим методом:
public class Test < public void pupAge()< int age = 0; age = age + 7; System.out.println(«Возраст собаки: » + age); >public static void main(String args[]) < Test test = new Test(); test.pupAge(); >>
В итоге мы получим следующий результат:
Возраст собаки: 7
Пример локальных переменных без инициализации
Переменные и константы в Python
В этой статье вы узнаете о переменных и константах в Python, вариантах их объявления и использования.
Переменные в Python
В большинстве языков программирования переменная является именованным местоположением, используемым для хранения данных в памяти. Каждая переменная должна иметь уникальное имя, называемое идентификатором. Принято думать о переменных как о контейнерах, которые содержат данные и эти данные могут быть извлечены или изменены позже, во время программирования.
Вы можете считать переменную сумкой для хранения в ней чего либо, и это что то можно извлечь или заменить в любое время.
Объявление переменных в Python
В отличии от других языков программирования, в Python переменные не нуждаются в объявлении для резервирования места в памяти. «Объявление переменной» или «инициализация переменной» происходит автоматически, когда мы присваиваем значение переменной.
Присвоение значения переменной в Python
Вы можете использовать оператор присваивания =, чтобы присвоить значение переменной.
Пример 1: Объявление и присвоение значения переменной
message = ‘hello’
В данном примере мы присвоили переменной message значение hello. Чтобы вывести значение переменной на экран нужно вызвать функцию print()
print(message)
Вы увидите следующее:
hello
Вам не нужно указывать тип переменной во время присвоения значения. Python язык с динамической типизацией, поэтому на этапе присвоения интерпретатор «понял» что переменная message имеет тип str (string, строка). При этом, далее вы можете присвоить этой переменной значение 123 и ее тип автоматически сменится на int (integer, число).
Пример 2: изменение значения переменной, изменение типа переменной
message = ‘bye’ print(message) print(type(message)) message = 123 print(message) print(type(message))
В этом примере мы сначала изменили значение на другую строку, затем присвоили переменной значение типа int. Как видите никаких ошибок это не спровоцировало.
Пример 3: Присвоение нескольких значений нескольким переменным на одной строке
Иногда можно присваивать значения сразу нескольким переменным на одной строке:
a, b, c = 1, ‘hello’, 12
Эта запись то же самое что и:
a = 1 b = ‘hello’ c = 12
Не стоит злоупотреблять этим способом, он несколько снижает читабельность кода.
Если мы хотим присвоить одно и то же значение нескольким переменным одновременно, мы можем сделать следующим способом:
a = b = c = 15
В результате, все три переменные будут типа int и содержать в себе значение 15.
Константы в Python
Константа — это тип переменной, значение которой нельзя изменить на протяжении всего жизненного цикла программы. Однако в Python, это носит скорее рекомендательный характер. Дело в том, что в отличии от многих языков программирования, в которых присвоение нового значения константе вызовет ошибку, в Python значение константы может быть изменено и это не вызовет вопросов со стороны интерпретатора.
При объявлении константы вы как бы говорите себе и другим программистам которые возможно будут читать ваш код «Значение этой переменной не должно меняться на протяжении всего цикла работы программы!».
Как объявить константу в Python
Как и обычная переменная (а константа в Python, технически, это обычная переменная) константа инициализируется в момент присвоения ей значения:
PI = 3.14
Имя константы пишется в верхнем регистре (PI, MESSAGE и т.д.) с целью выделить ее, дать понять что это именно константа и ее значение должно оставаться неизменным. Если в имени присутствуют два или больше слов, то они разделяются символом подчеркивания (WELCOME_MESSAGE).
Источник: programfiles.info