Сможете ли вы сами найти здесь ошибку?

⇐ ПредыдущаяСтр 15 из 72Следующая ⇒

В приведенном выше варианте программы указателю p1 присваивается адрес массива s только один раз. Это присваивание выполняется вне цикла. При входе в do-while-цикл (т.е. при первой его итерации) p1 действительно указывает на первый символ массива s. Но при втором проходе того же цикла p1 указатель будет содержать значение, которое останется после выполнения предыдущей итерации цикла, поскольку указатель p1 не устанавливается заново на начало массива s. Рано или поздно граница массива s будет нарушена.

Вот как выглядит корректный вариант той же программы.

// Эта программа корректна.

#include < iostream>

#include < cstdio>

#include < cstring>

using namespace std;

Int main()

{

　 char s[80];

　 char *p1;

　 do {

　　 p1 = s; // Устанавливаем p1 при каждой итерации цикла.

　　 cout < < " Введите строку: ";

　　 gets(p1); // Считываем строку.

　　 // Выводим ASCII-значения каждого символа.

　　 while(*p1) cout < < (int) *p1++ < < ' ';

　　 cout < < '';

　 }while(strcmp(s, " конец" ));

　 return 0;

}

Итак, в этом варианте программы в начале каждой итерации цикла указатель p1 устанавливается на начало строки.

Узелок на память. Чтобы использование указателей было безопасным, нужно в любой момент знать, на что они ссылаются.

Глава 7: Функции, часть первая: ОСНОВЫ

В этой главе мы приступаем к углубленному рассмотрению функций. Функции — это строительные блоки C++, а потому без полного их понимания невозможно стать успешным С++-программистом. Мы уже коснулись темы функций в главе 2 и использовали их в каждом примере программы. В этой главе мы познакомимся с ними более детально. Данная тема включает рассмотрение правил действия областей видимости функций, рекурсивных функций, некоторых специальных свойств функции main(), инструкции return и прототипов функций.

Правила действия областей видимости функций

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

Правила действия областей видимости любого языка программирования — это правила, которые позволяют управлять доступом к объекту из различных частей программы. Другими словами, правила действия областей видимости определяют, какой код имеет доступ к той или иной переменной. Эти правила также определяют время " жизни" переменной. Как упоминалось выше, существует три вида переменных: локальные переменные, формальные параметры и глобальные переменные. На этот раз мы рассмотрим правила действия областей видимости с точки зрения функций.

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

Как вы уже знаете, переменные, объявленные внутри функции, называются локальными. Но в C++ предусмотрено более " внимательное" отношение к локальным переменным, чем мы могли заметить до сих пор. В C++ переменные могут быть включены в блоки. Это означает, что переменную можно объявить внутри любого блока кода, после чего она будет локальной по отношению к этому блоку. (Помните, что блок начинается с открывающей фигурной скобки и завершается закрывающей.) В действительности переменные, локальные по отношению к функции, образуют просто специальный случай более общей идеи.

Локальную переменную могут использовать лишь инструкции, включенные в блок, в котором эта переменная объявлена. Другими словами, локальная переменная неизвестна за пределами собственного блока кода. Следовательно, инструкции вне блока не могут получить доступ к объекту, определенному внутри блока.

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

Самым распространенным программным блоком является функция. В C++ каждая функция определяет блок кода, который начинается с открывающей фигурной скобки этой функции и завершается ее закрывающей фигурной скобкой. Код функции и ее данные — это ее " частная собственность", и к ней не может получить доступ ни одна инструкция из любой другой функции, за исключением инструкции ее вызова. (Например, невозможно использовать инструкцию goto для перехода в середину кода другой функции.) Тело функции надежно скрыто от остальной части программы, и если в функции не используются глобальные переменные, то она не может оказать никакого влияния на другие части программы, равно, как и те на нее. Таким образом, содержимое одной функции совершенно независимо от содержимого другой. Другими словами, код и данные, определенные в одной функции, не могут взаимодействовать с кодом и данными, определенными в другой, поскольку две функции имеют различные области видимости.

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

#include < iostream>

using namespace std;

void f1();

Int main()

{

　 char str[] = " Это - массив str в функции main().";

　 cout < < str < < '';

　 f1();

　 cout < < str < < '';

　 return 0;

}

Void f1()

