Не забывайте об установке указателей
Следующая (некорректная) программа должна принять строку, введенную с клавиатуры, а затем отобразить ASCII ‑код для каждого символа этой строки. (Обратите внимание на то, что для вывода ASCII ‑кодов на экран используется операция приведения типов.) Однако эта программа содержит серьезную ошибку.
Сможете ли вы сами найти здесь ошибку?
В приведенном выше варианте программы указателю p1 присваивается адрес массива s только один раз. Это присваивание выполняется вне цикла. При входе в do‑while ‑цикл (т.е. при первой его итерации) p1 действительно указывает на первый символ массива s . Но при втором проходе того же цикла p1 указатель будет содержать значение, которое останется после выполнения предыдущей итерации цикла, поскольку указатель p1 не устанавливается заново на начало массива s . Рано или поздно граница массива s будет нарушена.
Вот как выглядит корректный вариант той же программы.
Итак, в этом варианте программы в начале каждой итерации цикла указатель p1 устанавливается на начало строки.
Узелок на память. Чтобы использование указателей было безопасным, нужно в любой момент знать, на что они ссылаются.
Глава 7:Функции, часть первая: ОСНОВЫ
В этой главе мы приступаем к углубленному рассмотрению функций. Функции – это строительные блоки C++, а потому без полного их понимания невозможно стать успешным С++‑программистом. Мы уже коснулись темы функций в главе 2 и использовали их в каждом примере программы. В этой главе мы познакомимся с ними более детально. Данная тема включает рассмотрение правил действия областей видимости функций, рекурсивных функций, некоторых специальных свойств функции main(), инструкции return и прототипов функций.
|
|
|
Правила действия областей видимости функций
Правила действия областей видимости определяют возможность получения доступа к объекту и время его существования.
Правила действия областей видимости любого языка программирования – это правила, которые позволяют управлять доступом к объекту из различных частей программы. Другими словами, правила действия областей видимости определяют, какой код имеет доступ к той или иной переменной. Эти правила также определяют время "жизни" переменной. Как упоминалось выше, существует три вида переменных: локальные переменные, формальные параметры и глобальные переменные. На этот раз мы рассмотрим правила действия областей видимости с точки зрения функций.
Локальные переменные
Как вы уже знаете, переменные, объявленные внутри функции, называются локальными. Но в C++ предусмотрено более "внимательное" отношение к локальным переменным, чем мы могли заметить до сих пор. В C++ переменные могут быть включены в блоки. Это означает, что переменную можно объявить внутри любого блока кода, после чего она будет локальной по отношению к этому блоку. (Помните, что блок начинается с открывающей фигурной скобки и завершается закрывающей.) В действительности переменные, локальные по отношению к функции, образуют просто специальный случай более общей идеи.
|
|
|
Локальную переменную могут использовать лишь инструкции, включенные в блок, в котором эта переменная объявлена. Другими словами, локальная переменная неизвестна за пределами собственного блока кода. Следовательно, инструкции вне блока не могут получить доступ к объекту, определенному внутри блока.
Важно понимать, что локальные переменные существуют только во время выполнения программного блока, в котором они объявлены. Это означает, что локальная переменная создается при входе в "свой" блок и разрушается при выходе из него. А поскольку локальная переменная разрушается при выходе из "своего" блока, ее значение теряется.
Самым распространенным программным блоком является функция. В C++ каждая функция определяет блок кода, который начинается с открывающей фигурной скобки этой функции и завершается ее закрывающей фигурной скобкой. Код функции и ее данные – это ее "частная собственность", и к ней не может получить доступ ни одна инструкция из любой другой функции, за исключением инструкции ее вызова. (Например, невозможно использовать инструкцию goto для перехода в середину кода другой функции.) Тело функции надежно скрыто от остальной части программы, и если в функции не используются глобальные переменные, то она не может оказать никакого влияния на другие части программы, равно, как и те на нее. Таким образом, содержимое одной функции совершенно независимо от содержимого другой. Другими словами, код и данные, определенные в одной функции, не могут взаимодействовать с кодом и данными, определенными в другой, поскольку две функции имеют различные области видимости.
|
|
|
Поскольку каждая функция определяет собственную область видимости, переменные, объявленные в одной функции, не оказывают никакого влияния на переменные, объявленные в другой, причем даже в том случае, если эти переменные имеют одинаковые имена. Рассмотрим, например, следующую программу.
|
|
|
Символьный массив str объявляется здесь дважды: первый раз в функции main() и еще раз – в функции f1() . При этом массив str , объявленный в функции main() , не имеет никакого отношения к одноименному массиву из функции f1() . Как разъяснялось выше, каждый массив (в данном случае str) известен только блоку кода, в котором он объявлен. Чтобы убедиться в этом, достаточно выполнить приведенную выше программу. Как видите, несмотря на то, что массив str получает строку, вводимую пользователем при выполнении функции f1() , содержимое массива str в функции main() остается неизменным.
Язык C++ содержит ключевое слово auto , которое можно использовать для объявления локальных переменных. Но поскольку все неглобальные переменные являются по умолчанию auto ‑переменными, то к этому ключевому слову практически никогда не прибегают. Поэтому вы не найдете в этой книге ни одного примера с его использованием. Но если вы захотите все‑таки применить его в своей программе, то знайте, что размещать его нужно непосредственно перед типом переменной, как показано ниже.
Обычной практикой является объявление всех переменных, используемых в функции, в начале программного блока этой функции. В этом случае всякий, кому придется разбираться в коде этой функции, легко узнает, какие переменные в ней используются. Тем не менее начало блока функции – это не единственно возможное место для объявления локальных переменных. Локальные переменные можно объявлять в любом месте блока кода. Переменная, объявленная в блоке, локальна по отношению к этому блоку. Это означает, что такая переменная не существует до тех пор, пока не будет выполнен вход в блок, а разрушение такой переменной происходит при выходе из ее блока. При этом никакой код вне этого блока не может получить доступ к этой переменной (даже код, принадлежащий той же функции).
Чтобы лучше понять вышесказанное, рассмотрим следующую программу.
Эта программа в зависимости от выбора пользователя обеспечивает ввод либо двух чисел, либо двух строк. Обратите внимание на объявление переменных а и b в if ‑блоке и переменных s1 и s2 в else ‑блоке. Существование этих переменных начнется с момента входа в соответствующий блок и прекратится сразу после выхода из него. Если пользователь выберет сложение чисел, будут созданы переменные а и b , а если он захочет конкатенировать строки– переменные s1 и s2 . Наконец, ни к одной из этих переменных нельзя обратиться извне их блока, даже из части кода, принадлежащей той же функции. Например, если вы попытаетесь скомпилировать следующую (некорректную) версию программы, то получите сообщение об ошибке.
Поскольку в данном случае переменная а неизвестна вне своего if ‑блока, компилятор выдаст ошибку при попытке ее использовать.
Если имя переменной, объявленной во внутреннем блоке, совпадает с именем переменной, объявленной во внешнем блоке, то "внутренняя" переменная переопределяет "внешнюю" в пределах области видимости внутреннего блока. Рассмотрим пример.
Вот как выглядят результаты выполнения этой программы.
Здесь переменная i , объявленная внутри if ‑блока, переопределяет, или скрывает, внешнюю переменную i . Изменения, которым подверглась внутренняя переменная i , не оказывают никакого влияния на внешнюю i . Более того, вне if ‑блока внутренняя переменная i больше не существует, и поэтому внешняя переменная i снова становится видимой.
Поскольку локальные переменные создаются с каждым входом и разрушаются с каждым выходом из программного блока, в котором они объявлены, они не хранят своих значений между активизациями блоков. Это особенно важно помнить в отношении функций. При вызове функции ее локальные переменные создаются, а при выходе из нее – разрушаются. Это означает, что локальные переменные не сохраняют своих значений между вызовами функций. (Существует один способ обойти это ограничение – он будет рассмотрен ниже в этой книге.)
Локальные переменные не хранят своих значений между активизациями.
Локальные переменные хранятся в стеке, если не задан иной способ хранения. Поскольку стек – это динамически изменяемая область памяти, локальные переменные не могут в общем случае сохранять свои значения между вызовами функций.
Как упоминалось выше, несмотря на то, что локальные переменные обычно объявляются в начале своего блока, это не является обязательным. Локальные переменные можно объявить в любом месте блока, главное, чтобы это было сделано до их использования. Например, следующая программа вполне допустима.
В этом примере переменные а и b не объявляются до тех пор, пока они станут нужными. Все же большинство программистов объявляют все локальные переменные в начале блока, в котором они используются, но это, как говорится, вопрос стилистики (или вкуса).
Дата добавления: 2018-09-22; просмотров: 269; Мы поможем в написании вашей работы! |
Мы поможем в написании ваших работ!