Функции C++

Большой фестиваль мультфильмов. .

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


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

#include <iostream>

using namespace std;

void f1 ();

int main ()

{

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

cout << str << '\n';

f1 ();

cout << str << '\n';

return 0;

}

void f1 ()

{

char str[80];

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

cin >> str;

cout << str << '\n';

}
Символьный массив 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 << '\n';

}

else {

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

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

cin >> s1;

cin >> s2;

strcat (s1, s2);

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

}

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 << '\n';

}

else {

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

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

cin >> s1;

cin >> s2;

strcat (s1, s2);

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

}

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 << '\n';

}

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

return 0;

}
Вот как выглядят результаты выполнения этой программы.

Внутренняя переменная i: 50

Внешняя переменная i: 10
Здесь переменная i, объявленная внутри if-блока, переопределяет, или скрывает, внешнюю переменную i. Изменения, которым подверглась внутренняя переменная i, не оказывают никакого влияния на внешнюю i. Более того, вне if-блока внутренняя переменная i больше не существует, и поэтому внешняя переменная i снова становится видимой.
Поскольку локальные переменные создаются с каждым входом и разрушаются с каждым выходом из программного блока, в котором они объявлены, они не хранят своих значений между активизациями блоков. Это особенно важно помнить в отношении функций. При вызове функции ее локальные переменные создаются, а при выходе из нее — разрушаются. Это означает, что локальные переменные не сохраняют своих значений между вызовами функций. (Существует один способ обойти это ограничение — он будет рассмотрен ниже в этой книге.)
Локальные переменные не хранят своих значений между активизациями.
Локальные переменные хранятся в стеке, если не задан иной способ хранения. Поскольку стек — это динамически изменяемая область памяти, локальные переменные не могут в общем случае сохранять свои значения между вызовами функций.
Как упоминалось выше, несмотря на то, что локальные переменные обычно объявляются в начале своего блока, это не является обязательным. Локальные переменные можно объявить в любом месте блока, главное, чтобы это было сделано до их использования. Например, следующая программа вполне допустима.

#include <iostream>

using namespace std;

int main ()

{

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

int a; // Объявляем одну переменную.

cin >> a;

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

int b; // Объявляем еще одну переменную.

cin >> b;

cout << "Произведение равно: " << а*Ь << '\n';

return 0;

}
В этом примере переменные а и b не объявляются до тех пор, пока они станут нужными. Все же большинство программистов объявляют все локальные переменные в начале блока, в котором они используются, но это, как говорится, вопрос стилистики (или вкуса).
Объявление переменных в итерационных инструкциях и инструкциях выбора
Переменную можно объявить в разделе инициализации цикла for или условном выражении инструкций if, switch или while. Переменная, объявленная в одной из этих инструкций, имеет область видимости, которая ограничена блоком кода, управляемым этой инструкцией. Например, переменная, объявленная в инструкции цикла for, будет локальной для этого цикла, как показано в следующем примере.

#include <iostream>

using namespace std;

int main ()

{

// Переменная i локальная для цикла for.

for (int i=0; i<10; i++) {

cout << i << " ";

cout << "в квадрате равно " << i * i << «\n»;

}

// i = 10; // *** Ошибка *** — i здесь неизвестна!

return 0;

}
Здесь переменная i объявляется в разделе инициализации цикла for и используется для управления этим циклом. А за пределами цикла переменная i неизвестна.
В общем случае, если управляющая переменная цикла for не нужна за пределами этого цикла, то объявление ее внутри for-инструкции (как показано в этом примере) хорошо тем, что оно ограничивает ее существование рамками цикла и тем самым предотвращает случайное использование в каком-то другом месте программы. Профессиональные программисты часто объявляют управляющую переменную цикла внутри for-инструкции. Но если переменная требуется коду вне цикла, ее нельзя объявлять в инструкции for.
Важно! Утверждение о том, что переменная, объявленная в разделе инициализации цикла for, является локальной по отношению к этому циклу или не является таковой, изменилось со временем (имеется в виду время, в течение которого развивался язык C++). Первоначально такая переменная была доступна после выхода из цикла for. Однако стандарт C++ ограничивает область видимости этой переменной рамками цикла for. Но следует иметь в виду, что различные компиляторы и теперь по-разному «смотрят» на эту ситуацию.
Если ваш компилятор полностью соблюдает стандарт C++, то вы можете также объявить переменную в условном выражении инструкций if, switch или while. Например, в следующем фрагменте кода