{

　 char str[80];

　 cout < < " Введите какую-нибудь строку: ";

　　 cin > > str;

　 cout < < str < < '';

}

Символьный массив str объявляется здесь дважды: первый раз в функции main() и еще раз — в функции f1(). При этом массив str, объявленный в функции main(), не имеет никакого отношения к одноименному массиву из функции f1(). Как разъяснялось выше, каждый массив (в данном случае str) известен только блоку кода, в котором он объявлен. Чтобы убедиться в этом, достаточно выполнить приведенную выше программу. Как видите, несмотря на то, что массив str получает строку, вводимую пользователем при выполнении функции f1(), содержимое массива str в функции main() остается неизменным.

Язык C++ содержит ключевое слово auto, которое можно использовать для объявления локальных переменных. Но поскольку все неглобальные переменные являются по умолчанию auto-переменными, то к этому ключевому слову практически никогда не прибегают. Поэтому вы не найдете в этой книге ни одного примера с его использованием. Но если вы захотите все-таки применить его в своей программе, то знайте, что размещать его нужно непосредственно перед типом переменной, как показано ниже.

auto char ch;

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

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

/* Эта программа демонстрирует локальность переменных по отношению к блоку.

#include < iostream>

#include < cstring>

using namespace std;

Int main()

{

　 int choice;

　 cout < < " (1) сложить числа или ";

　 cout < < " (2) конкатенировать строки?: ";

　　 cin > > choice;

　 if(choice == 1) {

　　 int a, b; /* Активизируются две int-переменные. */

　　 cout < < " Введите два числа: ";

　　　 cin > > а > > b;

　　 cout < < " Сумма равна " < < a+b < < '';

　 }

　 else {

　　 char s1 [80], s2[80]; /* Активизируются две строки. */

　　 cout < < " Введите две строки: ";

　　　 cin > > s1;

　　　 cin > > s2;

　　 strcat(s1, s2);

　　 cout < < " Конкатенация равна " < < s1 < < '';

　 }

　 return 0;

}

Эта программа в зависимости от выбора пользователя обеспечивает ввод либо двух чисел, либо двух строк. Обратите внимание на объявление переменных а и b в if-блоке и переменных s1 и s2 в else-блоке. Существование этих переменных начнется с момента входа в соответствующий блок и прекратится сразу после выхода из него. Если пользователь выберет сложение чисел, будут созданы переменные а и b, а если он захочет конкатенировать строки— переменные s1 и s2. Наконец, ни к одной из этих переменных нельзя обратиться извне их блока, даже из части кода, принадлежащей той же функции. Например, если вы попытаетесь скомпилировать следующую (некорректную) версию программы, то получите сообщение об ошибке.

/* Эта программа некорректна. */

#include < iostream>

#include < cstring>

using namespace std;

Int main()

{

　 int choice;

　 cout < < " (1) сложить числа или ";

　 cout < < " (2) конкатенировать строки?: ";

　　 cin > > choice;

　 if(choice == 1) {

　　 int a, b; /* Активизируются две int-переменные. */

　　 cout < < " Введите два числа: ";

　　　 cin > > а > > b;

　　 cout < < " Сумма равна " < < a+b < < '';

　 }

　 else {

　　 char s1 [80], s2 [80]; /* Активизируются две строки. */

　　 cout < < " Введите две строки: ";

　　　 cin > > s1;

　　　 cin > > s2;

　　 strcat (s1, s2);

　　 cout < < " Конкатенация равна " < < s1 < < '';

　 }

　 a = 10; // *** Ошибка ***

　 // Переменная а здесь неизвестна!

　 return 0;

}

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

Если имя переменной, объявленной во внутреннем блоке, совпадает с именем переменной, объявленной во внешнем блоке, то " внутренняя" переменная переопределяет " внешнюю" в пределах области видимости внутреннего блока. Рассмотрим пример.

#include < iostream>

using namespace std;

Int main()

{

　 int i, j;

　 i = 10;

　 j = 100;

　 if(j > 0) {

　　 int i; // Эта переменная i отделена от внешней переменной i.

　　 i = j /2;

　　 cout < < " Внутренняя переменная i: " < < i < < '';

　 }

　 cout < < " Внешняя переменная i: " < < i < < '';

　 return 0;

}

⇐ Предыдущая 10 11 12 13 141516 17 18 19 Следующая ⇒