Аргументы по умолчанию

С++ допускает при вызове функций опускать некоторые ее параметры. Достигается это указанием в прототипе функции значений аргументов по умолчанию. Например, функция, прототип которой приведен ниже, может при вызове иметь различный вид в зависимости от ситуации.

// Прототип функции:

void ShowInt (int i, bool Flag = true, char symbol = '\n');

// Вызовы функции ShowInt: Showlnt(1, false, 'a'); Showlnt(2, false); Showlnt(3);

В первом случае все три аргумента заданы явно, поэтому работа функции осуществляется в обычном режиме. Во втором вызове в функцию передается два параметра из трех, причем вместо последнего аргумента подставляется значение по умолчанию, а именно символ ' \n'. Третий вариант обращения к функции сообщает только один целочисленный параметр, а в качестве остальных аргументов используются значения по умолчанию: логическая переменная со значением true и символьная переменная со значением ' \n'.

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

Рассмотрим пример, в котором осуществляется вывод знакового числа двойной точности с указанием количества значащих символов. Другими словами, определим функцию, принимающую в качестве одного из параметров число выводимых знаков. Для решения поставленной задачи можно воспользоваться функцией возведения числа в степень pow() и функцией взятия модуля от длинного числа с плавающей точкой fabsl (), прототипы которых содержатся в заголовочном файле math. h:

#include <iostream.h>

#include <math.h>

void Out(double Numb, double Sig=l, bool Flg=true);

int main ()

{

double Mpi = -3.141592654;

Out(Mpi, 4, false);

Out(Mpi, 2); Out(Mpi);

return 0;

}

void Out(double numb, double sig, bool fig)

{

if(!flg)

numb = fabsl(numb);

numb = (int) (numb * pow(10, sig));

numb = numb / pow(10,sig);

cout « numb « '\n';

}

В теле программы производится вызов одной и той же функций Out () с различным числом параметров для вывода значения переменной двойной точности Mpi, в результате работы программы на печать будут выведены следующие значения:

3,1415 -3,14 -3,1

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

Области видимости. Локальные и глобальные переменные

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

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

Каждая переменная характеризуется областью действия, областью видимости и временем жизни,

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

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

Временем жизни переменной называется интервал выполнения программы, в течение которого она существует.

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

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

В рассматриваемом ниже примере переменные с именем x определены сразу в двух функциях - в main() и в Sum (), что, однако, не мешает компилятору различать их между собой:

#include <iostream.h>

// Прототип функции: int Sum(int a, int b);

int. main ()

{

// Локальные переменные:

int x = 2;

int у = 4;

cout « Sum(x, у);

return 0;

}

int Sum(int a, int b)

{

// Локальная переменная x

// видна только в теле функции Sum()

int x = a + b;

return x;

}

В программе осуществляется вычисление суммы двух целочисленных переменных посредством вызова функции Sum ().

Глобальные переменные, как указывалось ранее объявляются вне тела какой-либо из функций и действуют на протяжении выполнения всей программы. Такие переменные доступны в любой из функций программы, которая описана после объявления глобальной переменной. Отсюда следует вывод, что имена локальных я глобальных переменных не должны совпадать. Если глобальная переменная не проинициализирована явным образом, она инициализируется значением 0.

Область действия глобальной переменной совпадает с областью видимости и простирается от точки ее описания до конца файла, в котором она объявлена. Время жизни глобальной переменной - постоянное, то есть совпадает с временем выполнения программы.

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

Рассмотрим пример, поясняющий вышесказанное:

#include <iostream.h>

// Объявляем глобальную переменную Test: int Test = 200;

void PrintTest(void);

int main()

{

// Объявляем локальную переменную Test: int Test = 10;

// Вызов функции печати

// глобальной переменной:

PrintTest() ;

cout « "Локальная: " « Test « '\n';

return 0;

}

void PrintTest(void)

{

cout « "Глобальная: " « Test « '\n';

}

Первоначально объявляется глобальная переменная Test, которой присваивается значение 200. Далее объявляется локальная переменная с тем же именем Test, но со значением 10. Вызов функции PrintTest() та main() фактически осуществляет временный выход из тела главной функции. При этом все локальные переменные становятся недоступны и PrintTest() выводит на печать глобальную переменную Test. После этого управление программой возвращается в функцию main (), где конструкцией cout« выводится на печать локальная переменная Test. Результат работы программы выглядит следующим образом:

Глобальная: 200 Локальная: 10

В C++ допускается объявлять локальную переменную не только в начале функция, а вообще в любом месте программы. Если объявление происходит внутри какого-либо блока, переменная с таким же именем, объявленная вне тела блока, "прячется". Видоизменим предыдущий пример с тем, чтобы продемонстрировать процесс сокрытия локальной переменной:

#include <iostream.h>

// Объявляем глобальную переменную Test: int Test = 200;

void PrintTest(void);

int main О

{

// Объявляем локальную переменку» Test: int Test = 10;

// Вызов функции печати

// глобальной переменной: PrintTest() ;

cout « "Локальная: " « Test « '\n';

// Добавляем новый блок с еще одной

// локальной переменной Test:

{

int Test = 5;

cout « " Локальная: " «Test « '\n' ;

}

// Возвращаемся к локальной Test

// вне блока:

cout « " Локальная: " «Test « '\n';

return 0;

}

void PrintTest(void) {

cout « "Глобальная: " « Test « '\n';

}

Результат модифицированной программы будет выглядеть следующим образом:

Глобальная: 200 Локальная: 10 Локальная: 5 Локальная: 10