if (int х = 20) {

cout << "Это значение переменной х: ";

cout << х;

}
объявляется переменная х, которой присваивается число 20. Поскольку это выражение оценивается как истинное, инструкция cout будет выполнена. Область видимости переменных, объявленных в условном выражении инструкции, ограничивается блоком кода, управляемым этой инструкцией. Следовательно, в данном случае переменная х неизвестна за пределами инструкции if. По правде говоря, далеко не все программисты считают объявление переменных в условном выражении инструкций признаком хорошего стиля программирования, и поэтому такой прием в этой книге больше не повторится.
Формальные параметры
Как вы знаете, если функция использует аргументы, она должна объявить переменные, которые будут принимать значения этих аргументов. Эти переменные называются формальными параметрами функции. Если не считать получения значений аргументов при вызове функции, то поведение формальных параметров ничем не отличается от поведения любых других локальных переменных внутри функции. Область видимости параметра ограничивается рамками его функции.
Программист должен гарантировать, что тип объявляемых им формальных параметров совпадает с типом аргументов, передаваемых функции. И еще. Несмотря на то что эти переменные выполняют специальную задачу получения значений аргументов, их можно использовать подобно любым другим локальным переменным. Например, параметру внутри функции можно присвоить какое-нибудь новое значение.
Глобальные переменные
Глобальные переменные во многих отношениях противоположны локальным. Они известны на протяжении всей программы, их можно использовать в любом месте кода. и они сохраняют свои значения во время выполнения всего кода программы. Следовательно, их область видимости расширяется до объема всей программы. Глобальная переменная создается путем ее объявления вне какой бы то ни было функции. Благодаря их глобальности доступ к этим переменным можно получить из любого выражения, вне зависимости от функции, в которой это выражение находится.
Если глобальная и локальная переменные имеют одинаковые имена, то преимущество находится на стороне локальной переменной. Другими словами, локальная переменная скроет глобальную с таким же именем. Таким образом, несмотря на то, что к глобальной переменной теоретически можно получить доступ из любого кода программы, практически это возможно только в случае, если одноименная локальная переменная не переопределит глобальную.
Использование глобальных переменных демонстрируется в следующей программе. Как видите, переменные count и num_right объявлены вне всех функций, следовательно, они— глобальные. Из обычных практических соображений лучше объявлять глобальные переменные поближе к началу программы. Но формально они просто должны быть объявлены до их первого использования. Предлагаемая для рассмотрения программа— всего лишь простой тренажер по выполнению арифметического сложения. Сначала пользователю предлагается указать количество упражнений. Для выполнения каждого упражнения вызывается функция drill (), которая генерирует два случайных числа в диапазоне от 0 до 99. Пользователю предлагается сложить эти числа, а затем проверяется ответ. На каждое упражнение дается три попытки. В конце программа отображает количество правильных ответов. Обратите особое внимание на глобальные переменные, используемые в этой программе.

// Простая программа-тренажер по выполнению сложения.

#include <iostream>

#include <cstdlib>

using namespace std;

void drill ();

int count; // Переменные count и num_right — глобальные.

int num_right;

int main ()

{

cout << "Сколько практических упражнений: ";

cin >> count;

num_right = 0;

do {

drill (); count--;

}while (count);

cout << "Вы дали " << num_right<< « правильных ответов.\n»;

return 0;

}

void drill ()

