Какие управляющие символьные константы описаны верно. Управляющие символьные константы
В языке Си символы заключаются в апострофы. Поэтому, когда мы присваиваем какое-то значение переменной broiled типа char , мы должны писать
broiled = " Т "; /* ПРАВИЛЬНО */,
broiled = Т; /* НЕПРАВИЛЬНО */
Если апострофы опущены, компилятор "считает", что мы используем переменную с именем Т , которую забыли описать.
В стандарте языка Си принято правило, согласно которому значениями переменной или константы типа char могут быть только одиночные символы. В соответствии с этим последовательность операторов, указанная ниже, является недопустимой, поскольку там делается попытка присвоить переменной bovine значение, состоящее из двух символов:
ehar bovine;
bovine = " ox "; /*НЕПРАВИЛЬНО */
Если вы посмотрите на таблицу кода ASCII, то увидите, что некоторые из "символов" в ней не выводятся на печать. Например, при использовании в программе символа номер 7 терминал компьютера издает звуковой сигнал. Но как использовать символ, который невозможно набрать на клавиатуре? В языке Си для этого имеются два способа.
В первом способе используется сам код ASCII. Вы должны только указать номер символа вместе с предшествующим знаком "обратная косая черта". Мы уже делали это в нашей программе "золотой эквивалент". Вот эта строка
beep = " 07 ";
Здесь имеются два важных момента, которые вы должны отчетливо представлять себе. Первый - это то, что последовательность знаков заключается в апострофы точно так же, как это делается с обычным символом. Второе - то, что номер символа должен быть записан в восьмеричном виде. При записи последовательности знаков мы можем случайно пропустить нули в первых позициях; в этом случае для представления кода "сигнал" мы могли бы использовать "7" или даже "7" . Но ни в коем случае не опускайте в записи последние нули! Последовательность символов "20" можно записать в виде "20" , но не "2" .
При использовании кода ASCII необходимо отметить различие между числами и символами, обозначающими числа. Например, символу "4" соответствует код ASCII, равный 52. Это символ "4" а не число 4.
РИС. 3. 4. Формы записи констант целых типов
Во втором способе представления "неудобных" знаков используются специальные последовательности символов. Они называются управляющими последовательностями и выглядят следующим образом:
t табуляция
b шаг назад
r возврат каретки
f подача бланка
обратная косая черта ()
" апостроф (")
" кавычки (")
При присваивании символьной переменной эти последовательно сти тоже должны быть заключены в апострофы. Например, мы могли бы написать оператор
nerf = " n ";
а затем вывести на печать переменную nerf; это приведет к продвижению на одну строку вперед на печатающем устройстве или на экране дисплея.
Первые пять управляющих последовательностей являются общепринятыми символами, предназначенными для управления работой печатающего устройства:
символ "новая строка" вызывает переход к новой строке;
символ "табуляция" сдвигает курсор или печатающую головку на некоторое фиксированное число позиций 5 или 8;
символ "шаг назад" производит сдвиг назад на одну позицию;
символ "возврат каретки" осуществляет возврат к началу строки;
символ "подача бланка" вызывает протяжку бумаги на одну страницу.
В последних трех управляющих последовательностях символы , " , " можно считать символьными константами [поскольку они служат для определения символьных констант и непосредственно используются в операторе printf() , применение их самих в качестве символов могло бы привести к ошибке]. Если вы хотите вывести на печать строку.
Запомните, " символ называется обратная косая черта".
оператор будет выглядеть так:
printf(" Запомните, " символ называется обратная косая черта. " n");
Здесь у вас могут возникнуть два вопроса. Во-первых, почему мы не заключили управляющие последовательности в апострофы? Во-вторых, в каких случаях необходимо использовать код ASCII и когда управляющие последовательности, которые мы только что обсуждали? (Мы надеемся, что у вас возникли как раз эти вопросы, ПОТОМУ что мы собираемся отвечать именно на них.)
Лабораторная работа №1
Знакомство с языком программирования С++
Цель работы:
1. Изучение интерфейса программной оболочки Visual C++;
2. Компиляция и создание исполняемых файлов.
3. Изучение основных типов данных языка С++;
Базовые типы данных;
Переменные и константы;
4. Изучение операторов:
Арифметических;
Логических;
Сравнения;
Побитовых;
Ввода и вывода.
5. Приобретение навыков работы в ИСП Microsoft Visual C++ 5.0.
Используемое оборудование:
Персональная ЭВМ, совместимая с IBM PC.
Используемое программное обеспечение:
Операционная система Windows;
Интегрированная среда программирования Microsoft Visual C++ 5.0 (ИСП Microsoft Visual C++ 5.0).
Задание по работе
1.1. Загрузить ИСП Microsoft Visual C++ 5.0.
1.2. Изучить команды ИСП Microsoft Visual C++ 5.0.
1.3. Изучить основные типы данных ИСП Microsoft Visual C++ 5.0.
1.4. Выполнить пример 1, пример 2, пример 3 и задание преподавателя.
1.5. Записать протокол работы с интегрированной средой.
Порядок выполнения работы
2.1. Запустить Microsoft Visual C++ 5.0.
2.2. Создать *.cpp файл в рабочем каталоге.
2.3. Выполнить пример 1, пример 2, пример 3 и задание преподавателя.
2.4. Составить схему алгоритма и написать программу (по заданию преподавателя). Записать протокол работы с интегрированной средой.
2.5. Закончить работу с Microsoft Visual C++ 5.0 и запустить программу.
3.1. Наименование лабораторной работы.
3.2. Цель работы.
3.3. Теоретическую часть.
3.4. Алгоритмы выполненных программ.
3.5. Текст выполненных программ.
3.6. Вывод.
Краткое описание работы
4.1. Запуск и работа в ИСП Microsoft Visual C++ 5.0.
Для запуска ИСП Microsoft Visual C++ 5.0 необходимо запустить меню Пуск - Microsoft Visual C++ 5.0 - Microsoft Visual C++ 5.0.
Что бы начать работать в C++ сначала необходимо создать простое консольное приложение, для этого нужно выполнить следующие действия:
Ø Запустить Visual C++ (Пуск®Программы® Microsoft Visual C++ 5.0.® Microsoft Visual C++ 5.0. );
Ø Выбрать "New" в меню "File". Проверить, что бы в диалоговой панеле "New" была выбрана закладка "Projects". В списке типов проектов выберите "Win32 Console Application";
Ø Выбрать каталог для проекта ‘Location’ (С:\students\’группа*) и имя проекта ‘Project name’, например, "First" и нажмите кнопку "OK". У вас создадутся "First classes";
Ø После этого выберите опять "New", но с закладкой "Files" и выберите "C++ Source File". В списке ‘File name’ задайте имя например, "First" Далее нажмите "OK" и создастся файл "First.cpp".
Общая структура программы.
Наша задача – рассмотреть общую структуру программы написанной на языке С/С++, то есть весь исходный текст размещается в одном файле:
Ø Область директив препроцессора (include, define..);
Ø Описание пользовательских типов данных;
Ø Неполные объявления функций;
Ø Описание глобальных переменных;
Ø Объявление функции 1;
Ø Объявление функции 2;
Ø Объявление функции main().
Данная схема не имеет такого жесткого порядка как в Паскале, однако, она считается традиционной.
Программа состоит из одной или нескольких процедур, по традиции называемых функциями. Одна функция, обязательно присутствующая в любой программе, должна называться main. Она служит точкой входа в программу и в дальнейшем вызывает другие функции.
Минимальная программа выглядит следующим образом:
Void main(void)
Она состоит из функции main, не принимающей и не возвращающей параметров (void). Тело функции, заключенное в фигурные скобки, также не содержит никаких полезных операторов.
Переменные могут быть объявлены как внутри тела функции, так и вне тела. В первом случае доступ к ним может осуществляться только из тела данной функции (локальные объявления), а во втором – из любой функции (глобальные объявления).
Выполнение программы начинается с тела функции main, которая может принимать набор значений из командной строки. В теле main содержатся вызовы других функций, как из стандартных библиотек, так и определенных пользователем в тексте программы.
Выполнение программы по умолчанию заканчивается при завершении работы main, но может прерваться в любом месте при возникновении критической ошибки, или в предусмотренном случае. Для этого обычно используют функцию exit() из библиотеки stdlib.
Вывод строки на экран
Прежде всего, давайте напишем программу, выводящую строку на экран.
Программа должна содержать функцию с именем main(). Ей приписывается роль начала программы. Эта функция не является предопределенной для транслятора, она не может быть перегружена, а ее тип зависит от реализации. Функция main может определяться так:
Пример 1:
// Первая программа на С++
#include
Void main ()
cout << “Thise is my first program\n” << endl;
Для того, чтобы выполнить программу надо ее вначале сохранить. Зайдите в меню File и там нажмите на Save All . Затем надо ее построить (скомпилировать) для этого нужно выполнить следующие действия:
Ø Зайдем в меню (Build®Build *.exe) или сочетание клавиш (F7), начнется построение программы. Если компилятор не выдал сообщение об ошибке, которые можно посмотреть в появившемся внизу окошке, то можно смело запускать программу;
Ø Теперь вам осталось только выполнить программу, для этого зайдите в меню (Build®Execute *.exe.) или сочетание клавиш (Ctrl+F5);
Ø Ваша программа запущенна.
Строка #include сообщает компилятору, чтобы он включил стандартные возможности потока ввода и вывода, находящиеся в файле iostream.h. Без этих описаний выражение cout << "Thise is my first program " не имело бы смысла. Основные стандартные библиотеки приведены в таблице 1.
Таблица 1.
Основные стандартные библиотеки С/С++
Операция << ("поместить в") пишет свой первый аргумент во второй (в данном случае, строку "Thise is my first program " в стандартный поток вывода cout). Строка – это последовательность символов, заключенная в двойные кавычки. В строке символ обратной косой \, за которым следует другой символ, обозначает один специальный символ; в данном случае, \n является символом новой строки. Таким образом, выводимые символы состоят из "Thise is my first program " и перевода строки, которые определяют функцию, названную main . Каждая программа должна содержать функцию с именем main , и работа программы начинается с выполнения этой функции.
Ввод с клавиатуры
Следующая (довольно многословная) программа предлагает вам ввести число дюймов. После того, как вы это сделаете, она напечатает соответствующее число сантиметров.
Пример 2:
#include
Void main()
int inch = 0; // inch - дюйм
cout << "inches";
cin >> inch;
cout << inch;
cout << " in = ";
cout << inch*2.54;
cout << " cm\n";
Первая строка функции main() описывает целую переменную inch . Ее значение считывается с помощью операции >> ("взять из") над стандартным потоком ввода cin .
В этом примере на каждую команду вывода приходится один оператор; это слишком длинно. Операцию вывода << можно применять к ее собственному результату, так что последние четыре команды вывода можно было записать одним оператором:
cout << inch << " in = " << inch*2.54 << " cm\n";Комментарии
Часто бывает полезно вставлять в программу текст, который предназначается в качестве комментария только для читающего программу человека и игнорируется компилятором в программе. В C++ это можно сделать одним из двух способов.
Символы /* начинают комментарий, заканчивающийся символами */. Вся эта последовательность символов эквивалентна символу пропуска (например, символу пробела). Это наиболее полезно для многострочных комментариев и изъятия частей программы при редактировании, однако следует помнить, что комментарии /* */ не могут быть вложенными.
Символы // начинают комментарий, который заканчивается в конце строки, на которой они появились. Опять, вся последовательность символов эквивалентна пропуску. Этот способ наиболее полезен для коротких комментариев. Символы // можно использовать для того, чтобы закомментировать символы /* или */, а символами /* можно закомментировать //.
4.6. Типы данных в C++
Перед тем, как писать программу, необходимо задать типы данных. В C++ существуют несколько часто используемых типов данных (не все):
Ø Численные знаковые целые (int, short, char);
Ø Численные знаковые дробные (float, double, long (в С), long double (в С);
Ø Численные без знаковые - все перечисленные выше типы с добавлением Unsigned;
Ø Char так же может использоваться как символьный тип .
Стандартные типы и размеры соответствующих ячеек приведены ниже.
| Диапазон | Размер (Бт) |
| char -128..127; | |
| unsigned char 0..255; | |
| int -32 768.. 32 767; | |
| unsigned int 0..65535; | |
| long -2 147 483 648..2 147 483 647; | |
| unsigned long 0..4 294 967 295; | |
| float 3.4e-38..3.4e+38; | |
| double 1.7e-308..1.7e+308; | |
| long double 3.4e-4932..3.4e+4932. |
Переменная в C/C++ объявляется следующим образом:
Int iMyVariable;
В приведенном операторе iMyVariable объявлена как целая переменная. А вот объявление переменной типа char :
Char cMyChar;
Такие типы данных, как int , float , char и long , являются неотъемлемой частью C/C++ и вам не нужно писать никакого кода, чтобы сообщить компилятору о том, что означают эти слова. C/C++ позволяет вам также объявлять свои собственные, специальные типы данных.
В примере 3 представлена программа, которая будет выводить размер типов данных в байтах. Пример 3:
#include
Void main(void)
cout << " (unsigned)int = " << sizeof(int) << endl;
cout << " (unsigned)short = " << sizeof(short) << endl;
cout << " (unsigned)char = " << sizeof(char) << endl;
cout << " (unsigned)float = " << sizeof(float) << endl;
cout << " (unsigned)double = " << sizeof(double) << endl;
cout << " (unsigned)long = " << sizeof(long) << endl;
cout << " (unsigned)long double = " << sizeof(long double) << endl;
Для того, чтобы узнать размер ячейки соответствующего типа достаточно написать в программе sizeof (тип). Дело в том, что для различных операционных систем размеры ячейки одного типа может отличаться (например тип int в 16-ти и 32-х разрядных ОС, 1 байт и 2 байта соответственно).
Оператор sizeof вычисляет размер своего операнда в байтах. Операнд должен быть или выражением, которое не вычисляется, или именем типа в скобках. Оператору sizeof нельзя применять к функции, битовому полю, неопределенному классу, типу void или к массиву с неуказанными границами индексов. Байт никак не определяется языком, кроме как результата операции sizeof , именно sizeof (char) есть 1.
4.7. ПеременныеПеременная представляет собой имя ячейки памяти, которую должен использовать для хранения модифицируемого значения, чтобы память была доступна программе для использования, она должна быть закреплена за ней. Существует статическое и динамическое выделение памяти. Статическое выделение памяти происходит на этапе компиляции и размер блока не может быть изменен в течение времени выполнения программы. Динамическая память выделяется именно в процессе выполнения, и ее размер может зависеть от текущего состояния программы. Участок памяти, закрепленный за программой, используется для хранения данных.
Если данные могут меняться в процессе работы, то говорят об использовании переменных, если не могут – то констант. Для доступа к переменной или константе необходимо использовать имя или адрес.
Переменная - это именованная область памяти, значение которой может изменяться в процессе выполнения программы.
Все переменные должны быть объявлены для своего использования, для того чтобы компилятор смог выделить статическую память, поэтому ему требуется знать ее точный размер. Для того чтобы объявить переменную, необходимо указать: имя, адрес, размер (определяемый типом), значение .
Если объявление располагается внутри пары фигурных скобок (например, внутри тела функции), то объявленные переменные считаются локальными и память для них отводится в области стека программы, а начальное значение неопределенно.
Если переменная объявлена вне тел функций, то она считается глобальной и размещается в сегменте данных и ее начальное значение равно нулю. Объявление переменной с присвоением ей начального значения называется инициализацией .
Если функция имеет аргумент, следует объявить переменные, которые будут принимать их значения, эти переменные называютсяформальными параметрами.
В языке С++ существуют два классификатора, управляющих доступом и модификацией: const и volatile .
Константа – это именованная область памяти, значение которой не может изменяться в процессе выполнения программы. Константам всегда присваивается некоторое значение при объявлении, и оно не может быть изменено в дальнейшем. Переменные типа const не могут изменяться, однако их можно инициализировать.
Квалификатор volatile сообщает компилятору, что значение переменной может изменяться неявно. Например , адрес глобальной переменной передать таймеру операционной системы и использовать его для отсчета реального времени. В этом случае содержимое переменной изменяется без явного выполнения какого-либо оператора присваивания.
В языке С/С++ предусмотрены управляющие символьные константы , которые приведены в таблице 2.
Таблица 2.
Управляющие символьные константы
Самые знаменитые служебные символы: перевод строки (код 13), возврат каретки (код 10), табуляция (код 9). Для задания их в программе в виде символьных констант используется сочетание двух видимых символов, а именно “\n”, “\r”, “\t” соответственно. Для представления символа “слэш“ используется конструкция “\\”
В языке С существуют четыре спецификатора хранения: extern, static, register, auto.
Эти спецификаторы сообщают компилятору, как хранить объявленную переменную. Общий вид объявления, использующего эти спецификаторы:
Похожая информация.
Символьные константы
Константы вещественного типа
Целочисленные константы
Общий формат: ±n (+ обычно не ставится).
Десятичные константы - последовательность цифр 0...9, первая из которых не должна быть 0. Например, 22 и 273 - обычные целые константы, если нужно ввести длинную целую константу, то указывается признак L (l ) - 273L (273l ). Для такой константы будет отведено – 4 байта. Обычная целая константа, которая слишком длинна для типа int , рассматривается как более длинный тип (long или long long ).
Существует система обозначений для восьмеричных и шестнадцатеричных констант.
Восьмеричные константы - последовательность цифр от 0 до 7, первая из которых должна быть 0, например: 020 = 16-десятичное.
Шестнадцатеричные константы - последовательность цифр от 0 до 9 и букв от A до F (a...f), начинающаяся символами 0Х (0х), например: 0X1F (0х1f) = 31-десятичное.
Восьмеричные и шестнадцатеричные константы могут также заканчиваться буквой L(l) - long, например, 020L или 0X20L.
Примеры целочисленных констант:
1992 13 1000L - десятичные;
0777 00033 01l - восьмеричные;
0x123 0X00ff 0xb8000l - шестнадцатеричные.
Данные константы размещаются в памяти по формату double, а во внешнем представлении могут иметь две формы:
1) с фиксированной десятичной точкой, формат записи: ±n .m , где n , m - целая и дробная части числа;
2) с плавающей десятичной точкой (экспоненциальная форма): ±n .m E±p , где n , m - целая и дробная части числа, р - порядок, например, 1,25×10 -8 записывается как 1.25E-8.
Примеры констант с фиксированной и плавающей точками:
1.0 -3.125100е-10 0.12537е+13
Символьная константа - это символ, заключенный в одинарные кавычки: "A", "х" (занимает 1 байт).
В языке Си используются и. специальные (управляющие ) символы, не отображаемые на экране; их назначение - влиять на порядок изображения других символов.. Поскольку они не отображаются на экране, для их обозначения в тексте программы используется пара символов, первый из которых всегда - обратная косая черта (обратный слеш ) ("\"). Основные их них:
С помощью обратного слеша в символьных и строковых (см. ниже) константах представляются и некоторые обычные символы, чье написание там могло бы привести к двусмысленности:
При присваивании символьной переменной эти последовательности должны быть заключены в апострофы. Символьная константа "\0" (не путать с символом - цифрой "0" !) часто записывается вместо целой константы 0, чтобы подчеркнуть символьную природу некоторого выражения (см. тему "Строки").
Примеры символьных констант: "А", "9", "$", "\n", "\"".
Строковая константа представляет собой последовательность символов кода ASCII, заключенная в кавычки (”) . Во внутреннем представлении к строковым константам добавляется нулевой символ "\0", еще называемый нуль-терминатор, отмечающий конец строки. Кавычки не являются частью строки, а служат только для ее ограничения. Строка - это массив, состоящий из символов. Внутреннее представление константы "01234\0ABCDEF":
"0","1","2","3","4","\0","A","B","C","D","E","F","\0"
Примеры строковых констант:
"Система", "\n\t Аргумент \n", "Состояние \"WAIT\""
В конец строковой константы компилятор автоматически помещает нуль-символ (нуль-терминатор). Нуль-символ - это не цифра 0 , он на печать не выводится и в таблице кода ASCII имеет код 0.
Например, строка "" - пустая строка, содержащая лишь нуль-терминатор.
2.8. Именованные константы
Константы
Константами называют неизменяемые величины. Различаются целые, вещественные, символьные и строковые константы. Компилятор, выделив константу в качестве лексемы, относит ее к одному из типов по ее внешнему виду.
Форматы констант, соответствующие каждому типу, приведены в табл. 7.1.
Таблица 7.1.
Константы в языке С++
| Константа | Формат | Примеры |
| Целая | Десятичный: последовательность десятичных цифр, начинающаяся не с нуля, если это не число нуль | 8, 0, 199226 |
| Восьмеричный: нуль, за которым следуют восьмеричные цифры (0,1,2,3,4,5,6,7) | 01, 020, 07155 | |
| Шестнадцатеричный: Ох или ОХ, за которым следуют шестнадцатеричные цифры (0,1,2,3,4,5,6,7,8,9,А,В,С,D,Е,F) | 0хА, 0x1 В8, 0Х00FF | |
| Вещественная | Десятичный: [цифры], [цифры] | 5.7, .001, 35. |
| Экспоненциальный: [цифры][.][цифры]{Е|е}[+|-[цифры] | 0.2Е6, .11е-3, 5Е10 | |
| Символьная | Один или два символа, заключенных в апострофы | "А", ‘ю’, "*", ‘db’ ‘\0’ ‘\n’, ‘\012’ "\x07\x07" |
| Строковая | Последовательность символов, заключенная в кавычки | "Здесь был Vasia", "\tЗначение r=\0хF5\" |
Если требуется сформировать отрицательную целую или вещественную константу, то перед константой ставится знак унарной операции изменения знака (-), например: -218, -022, -0х3С, -4.8, -0.1е4.
Вещественная константа в экспоненциальном формате представляется в виде мантиссы и порядка. Мантисса записывается слева от знака экспоненты (Е или е), порядок – справа от знака. Значение константы определяется как произведение мантиссы и возведенного в указанную в порядке степень числа 10. Обратите внимание, что пробелы внутри числа не допускаются, а для отделения целой части от дробной используется не запятая, а точка.
Программист может задать тип константы самостоятельно. Могут быть опущены либо целая часть, либо дробная, но не обе сразу. Если указаны обе части, символ точки обязателен.
Символьные константы, состоящие из одного символа, занимают в памяти один байт и имеют стандартный тип char. Двухсимвольные константы занимают два байта и имеют тип int, при этом первый символ размещается в байте с меньшим адресом.
Символ обратной косой черты используется для представления:
· кодов, не имеющих графического изображения (например,
\а – звуковой сигнал, \n – перевод курсора в начало следующей строки);
· символов апострофа ("), обратной косой черты (\), знака вопроса (?) и кавычки (");
· любого символа с помощью его шестнадцатеричного или восьмеричного кода, например, \073, \0xF5. Числовое значение должно находиться в диапазоне от 0 до 255.
Последовательности символов, начинающиеся с обратной косой черты, называют управляющими, или escape-последовательностями. В таблице 7.2. приведены их допустимые значения. Управляющая последовательность интерпретируется как одиночный символ. Если непосредственно за обратной косой чертой следует символ, не предусмотренный табл. 7.2, результат интерпретации не определен. Если в последовательности цифр встречается недопустимая, она считается концом цифрового кода.
Таблица 7.2.
Управляющие последовательности в языке С++
Управляющие последовательности могут использоваться и в строковых константах, называемых иначе строковыми литералами. Например, если внутри строки требуется записать кавычку, ее предваряют косой чертой, по которой компилятор отличает ее от кавычки, ограничивающей строку:
"Издательский дом \"Питер\""
Все строковые литералы рассматриваются компилятором как различные объекты.
Строковые константы, отделенные в программе только пробельными символами, при компиляции объединяются в одну. Длинную строковую константу можно разместить на нескольких строках, используя в качестве знака переноса обратную косую черту, за которой следует перевод строки. Эти символы игнорируются компилятором, при этом следующая строка воспринимается как продолжение предыдущей. Например, строка
До этого момента, все переменные, которые мы рассматривали, были не константами. Их значения можно было изменить в любое время. Например:
int x { 4 }; // инициализация переменной x значением 4 x = 5; // изменяем значение x на 5
Тем не менее, иногда полезно использовать переменные, значения которых нельзя изменить – константы . Вот например, сила тяжести на Земле: 9.8м/с^2. Оно вряд ли поменяется в ближайшее время. Использовать константу для этого случая — наилучший вариант, так как таким способом мы предотвратим любое (даже случайное) изменение значения.
Чтобы сделать переменную константой – используйте ключевое слово const перед типом переменной или после. Например:
const double gravity { 9.8 }; // предпочтительнее использовать const перед типом данных int const sidesInSquare { 4 }; // ок, но не предпочтительно
Несмотря на то, C++ примет const как до, так и после типа, мы рекомендуем использовать именно перед типом.
Константы должны быть инициализированы при объявлении . Их значения с помощью операции присваивания изменить не получится.
const double gravity { 9.8 }; gravity = 9.9; // не допускается - ошибка компиляции
Объявление константы без инициализации также вызовет ошибку компиляции:
const double gravity; // ошибка компиляции, константа должна быть инициализирована
Обратите внимание, константы могут быть инициализированы и с помощью неконстантных значений:
std::cout << "Enter your age: "; int age; std::cin >> age; const int usersAge (age); // в дальнейшем переменная usersAge не может быть изменена
const является наиболее полезным (и наиболее часто используемым) с параметрами функций:
void printInteger(const int myValue) { std::cout << myValue; }
void printInteger (const int myValue ) std :: cout << myValue ; |
Таким образом, при вызове функции, константа-параметр говорит нам, что функция не будет изменять значение переменной myValue. Во-вторых, она гарантирует, что функция не изменит значение myValue.
Compile time и runtime
Когда вы находитесь в процессе компиляции программы – это compile time (время компиляции ) . Компилятор проверяет вашу программу на синтаксические ошибки, затем конвертирует код в объектные файлы.
Когда вы находитесь в процессе запуска вашей программы или когда программа уже выполняется — это runtime (время выполнения) . Код выполняется строка за строкой.
Constexpr
В C++ есть два вида констант.
Константы r untime . Их значения определяются только во время выполнения (когда программа запущена). Переменные типа usersAge и myValue (в коде выше) — это константы runtime, так как компилятор не может определить их значения во время компиляции. usersAge зависит от пользовательского ввода (который можно получить только во время выполнения программы), а myValue зависит от значения, переданного в функцию (которое станет известным также во время выполнения программы).
Константы c ompile-time . Их значения определяются во время компиляции. Например, сила тяжести Земли – это константа compile-time, мы её определили сами в ходе написания программы.
В большинстве случаев, неважно какой тип константы: compile-time или runtime. Однако, есть все же несколько ситуаций, когда C++ может требовать константу compile-time вместо runtime (например, при определении длины массива фиксированного размера — мы рассмотрим это позже). Так как типов есть два, то компилятору нужно постоянно отслеживать, к какому из них относится какая переменная. Чтобы упростить это задание, в C++ 11 появляется ключевое слово constexpr , которое гарантирует, что тип константы — compile-time:
constexpr double gravity (9.8); // ок, значение определяется во время компиляции constexpr int sum = 4 + 5; // ок, значение 4 + 5 определяется во время компиляции std::cout << "Enter your age: "; int age; std::cin >> age; constexpr int myAge = age; // не ок, переменная age не определяется во время компиляции
Использовать вы его, скорее всего, не будете, но знать о нем не помешает.
Правило: Любая переменная, которая не должна изменять свое значение после инициализации — должна быть объявлена, как const (или как constexpr).
Имена констант
Некоторые программисты пишут имена констант заглавными буквами. Другие используют обычные имена, только с префиксом ‘k’. Мы же не будем их как-то выделять, так как константы – это те же обычные переменные, просто с фиксированными значениями, вот и всё. Особой причины, чтобы их выделять нет. Однако, это дело каждого лично.
Символьные константы
В предыдущем уроке , мы обсуждали «магические числа» – литералы, которые используются в программе как константы. Поскольку их использование является плохой практикой, тогда что использовать вместо них? Ответ: символьные константы. Символьная (или еще символическая ) константа – это тот же литерал (магическое число), только с идентификатором. Есть два способа объявления символических констант в C++. Один из них хороший, а один не очень. Рассмотрим оба.
Плохой способ: Использование макросов-объектов с текстом-заменой в качестве символьных констант
Раньше этот метод широко использовался, так что вы все еще можете увидеть его в старых кодах.
В уроке 22 о препроцессорах и директивах , мы говорили, что макросы-объекты имеют две формы – с текстом-заменой и без. Рассмотрим первый случай (с текстом-заменой). Он выглядит так:
#define identifier substitution_text
Как только препроцессор встретит эту директиву, все дальнейшие появления ‘identifier’ будет заменяться на ‘substitution_text’. Идентификатор обычно пишется заглавными буквами с нижним подчеркиванием вместо пробелов.
Например:
int max_students = numClassrooms * MAX_STUDENTS_PER_CLASS;
#define MAX_STUDENTS_PER_CLASS 30 |
Во время компиляции, препроцессор заменит все идентификаторы MAX_STUDENTS_PER_CLASS на литерал 30.
Согласитесь, это гораздо лучший вариант, чем использование магических чисел, как минимум по нескольким причинам. MAX_STUDENTS_PER_CLASS обеспечивает контекст того, что это за значение и зачем оно надо, даже без комментариев. Во-вторых, если число нужно будет изменить — достаточно будет сделать правки только в директиве #define, все остальные идентификаторы MAX_STUDENTS_PER_CLASS в программе будут автоматически заменены новым значением при повторной компиляции.
Рассмотрим еще один пример:
#define MAX_STUDENTS_PER_CLASS 30 #define MAX_NAME_LENGTH 30 int max_students = numClassrooms * MAX_STUDENTS_PER_CLASS; setMax(MAX_NAME_LENGTH);
#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).
Так почему же этот способ плохой? Есть две причины.
Во-первых, макросы обрабатываются препроцессором, который заменяет идентификаторы на определенные значения. Эти значения не будут отображаться в отладчике (который показывает ваш фактический код). При компиляции int max_students = numClassrooms * 30; в отладчике вы увидите int max_students = numClassrooms * MAX_STUDENTS_PER_CLASS; . А если нужно будет узнать значение MAX_STUDENTS_PER_CLASS? Вам придется самостоятельно найти его в коде. А это может занять некоторое время, в зависимости от размеров программы.
Во-вторых, эти директивы всегда имеют глобальную область видимости (о ней мы поговорим позже). Это означает, что значения #define в одной части кода могут конфликтовать со значениями #define в другой части кода.
Правило: Не используйте #define для создания символьных констант.
Хороший способ: Переменные const
Лучший способ создать символьную константу — использовать const:
const int maxStudentsPerClass { 30 }; const int maxNameLength { 30 };
const int maxStudentsPerClass { 30 } ; const int maxNameLength { 30 } ; |
Такие значения будут отображаться в отладчике, также они следуют всем правилам обычных переменных (в том числе и насчет области видимости).
Правило: Используйте const для создания символьных констант.
Использование символьных констант в программе
Во многих программах символьная константа должна быть использована на протяжении всего кода (а не только в одном месте). Они могут быть физическими или математическими константами, которые не меняются (например, число Пи или число Авогадро) или специфическими значения вашей программы. Чтобы не писать их каждый раз, когда они необходимы — определите их в одном месте и используйте везде, где будет нужно. Таким образом, если вам придется их изменить – достаточно будет зайти в один файл и там внести правки, а не рыскать по всей программе.
Как это осуществить? Очень просто:
- Создайте заголовочный файл для хранения констант.
- В заголовочном файле объявите пространство имен (
Загрузка...
