Всего книг:

826

Последнее обновление:

 2008-07-25 16:42:12

 

Искать

 

 


 

Нас считают!


Яндекс цитирования

 

 

 

 

 

 

 

 

 

 

 

 

 

 

Учимся программировать на языке C++ : Локальные переменные и область видимости

Allk.Ru - Все книги!

 

 

 

Учимся программировать на языке C++:Локальные переменные и область видимости

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

• Вы объявляете локальные переменные внутри функции точно так же, как и внутри main: указывая тип и имя переменной.

• Имена переменных, используемых внутри функций, должны быть уникальными только по отношению к данной функции.

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

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

• Оператор глобальной области видимости C++ (::) позволяет вам управлять областью видимости переменной.

Объявление локальных переменных внутри функции достаточно просто. Фактически вы уже это делали каждый раз, когда объявляли переменные внутри main.
ОБЪЯВЛЕНИЕ ЛОКАЛЬНЫХ ПЕРЕМЕННЫХ

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

void some_function(void)

{
int count;
float result;
}

Следующая программа USEBEEPS.CPP использует функцию sound_speaker, которая заставляет играть встроенный компьютерный динамик столько раз, сколько указано параметром beeps. Внутри функции sound_speaker локальная переменная counter хранит количество звуков, издаваемых динамиком:

#include

void sound_beeps(int beeps)

{
for (int counter = 1; counter <= beeps; counter++) cout << '\a';
}

void main(void)

{
sound_beeps(2);
sound_beeps(3);
}

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

При объявлении локальных переменных внутри функции очень вероятно, что имя локальной переменной, объявляемой вами в одной функции, будет таким же, как и имя переменной, используемой в другой функции. Как уже упоминалось, локальные переменные известны только в текущей функции. Таким образом, если две функции используют одно и то же имя для своих локальных переменных, это не приводит к конфликту. C++ трактует имя каждой переменной как локальное по отношению к соответствующей функции. Следующая программа LCLNAME.CPP использует функцию add_values для сложения двух целочисленных значений. Эта функция присваивает свой результат локальной переменной value. Однако в main один из параметров, передаваемых в функцию, также носит имя value. Тем не менее, поскольку C++ трактует обе переменные как локальные для соответствующих функций, их имена не конфликтуют:

#include

int add_values(int a, int b)
{
int value;
value =a + b;
return(value);
}

void main (void)

{
int value = 1001;
int other value = 2002;
cout << value << " + " << other_value << " = " << add_values(value, other_value) << endl;
}

О локальных переменных

Локальные переменные представляют собой переменные, объявляемые внутри функции. Имя и значение локальной переменной известны только функции, внутри которой переменная объявлена. Вы должны объявлять локальные переменные в начале вашей функции сразу же после первой открывающей фигурной скобки. Имена, назначаемые локальным переменным, должны быть уникальными только для функции, внутри которой эти переменные определены. При объявлении локальной переменной внутри функции ее можно инициализировать с помощью оператора присваивания.
ГЛОБАЛЬНЫЕ ПЕРЕМЕННЫЕ

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

int some_global_variable; ---> Объявление глобальной переменной

void main(void)

{
// Здесь должны быть операторы программы
}

Следующая программа GLOBAL. CPP использует глобальную переменную именем number. Каждая функция в программе может использовать (или изменять) значение глобальной переменной. В данном случае каждая функция выводит текущее значение этой переменной, а затем увеличивает это значение на единицу:

#include

int number = 1001;

void first_change(void)

(
cout << "значение number в first_cbange " << number << endl;
number++;
}

void second_change(void)

{
cout << "значение number в second_change " << number << endl;
number++;
}

void main(void)

{
cout << "значение number в main " << number << endl;
number++;
first_change () ;
second_change();
}

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

По мере возможности следует избегать использования в программах глобальных переменных. Однако если ваша программа должна использовать глобальную переменную, то может случиться, что имя глобальной переменной конфликтует с именем локальной переменной. При возникновении такого конфликта C++ предоставляет приоритет локальной переменной. Другими словами, программа предполагает, что в случае конфликта каждая ссылка на имя соответствует локальной переменной.

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

number = 1001; // обращение к локальной переменной

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

::number = 2002; // Обращение к глобальной переменной

Следующая программа GLOBLOCA.CPP использует глобальную переменную number. В дополнение к этому функция show_numbers использует локальную переменную с именем number. Эта функция использует оператор глобального разрешения для обращения к глобальной переменной:

#include int number = 1001; // Глобальная переменная

void show_numbers(int number)

{
cout << "Локальная переменная number" << " содержит " << number << endl;
cout << "Глобальная переменная number" << " содержит " << ::number << endl;
}

void main(void)
{
int some_value = 2002;
show_numbers(some_value) ;
}

Когда вы откомпилируете и запустите эту программу, на вашем экране появится следующий вывод:

С:\> GLOBLOCA

Локальная переменная number содержит 2002

Глобальная переменная number содержит 1001

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

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

При чтении книг и журнальных статей по C++ вы можете встретить термин область видимости, что определяет участок в программе, где имя переменной имеет смысл (и, следовательно, используется). Для локальной переменной область видимости ограничена функцией, внутри которой эта переменная объявлена. С другой стороны, глобальные переменные известны на протяжении всей программы. В результате глобальные переменные имеют большую область видимости.
ЧТО ВАМ НЕОБХОДИМО ЗНАТЬ

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

1. Локальные переменные представляют собой переменные, объявленные внутри функции.
2. Локальные переменные известны только той функции, внутри которой они объявлены.
3. Несколько функций могут использовать одно и то же имя для локальной переменной без каких-либо конфликтов.
4. Глобальная переменная представляет собой переменную, чье имя и значение известны на протяжении всей программы.
5. Чтобы объявить глобальную переменную, объявите переменную в начале вашего исходного файла вне какой-либо функции.
6. Поскольку глобальные переменные могут быть легко изменены любой функцией, они привносят возможность появления трудно обнаруживаемьгх ошибок, поэтому избегайте использования глобальных переменных в своих программах

Предыдущий вопрос | Содержание | Следующий вопрос

 

Внимание!

1. Все книги являются собственностью их авторов.
2. Предназначены для частного просмотра.
3.Любое коммерческое использование категорически запрещено.

 

 


In-Server & Artificial Intelligence

Контакты

317197170

support[@]allk.ru

 

Ссылки

Art