{

int count; /* Эта переменная count — локальная и никак не связана с одноименной глобальной.*/

int а, b, ans;

// Генерируем два числа между 0 и 99.

а = rand () % 100;

b = rand () % 100;

// Пользователь получает три попытки дать правильный ответ.

for (count=0; count<3; count++) {

cout << "Сколько будет " << а << " + " << b << "? ";

cin >> ans;

if (ans==a+b) {

cout << «Правильно\n»;

num_right++;

return;

}

}

cout << «Вы использовали все свои попытки.\n»;

cout << "Ответ равен " << a+b << '\n';

}
При внимательном изучении этой программы вам должно быть ясно, что как функция main (), так и функция drill () получают доступ к глобальной переменной num_right. Но с переменной count дело обстоит несколько сложнее. В функции main () используется глобальная переменная count. Однако в функции drill () объявляется локальная переменная count. Поэтому здесь при использовании имени count подразумевается именно локальная, а не глобальная переменная count. Помните, что, если в функции глобальная и локальная переменные имеют одинаковые имена, то при обращении к этому имени подразумевается локальная, а не глобальная переменная.
Хранение глобальных переменных осуществляется в некоторой определенной области памяти, специально выделяемой программой для этих целей. Глобальные переменные полезны в том случае, когда в нескольких функциях программы используются одни и те же данные, или когда переменная должна хранить свое значение на протяжении выполнения всей программы. Однако без особой необходимости следует избегать использования глобальных переменных, и на это есть три причины.
■ Они занимают память в течение всего времени выполнения программы, а не только тогда, когда действительно необходимы.
■ Использование глобальной переменной в «роли», с которой легко бы «справилась» локальная переменная, делает такую функцию менее универсальной, поскольку она полагается на необходимость определения данных вне этой функции.
■ Использование большого количества глобальных переменных может привести к появлению ошибок в работе программы, поскольку при этом возможно проявление неизвестных и нежелательных побочных эффектов. Основная проблема, характерная для разработки больших С++-программ, — случайная модификация значения переменной в каком-то другом месте программы. Чем больше глобальных переменных в программе, тем больше вероятность ошибки.
Передача указателей и массивов в качестве аргументов
До сих пор в приводимых здесь примерах функциям передавались значения простых переменных. Но возможны ситуации, когда в качестве аргументов необходимо использовать указатели и массивы. Рассмотрению особенностей передачи аргументов этого типа и посвящены следующие подразделы.
Вызов функций с указателями
В C++ разрешается передавать функции указатели. Для этого достаточно объявить параметр типа указатель. Рассмотрим пример.

// Передача функции указателя.

#include <iostream>

using namespace std;

void f (int *j);

int main ()

{

int i;

int *p;

p = &i; // Указатель p теперь содержит адрес переменной i.

f (p);

cout << i; // Переменная i теперь содержит число 100.

return 0;

}

void f (int *j)

{

*j = 100; // Переменной, адресуемой указателем j, присваивается число 100.

}
Как видите, в этой программе функция f () принимает один параметр: указатель на целочисленное значение. В функции main () указателю р присваивается адрес переменной i. Затем из функции main () вызывается функция f (), а указатель р передается ей в качестве аргумента. После того как параметр-указатель j получит значение аргумента р, он (так же, как и р) будет указывать на переменную i, определенную в функции main (). Таким образом, при выполнении операции присваивания

*j = 100;
переменная i получает значение 100. Поэтому программа отобразит на экране число 100. В общем случае приведенная здесь функция f () присваивает число 100 переменной, адрес которой был передан этой функции в качестве аргумента.
В предыдущем примере необязательно было использовать переменную р. Вместо нее при вызове функции f () достаточно использовать переменную i, предварив ее оператором «&» (при этом, как вы знаете, генерируется адрес переменной i). После внесения оговоренного изменения предыдущая программа приобретает такой вид.

// Передача указателя функции — исправленная версия.

#include <iostream>

using namespace std;

void f (int *j);

int main ()

{

int i;

f (&i);

cout << i;

return 0;

}

void f (int * j)

