29. Константы. Специальные символы. Квалификатор const.

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

Если в вашей программе многократно используется некое число, например 7. Но в дальнейшем оно может изменится на другое. То легче один раз объявить константу и когда надо заменить один раз значение у константы.

константы

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

// инициализирующее выражение обязательно

const int ci1=6, ci7=7;

// объявление константы определенной в другом модуле

extern const int a;

int func(const char* arg){

// данные на которые указывает arg

// нельзя изменить

...

}

Спец.символы.

У символьных и строковых литералов есть определенные особенности, как управляющие коды. Они - специальные символы, которые являются трудными или невозможными выразить иначе в исходном коде программы, как новая строка (\n) или вкладка (\t). Всем им предшествует наклонная черта влево (\). Здесь у Вас есть список некоторых из таких управляющих кодов:

\n новая строка

\r возврат каретки

\t вкладка

\v вертикальная вкладка

\b клавиша Backspace

\f перевод формата (нумеруют страницы канала),

\a предупреждение (звуковой сигнал)

\' одинарная кавычка (')

\" двойная кавычка (")

\? вопросительный знак (?)

\\ наклонная черта влево (\)

Квалификатор типов const (от анг. type qualifier) – зарезервированное ключевое слово в языке программирования С++, которое не даёт модифицировать значения переменных. Отсюда и возникло в программировании такое понятие, как константы или константные переменные, то есть неизменные. Необходимо запомнить, что при объявлении константы, её нужно инициализировать.

//Синтаксис объявления константы

const /*тип данных*/ /*имя переменной*/ = /*инициализатор ( значение) */; // объявление константной переменной

Объявление константной переменной от обычной переменной отличается ключевым словом const, которое ставится перед типом данных объявляемой переменной.

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

30. Область видимости переменных.

Область видимости (англ. scope) — в программировании обозначает область в которой в данный момент можно обратиться по имени к переменным и функциям.

Переменные по области видимости делятся на два типа:

• локальные, когда переменная объявляется внутри функции, в таком случае изнутри вызвать эту переменную не получится;

• глобальные, когда переменная объявляется вне всех функций, в таком случае она доступна ото всюду[1][неавторитетный источник?].

Область видимости переменной может задаваться с помощью классов памяти или пространства имён.

В качестве обучающего примера попробую описать область видимости переменных с помощью функций.

Первый вариант – глобальная переменная. Глобальная переменная объявляется один раз и действует по всей программе

Код C++ Глобальная переменная

#include <conio.h>

#include <iostream.h>

void main(); //Прототип функции main

void sum(); //Прототип функции sum

//Обратите внимание, что переменные объявляются вне функций

int i=100; //Глобальная переменная i. При объявлении запоминаем в i некоторое значение

int a; //Глобальная переменная a

void main()

{

clrscr();

a=200;//так как a была объявлена вне функции - она глобальная и значит доступна по всему коду

sum(); //Вызываем некоторую функцию

return;

}

void sum()

{

cout<<i<<endl; //Выводим значение переменной i на экран = 100

cout<<a<<endl;//Выводим значение переменной a на экран = 200. Значение 200 было записано в main

cout<<i+a<<endl; //Выводим значение i+a на экран = 300

getch();

return;

}

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

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

Если я плохо объяснил, что обозначает глобальная переменная, то я неудачник. Если хорошо, то имеет смысл читать дальнейшее описание. Помимо понятия Глобальная переменная – существует Локальная переменная. Локальная переменная определяется внутри функции и доступна она только для функции, внутри которой была объявлена.

Код C++ Локальная переменная

#include <conio.h>

#include <iostream.h>

void main(); //Прототип функции main

void sum(); //Прототип функции sum

void main()

{

int a; //Объявили переменную внутри main, т.е. объявили локально

a=200; //Переменная объявленная внутри main доступна только и только внутри main

return;

}

void sum()

{

int i;//Объявили переменную i внутри sum. Другими словами объявили локальную переменную i

cout<<i<<endl; //Выводим на экран i

cout<<a<<endl; //Тут должна быть ошибка

cout<<i+a<<endl;

getch();

return;

}

Ошибка в указанном месте возникает из-за того, что для функции sum не действует никакая переменная, объявленная внутри любой другой функции. Если программист объявляет переменную внутри некоторой одной функции, значит он предполагает, что с этой переменной будет работать только и только та функция, в которой переменная была объявлена. Такие переменные живут только внутри своих функций и не доступны для других участков кода. Это и есть локальная переменная. В отличии от первого приведенного примера, в этом примере глобальных переменных объявлено не было. Значит по факту для sum переменной a не существует в природе.

Существует ситуация, когда программист объявляет глобальную и локальную переменные с одинаковыми именами. В этом случае во время работы функции с локальной переменной локальная переменная закрывает глобальную и говорит: “Я тут главная”. Непосредственная работа выполняется с локальной переменной, при этом значение глобальной переменной остается в памяти

Код C++ Локальная переменная затеняет глобальную

#include <conio.h>

#include <iostream.h>

void main(); //Прототип функции main

void sum(); //Прототип функции sum

void new_fun(); //Прототип функции new_fun

int i=100; //Глобальная переменная i

void main()

{

cout<<i<<endl; //В этом случае i глобальная, т.к. внутри main i объявлено не было i=100;

sum(); //Вызывам некоторую функцию

new_fun(); //Вызываем некоторую функцию

getch();

return;

}

void sum()

{

int i=20;//Переменная i локальная т.к. объявлена внутри sum. Действует только внутри sum

cout<<i<<endl; //Выводим на экран i. Локальная i затенила глобальную (действующая i=20). Глобальная i висит в памяти

return;

}

void new_fun() //Внутри new_fun переменных не объявлено, значит для new_fun существуют только глобальные переменные

{

cout<<i<<endl; //Выводм на экран глобальную i (i=100)

return;

}

В случае когда программист объявляет глобальную переменную и одноименную с ней локальную, локальная затеняет глобальную. При вызове функции с локальными переменными, локальные переменные по приоритету выше глобальных. Так как локальные переменные по приоритету выше, значит значения для вычислений берутся из них. По завершении функции глобальная переменная вновь приобретает силу. Это можно понять по приведенному примеру. Вне функций была объявлена некоторая переменная i (вне = глобальная), вместе с ней внутри функции sum была объявлена еще одна переменная i (внутри = локальная).

В последнем примере было описано, что обозначает выражение “локальная переменная затеняет глобальную”. Так как глобальная переменная не теряет своего значения, то программист может обратиться непосредственно к ней внутри функции с одноименной локальной переменной . Для такого обращения используется глобальный оператор разрешения

Код C++ Глобальный оператор разрешения

#include <conio.h>

#include <iostream.h>

int i=100;//Глобальная переменная i

void main()

{

clrscr();

int i=50; //Локальная переменная i

cout<<i<<endl; //Обращение к локальной переменной (i=50)

cout<<::i<<endl; //Обращение к глобальной переменной (i=100) Использован глобальный оператор разрешения

getch();

return;

}

Такое описание было написано для тех начинающих, которым надо всё поподробнее растолковать. Самое главное запомнить понятие локальной и глобальной переменных

• Локальная переменная – такая переменная, которая объявляется внутри функции и действует она только внутри своей функции (видима только своей функции)

• Глобальная переменная – такая переменная, которая объявлена вне функции и доступна она для окончания работы программы (видима всей программе)

Несмотря на описанные возможности не рекомендуется применять переменные с одинаковыми именами. Во избежание путаницы следует избегать глобальных переменных везде где возможно. Это важно помнить.