{

*j = 100; // Переменной, адресуемой указателем j, присваивается число 100.

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

#include <iostream>

using namespace std;

void display (int num[10]);

int main ()

{

int t[10], i;

for (i=0; i<10; ++i) t[i]=i;

display (t); // Передаем функции массив t.

return 0;

}

// Функция выводит все элементы массива.

void display (int num[10])

{

int i;

for (i=0; i<10; i++) cout << num[i] <<' ';

}
Несмотря на то что параметр num объявлен здесь как целочисленный массив, состоящий из 10 элементов, С++-компилятор автоматически преобразует его в указатель на целочисленное значение. Необходимость этого преобразования объясняется тем, что никакой параметр в действительности не может принять массив целиком. А так как будет передан один лишь указатель на массив, то функция должна иметь параметр, способный принять этот указатель.
Второй способ объявления параметра-массива состоит в его представлении в виде безразмерного массива, как показано ниже.

void display (int num[])

{

int i;

for (i=0; i<10; i++) cout << num[i] << ' ';

}
Здесь параметр num объявляется как целочисленный массив неизвестного размера. Поскольку C++ не обеспечивает проверку нарушения границ массива, то реальный размер массива — нерелевантный фактор для подобного параметра (но, безусловно, не для программы в целом). Целочисленный массив при таком способе объявления также автоматически преобразуется С++-компилятором в указатель на целочисленное значение.
Наконец, рассмотрим третий способ объявления параметра-массива. При передаче массива функции ее параметр можно объявить как указатель. Как раз этот вариант чаще всего используется профессиональными программистами. Вот пример:

void display (int *num)

{

int i;

for (i=0; i<10; i++) cout << num[i] << ' ';

}
Возможность такого объявления параметра (в данном случае num) объясняется тем, что любой указатель (подобно массиву) можно индексировать с помощью символов квадратных скобок ([]). Таким образом, все три способа объявления параметра-массива приводятся к одинаковому результату, который можно выразить одним словом: указатель.
Однако отдельный элемент массива, используемый в качестве аргумента, обрабатывается подобно обычной переменной. Например, рассмотренную выше программу можно было бы переписать, не используя передачу целого массива:

#include <iostream>

using namespace std;

void display (int num);

int main ()

{

int t[10],i;

for (i=0; i<10; ++i) t[i]=i;

for (i=0; i<10; i++) display (t[i]);

return 0;

}

// Функция выводит одно число.

void display (int num)

{

cout << num << ' ';

}
Как видите, параметр, используемый функцией display (), имеет тип int. Здесь не важно, что эта функция вызывается с использованием элемента массива, поскольку ей передается только один его элемент.
Помните, что, если массив используется в качестве аргумента функции, то функции передается адрес этого массива. Это означает, что код функции может потенциально изменить реальное содержимое массива, используемого при вызове функции. Например, в следующей программе функция cube () преобразует значение каждого элемента массива в куб этого значения. При вызове функции cube () в качестве первого аргумента необходимо передать адрес массива значений, подлежащих преобразованию, а в качестве второго — его размер.

#include <iostream>

using namespace std;

void cube (int *n, int num);

int main ()

{

int i, nums[10];

for (i=0; i<10; i++) nums[i] = i+1;

cout << "Исходное содержимое массива: ";

for (i=0; i<10; i++) cout << nums[i] << ' ';

cout << '\n';

cube (nums, 10); // Вычисляем кубы значений.

cout << "Измененное содержимое: ";

for (i=0; i<10; i++) cout << nums[i] << ' ';

return 0;

}

void cube (int *n, int num)

{

while (num) {

*n = *n * *n * *n;

num--;

n++;

}

}
Результаты выполнения этой программы таковы.

Исходное содержимое массива: 12345678910

Измененное содержимое: 1 8 27 64 125 216 343 512 729 1000
Как видите, после обращения к функции cube () содержимое массива nums изменилось: каждый элемент стал равным кубу исходного значения. Другими словами, элементы массива nums были модифицированы инструкциями, составляющими тело функции cube (), поскольку ее параметр n указывает на массив nums.
Передача функциям строк
Как вы уже знаете, строки в C++ — это обычные символьные массивы, которые завершаются нулевым символом. Таким образом, при передаче функции строки реально передается только указатель (типа char*) на начало этой строки. Рассмотрим, например, следующую программу. В ней определяется функция stringupper (), которая преобразует строку символов в ее прописной эквивалент.

// Передача функции строки.

#include <iostream>

#include <cstring>

#include <cctype>

using namespace std;

void stringupper (char *str);

int main ()

{

char str[80];

strcpy (str, «Мне нравится C++»);

stringupper (str);

cout << str; // Отображаем строку с использованием прописного написания символов.

return 0;

}

void stringupper (char *str)

{

while (*str) {

*str = toupper (*str); // Получаем прописной эквивалент одного символа.

str++; // Переходим к следующему символу.

}

}
Результаты выполнения этой программы таковы.

МНЕ НРАВИТСЯ C++
Обратите внимание на то, что параметр str функции stringupper () объявляется с использованием типа char*. Это позволяет получить указатель на символьный массив, который содержит строку. Рассмотрим еще один пример передачи строки функции. Как вы узнали в главе 5, стандартная библиотечная функция strlen () возвращает длину строки. В следующей программе показан один из возможных вариантов реализации этой функции.

// Одна из версий функции strlen ().

#include <iostream>

using namespace std;

int mystrlen (char *str);

int main ()

{

cout << "Длина строки ПРИВЕТ ВСЕМ равна: ";

cout << mystrlen («ПРИВЕТ ВСЕМ»);

return 0;

}

// Нестандартная реализация функции strlen ().

int mystrlen (char *str)

{

int i;

for (i=0; str[i]; i++); // Находим конец строки.

return i;

}
Вот как выглядят результаты выполнения этой программы.

Длина строки ПРИВЕТ ВСЕМ равна: 11
В качестве упражнения вам стоило бы попытаться самостоятельно реализовать другие строковые функции, например strcpy () или strcat (). Этот тест позволит узнать, насколько хорошо вы освоили такие элементы языка C++, как массивы, строки и указатели.
Аргументы функции main (): argc и argv
Аргумент командной строки представляет собой информацию, задаваемую в командной строке после имени программы.
Иногда возникает необходимость передать информацию программе при ее запуске. Как правило, это реализуется путем передачи аргументов командной строки функции main (). Аргумент командной строки представляет собой информацию, указываемую в команде (командной строке), предназначенной для выполнения операционной системой, после имени программы. (В Windows команда «Run» (Выполнить) также использует командную строку.) Например, С++-программы можно компилировать путем выполнения следующей команды,

cl prog_name
Здесь элемент prog_name — имя программы, которую мы хотим скомпилировать. Имя программы передается С++-компилятору в качестве аргумента командной строки.
В C++ для функции main () определено два встроенных, но необязательных параметра, argc и argv, которые получают свои значения от аргументов командной строки. В конкретной операционной среде могут поддерживаться и другие аргументы (такую информацию необходимо уточнить по документации, прилагаемой к вашему компилятору). Рассмотрим параметры argc и argv более подробно.
На заметку. Формально для имен параметров командной строки можно выбирать любые идентификаторы, однако имена argc и argv используются по соглашению уже в течение нескольких лет, и поэтому имеет смысл не прибегать к другим идентификаторам, чтобы любой программист, которому придется разбираться в вашей программе, смог быстро идентифицировать их как параметры командной строки.
Параметр argc имеет целочисленный тип и предназначен для хранения количества аргументов командной строки. Его значение всегда не меньше единицы, поскольку имя программы также является одним из учитываемых аргументов. Параметр argv представляет собой указатель на массив символьных указателей. Каждый указатель в массиве argv ссылается на строку, содержащую аргумент командной строки. Элемент argv[0] указывает на имя программы; элемент argv[1] — на первый аргумент, элемент argv[2] — на второй и т.д. Все аргументы командной строки передаются программе как строки, поэтому числовые аргументы необходимо преобразовать в программе в соответствующий внутренний формат.
Важно правильно объявить параметр argv. Обычно это делается так.

char *argv[];
Доступ к отдельным аргументам командной строки можно получить путем индексации массива argv. Как это сделать, показано в следующей программе. При ее выполнении на экран выводится приветствие («Привет» ), а за ним — ваше имя, которое должно быть первым аргументом командной строки.

#include <iostream>

using namespace std;

int main (int argc, char *argv[])

{

if (argc!=2) {

cout << «Вы забыли ввести свое имя.\n»;

return 1;

}

cout << "Привет, " << argv[1] << '\n';

return 0;

}
Предположим, что вас зовут Том и что вы назвали эту программу именем name. Тогда, если запустить эту программу, введя команду name Том, результат ее работы должен выглядеть так: Привет, Том. Например, вы работаете с диском А, и в ответ на приглашение на ввод команды должны ввести упомянутую выше команду и получить следующий результат.

A>name Том

Привет, Том

А>
В C++ точно не оговорено, как должны быть представлены аргументы командной строки, поскольку среды выполнения (операционные системы) имеют здесь большие различия. Однако чаще всего используется следующее соглашение: каждый аргумент командной строки должен быть отделен пробелом или символом табуляции. Как правило, запятые, точки с запятой и тому подобные знаки не являются допустимыми разделителями аргументов. Например, строка

один, два и три
состоит из четырех строковых аргументов, в то время как строка

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

«это лишь один аргумент»
Следует иметь в виду, что представленные здесь примеры применимы к широкому диапазону сред, но это не означает, что ваша среда входит в их число.
Чтобы получить доступ к отдельному символу в одном из аргументов командной строки, при обращении к массиву argv добавьте второй индекс. Например, при выполнении приведенной ниже программы посимвольно отображаются все аргументы, с которыми она была вызвана.

/* Эта программа посимвольно выводит все аргументы командной строки, с которыми она была вызвана.

*/

#include <iostream>

using namespace std;

int main (int argc, char *argv[])

{

int t, i;

for (t=0; t<argc; ++t) {

i = 0;

while (argv[t][i]) {

cout << argv[t][i];

++i;

}

cout << ' ';

}

return 0;

}
Нетрудно догадаться, что первый индекс массива argv позволяет получить доступ к соответствующему аргументу командной строки, а второй — к конкретному символу этого строкового аргумента.
Обычно аргументы argc и argv используются для ввода в программу начальных параметров, исходных значений, имен файлов или вариантов (режимов) работы программы. В C++ можно ввести столько аргументов командной строки, сколько допускает операционная система. Использование аргументов командной строки придает программе профессиональный вид и позволяет использовать ее в командном файле (исполняемом текстовом файле, содержащем одну или несколько команд).
Передача числовых аргументов командной строки
Как упоминалось выше, при передаче программе числовых данных в качестве аргументов командной строки эти данные принимаются в строковой форме. В программе должно быть предусмотрено их преобразование в соответствующий внутренний формат с помощью одной из стандартных библиотечных функций, поддерживаемых C++. Например, при выполнении следующей программы выводится сумма двух чисел, которые указываются в командной строке после имени программы. Для преобразования аргументов командной строки во внутреннее представление здесь используется стандартная библиотечная функция atof (). Она преобразует число из строкового формата в значение типа double.

/* Эта программа отображает сумму двух числовых аргументов командной строки.

*/

#include <iostream>

#include <cstdlib>

using namespace std;

int main (int argc, char *argv[])

{

double a, b;

if (argc!=3) {

cout << «Использование: add число число\n»;

return 1;

}

a = atof (argv[1]);

b = atof (argv[2]);

cout << a + b;

return 0;

}
Чтобы сложить два числа, используйте командную строку такого вида (предполагая, что эта программа имеет имя add).

C>add 100.2 231
Преобразование числовых строк в числа
Стандартная библиотека C++ включает несколько функций, которые позволяют преобразовать строковое представление числа в его внутренний формат. Для этого используются такие функции, как atoi (), atol () и atof (). Они преобразуют строку в целочисленное значение (типа int), длинное целое (типа long) и значение с плавающей точкой (типа double) соответственно. Использование этих функций (для их вызова необходимо включить в программу заголовочный файл <cstdlib>) демонстрируется в следующей программе.

// Демонстрация использования функций atoi (), atol () и atof ().

#include <iostream>

#include <cstdlib>

using namespace std;

int main ()

{

int i;

long j;

double k;

i = atoi («100»);

j = atol («100000»);

k = atof («-0.123»);

cout << i << ' ' << j << ' ' << k;

cout << ' \n';

return 0;

}
Результаты выполнения этой программы таковы.

100 100000 -0.123
Функции преобразования строк полезны не только при передаче числовых данных программе через аргументы командной строки, но и в ряде других ситуаций.
Инструкция return
До сих пор (начиная с главы 2) мы использовали инструкцию return без подробных разъяснений. Напомним, что инструкция return выполняет две важные операции. Во-первых, она обеспечивает немедленное возвращение управления к инициатору вызова функции. Во-вторых, ее можно использовать для передачи значения, возвращаемого функцией. Именно этим двум операциям и посвящен данный раздел.
Завершение функции
Как вы уже знаете, управление от функции передается инициатору ее вызова в двух ситуациях: либо при обнаружении закрывающейся фигурной скобки, либо при выполнении инструкции return. Инструкцию return можно использовать с некоторым заданным значением либо без него. Но если в объявлении функции указан тип возвращаемого значения (т.е. не тип void), то функция должна возвращать значение этого типа. Только void-функции могут использовать инструкцию return без какого бы то ни было значения.
Для void-функций инструкция return главным образом используется как элемент программного управления. Например, в приведенной ниже функции выводится результат возведения числа в положительную целочисленную степень. Если же показатель степени окажется отрицательным, инструкция return обеспечит выход из функции, прежде чем будет сделана попытка вычислить такое выражение. В этом случае инструкция return действует как управляющий элемент, предотвращающий нежелательное выполнение определенной части функции.

void power (int base, int exp)

{

int i;

if (exp<0) return; /* Чтобы не допустить возведения числа в отрицательную степень, здесь выполняется возврат в вызывающую функцию и игнорируется остальная часть функции. */

i = 1;

for ( ; exp; exp--) i = base * i;

cout << "Результат равен: " << i;

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

void f ()

{

// ...

switch© {

case 'a': return;

case 'b': // ...

case 'c': return;

}

if (count<100) return;

// ...

}
Однако следует иметь в виду, что слишком большое количество инструкций return может ухудшить ясность алгоритма и ввести в заблуждение тех, кто будет в нем разбираться. Несколько инструкций return стоит использовать только в том случае, если они способствуют ясности функции.
Возврат значений
Каждая функция, кроме типа void, возвращает какое-нибудь значение. Это значение явно задается с помощью инструкции return. Другими словами, любую не void-функцию можно использовать в качестве операнда в выражении. Следовательно, каждое из следующих выражений допустимо в C++.

х = power (у);

if (max (х, у)) > 100) cout << «больше»;

switch (abs (х)) {
Несмотря на то что все не void-функции возвращают значения, они необязательно должны быть использованы в программе. Самый распространенный вопрос относительно значений, возвращаемых функциями, звучит так: «Поскольку функция возвращает некоторое значение, то разве я не должен (должна) присвоить это значение какой-нибудь переменной?». Ответ: нет, это необязательно. Если значение, возвращаемое функцией, не участвует в присваивании, оно попросту отбрасывается (теряется).
Рассмотрим следующую программу, в которой используется стандартная библиотечная функция abs ().

#include <iostream>

#include <cstdlib>

using namespace std;

int main ()

{

int i;

i = abs (-10); // строка 1

cout << abs (-23); // строка 2

abs (100); // строка 3

return 0;

}
Функция abs () возвращает абсолютное значение своего целочисленного аргумента. Она использует заголовок <cstdlib>. В строке 1 значение, возвращаемое функцией abs (), присваивается переменной i. В строке 2 значение, возвращаемое функцией abs (), ничему не присваивается, но используется инструкцией cout. Наконец, в строке 3 значение, возвращаемое функцией abs (), теряется, поскольку не присваивается никакой другой переменной и не используется как часть выражения.
Если функция, тип которой отличен от типа void, завершается в результате обнаружения закрывающейся фигурной скобки, то значение, которое она возвращает, не определено (т.е. неизвестно). Из-за особенностей формального синтаксиса C++ не void-функция не обязана выполнять инструкцию return. Это может произойти в том случае, если конец функции будет достигнут до обнаружения инструкции return. Но, поскольку функция объявлена как возвращающая значение, значение будет таки возвращено, даже если это просто «мусор». В общем случае любая создаваемая вами не void-функция должна возвращать значение посредством явно выполняемой инструкции return.
Выше упоминалось, что void-функция может иметь несколько инструкций return. То же самое относится и к функциям, которые возвращают значения. Например, представленная в следующей программе функция find_substr () использует две инструкции return, которые позволяют упростить алгоритм ее работы. Эта функция выполняет поиск заданной подстроки в заданной строке. Она возвращает индекс первого обнаруженного вхождения заданной подстроки или значение -1, если заданная подстрока не была найдена. Например, если в строке "Я люблю C++ " необходимо отыскать подстроку «люблю», то функция find_substr () возвратит число 2 (которое представляет собой индекс символа «л» в строке "Я люблю C++ ").

#include <iostream>

using namespace std;

int find_substr (char *sub, char *str);

int main ()

{

int index;

index = find_substr («три», «один два три четыре»);

cout << "Индекс равен " << index; // Индекс равен 9.

return 0;

}

// Функция возвращает индекс искомой подстроки или -1, если она не была найдена.

int find_substr (char *sub, char *str)

{

int t;

char *p, *p2;

for (t=0; str[t]; t++) {

p = &str[t]; // установка указателей

p2 = sub;

while (*p2 && *p2==*p) { // проверка совпадения

p++; p2++;

}

/* Если достигнут конец р2-строки (т.е. подстроки), то подстрока была найдена. */

if (!*p2) return t; // Возвращаем индекс подстроки.

}

return -1; // Подстрока не была обнаружена.

}
Результаты выполнения этой программы таковы.

Индекс равен 9
Поскольку искомая подстрока существует в заданной строке, выполняется первая инструкция return. В качестве упражнения измените программу так, чтобы ею выполнялся поиск подстроки, которая не является частью заданной строки. В этом случае функция find_substr () должна возвратить значение -1 (благодаря второй инструкции return).
Функцию можно объявить так, чтобы она возвращала значение любого типа данных, действительного для C++ (за исключением массива: функция не может возвратить массив). Способ объявления типа значения, возвращаемого функцией, аналогичен тому, который используется для объявления переменных: имени функции должен предшествовать спецификатор типа. Спецификатор типа сообщает компилятору, значение какого типа данных должна возвратить функция. Указываемый в объявлении функции тип должен быть совместимым с типом данных, используемым в инструкции return. В противном случае компилятор отреагирует сообщением об ошибке.
Функции, которые не возвращают значений (void-функции)
Как вы заметили, функции, которые не возвращают значений, объявляются с указанием типа void. Это ключевое слово не допускает их использования в выражениях и защищает от неверного применения. В следующем примере функция print_vertical () выводит аргумент командной строки в вертикальном направлении (вниз) по левому краю экрана. Поскольку эта функция не возвращает никакого значения, в ее объявлении использовано ключевое слово void.

#include <iostream>

using namespace std;

void print_vertical (char *str);

int main (int argc, char *argv[])

{

if (argc==2) print_vertical (argv[1]);

return 0;

}

void print_vertical (char *str)

{

while (*str)

cout << *str++ << '\n';

}
Поскольку print_vertical () объявлена как void-функция, ее нельзя использовать в выражении. Например, следующая инструкция неверна и поэтому не скомпилируется.

х = print_vertical («Привет!»); // ошибка
Важно! В первых версиях языка С не был предусмотрен тип void. Таким образом, в старых С-программах функции, не возвращающие значений, по умолчанию имели тип int. Если вам придется встретиться с такими функциями при переводе старых С-программ «на рельсы» C++, просто объявите их с использованием ключевого слова void, сделав их void-функциями.
Функции, которые возвращают указатели
Функции могут возвращать указатели. Указатели возвращаются подобно значениям любых других типов данных и не создают при этом особых проблем. Но, поскольку указатель представляет собой одно из самых сложных (или небезопасных) средств языка C++, имеет смысл посвятить ему отдельный раздел.
Чтобы вернуть указатель, функция должна объявить его тип в качестве типа возвращаемого значения. Вот как, например, объявляется тип возвращаемого значения для функции f (), которая должна возвращать указатель на целое число.

int *f ();
Если функция возвращает указатель, то значение, используемое в ее инструкции return, также должно быть указателем. (Как и для всех функций, return-значение должно быть совместимым с типом возвращаемого значения.)
В следующей программе демонстрируется использование указателя в качестве типа возвращаемого значения. Это — новая версия приведенной выше функции find_substr (), только теперь она возвращает не индекс найденной подстроки, а указатель на нее. Если заданная подстрока не найдена, возвращается нулевой указатель.

// Новая версия функции find_substr ().

// которая возвращает указатель на подстроку.

#include <iostream>

using namespace std;

char *find_substr (char *sub, char *str);

int main ()

{

char *substr;

substr = find_substr («три», «один два три четыре»);

cout << "Найденная подстрока: " << substr;

return 0;

}

// Функция возвращает указатель на искомую подстроку или нуль, если таковая не будет найдена.

char *find_substr (char *sub, char *str)

{

int t;

char *p, *p2, *start;

for (t=0; str[t]; t++) {

p = &str[t]; // установка указателей

start = p;

р2 = sub;

while (*р2 && *p2==*p) { // проверка совпадения

р++; р2++;

}

/* Если достигнут конец р2-подстроки, то эта подстрока была найдена. */

if (!*р2) return start; // Возвращаем указатель на начало найденной подстроки.

}

return 0; // подстрока не найдена

}
При выполнении этой версии программы получен следующий результат.

Найденная подстрока: три четыре
В данном случае, когда подстрока «три» была найдена в строке «один два три четыре», функция find_substr () возвратила указатель на начало искомой подстроки «три», который в функции main () был присвоен переменной substr. Таким образом, при выводе значения substr на экране отобразился остаток строки, т.е. «три четыре».
Многие поддерживаемые C++ библиотечные функции, предназначенные для обработки строк, возвращают указатели на символы. Например, функция strcpy () возвращает указатель на первый аргумент.

Комментирование и размещение ссылок запрещено.

Комментарии закрыты.