Лекции по информатике
Подождите немного. Документ загружается.
myfunc()
{
static int count;
}
Адреса хранения статических переменных остаются неизменными на протяжении
всего времени выполнения программы. После прекращения работы функции память,
закрепленная за переменной, не освобождается, поэтому и записанное в ней значение
переменной сохраняется. При следующем вызове этой же функции переменная будет
иметь значение, оставшееся от предыдущего вызова. Запомните, что переменная при
этом остается локальной и имеет смысл только внутри своей функции.
Передача параметров по значению
Когда параметр передается в функцию, по умолчанию используется техника,
известная как передача параметра по значению, при которой функция обеспечивается
копией значения параметра. При передаче параметра по значению любые изменения,
выполняемые в функции над значением данного параметра, существуют только внутри
самой функции. Когда функция завершается, значение переменной, переданной по
значению, оказывается не измененным. Например, в следующей программе функции
display_and_change передаются три параметра (переменные a, b и с):
#include <stdio.h>
void display_and_change(int first, int second, int third)
{
printf("Начальные значения функции %d %d %d\n",
first, second, third);
first += 100;
second +=100;
third += 100;
printf("Конечные значения функции %d %d %d\n",
first, second, third);
}
void main(void)
{
int a=l, b=2, с = 3;
display_and_change(a, b, c);
printf("Конечные значения main %d %d %d\n", a, b ,c);
}
После компиляции и выполнения программы на экран выводится:
C:\> NOCHANGE <ЕNTER>
Начальные значения функции 123
Конечные значения функции 101 102 103
Конечные значения main 123
Как можно видеть, изменения, которые выполняются в функции для переменных,
действенны только в самой функции. После завершения функции значения переменных в
main остаются неизмененными.
При передаче параметров в функцию их значения размещаются в стеке. Для
случая переменных a, b и с в стеке будут содержаться значения 1,2 и 3 соответственно.
Любые изменения, выполняемые в функции над значениями параметров, в
действительности изменяют значения ячеек стека.
При завершении выполнения функции стек освобождается, а следовательно,
пропадают и изменения, сделанные функцией в ячейках стека. Ячейки памяти,
содержащие значение каждой переменной, функцией не использовались. Таким образом,
при передаче параметра по значению функция не может выполнить такую модификацию
значений параметров, которая бы оставалась действующей и после завершения
функции.
Передача параметров по ссылке
Как известно, в Си по умолчанию параметры передаются функции по значению.
При таком способе передачи параметра функция не имеет возможности изменить
значение передаваемой ей переменной таким образом, чтобы это изменение имело
место и после завершения выполнения функции. Однако в большинстве программ
бывает необходимо, чтобы функции тем или иным способом изменяли значения своих
параметров. Например, функция, которая читает информацию из файла, должна
возвращать считанные данные в массиве символьной строки.
Для того чтобы функция могла возвращать модифицированное значение своего
параметра, при вызове такой функции должен использоваться способ, называемый
передача параметра по ссылке. Различие между передачей параметра по значению и по
ссылке заключается в том, что в первом случае функция получает копию значения
параметра, а во втором - адрес значения переменной. Таким образом, при получении
параметра по ссылке функция может производить изменения значения, сохраненного по
данному адресу, и эти изменения остаются в силе и после завершения функции. Для
организации передачи параметров функции по ссылке в программе должны
использоваться указатели. Подробно этот тип переменных обсуждается в разделе
"Массивы, указатели и структуры". Здесь же будем рассматривать указатель просто как
адрес памяти. Для присваивания указателю адреса переменной используется операция
получения адреса (&). Для доступа к значению, расположенному по месту памяти,
задаваемому указателем, применяется операция "звездочка" (*).
int x;
int &y=x;
Идентификатор y назначает другое, альтернативное имя ячейке, названной x. Если
прибавить к значению переменной x некоторое число, то оно будет прибавлено и к
переменной y.
#include <iostream.h>
#include <conio.h>
void summa(int &number1, int &number2)
{
number1++;
number2++;
}
void main()
{
int a=10;
int b=15;
cout<<"Before upd "<<a<<" "<<b;
summa(a,b);
cout<<"\nAfter upd "<<a<<" "<<b;
getch();
}
Результат
Before upd 10 15
After upd 11 16
Так как number1 и a – это одна и та же ячейка, то изменение number1
автоматически приведет к изменению переменной a (аналогично number2 и b).
Значения параметров по умолчанию
Как вы уже знаете, C++ позволяет вам с помощью параметров передавать
информацию в функции. Кроме этого, в C++ при вызове функций можно опускать
параметры. В таких случаях для опущенных параметров будут использоваться значения
по умолчанию. Обеспечение значений по умолчанию для параметров упрощает
возможность повторного использования функций (их использования несколькими
программами).
Обеспечить значения по умолчанию для параметров функции очень легко. Вы
просто присваиваете значение параметру с помощью оператора присваивания С++
прямо при объявлении функции, как показано ниже:
void some_function(int size=12, float cost=19.95) //--->Значения по умолчанию
{
MMM// Операторы функции
}
Следующая программа присваивает значения по умолчанию параметрам a, b и c
внутри функции show_parameters. Затем программа четыре раза вызывает эту функцию,
сначала не указывая параметров вообще, затем указывая значение только для а, потом
значения для а и b и, наконец, указывая значения для всех трех параметров:
#include <iostream.h>
void show__parameters (int a=1, int b=2, int c=3)
{
MMMcout << "a" << a << " b " << b << " с " << с << endl;
}
void main(void)
{
MMMshow_parameters();
MMMshow_parameters(1001);
MMMshow_parameters(1001, 2002);
MMMshow_parameters(1001, 2002, 3003);
}
Когда вы откомпилируете и запустите эту программу, на вашем экране появится
следующий вывод:
С:\> DEFAULTS <ENTER>
а 1 b 2 с 3
а 1001 b 2 с 3
а 1001 b 2002 с 3
а 1001 b 2002 с 3003
Как видите, если необходимо, функция использует значения параметров по
умолчанию.
Правила для пропуска значений параметров
Если программа опускает значения параметров при вызове функции, функция
использует значения по умолчанию. Если программа опускает определенный параметр
для функции, обеспечивающей значения по умолчанию, то следует опустить и все
последующие параметры. Другими словами, вы не можете опускать средний параметр. В
случае предыдущей программы, если требовалось опустить значение параметра b в
show_parameters, программа также должна была опустить значение параметра с. Вы не
можете указать значение для а и с, опуская значение b.
По мере увеличения количества созданных программ и функций, вероятно,
встретятся функции, которые вообще не имеют параметров. При определении такой
функции (и ее прототипа) следует применить ключевое слово void. С помощью void
компилятору (и другим программам) сообщается о том, что функция не использует
параметров:
int my_function(void);
Если в дальнейшем в программе будет сделана попытка использовать такую
функцию с параметрами, то компилятор выдаст ошибку.
Перегрузка функций
При определении функций в своих программах вы должны указать тип
возвращаемого функцией значения, а также количество параметров и тип каждого из них.
При программировании на языке С, когда у вас была функция, например, с именем
add_values, которая работала с двумя целыми значениями, а вы хотели бы использовать
подобную функцию для сложения трех целых значений, вам следовало создать функцию
с другим именем. Например, вы могли бы использовать add_two_values и
add_three_values. Аналогично если вы хотели использовать подобную функцию для
сложения значений типа float, то вам была бы необходима еще одна функция с еще
одним именем. Чтобы избежать дублирования функции, C++ позволяет вам определять
несколько функций с одним и тем же именем. В процессе компиляции C++ принимает во
внимание количество аргументов, используемых каждой функцией, и затем вызывает
именно требуемую функцию. Предоставление компилятору выбора среди нескольких
функций называется перегрузкой.
Перегрузка функций позволяет вам использовать одно и то же имя для нескольких
функций с разными типами параметров. Перегруженные функции не обязаны возвращать
значения одинакового типа по той причине, что компилятор однозначно идентифицирует
функцию по ее имени и набору ее аргументов. Для компилятора функции с одинаковыми
именами, но различными типами аргументов — разные функции, поэтому тип
возвращаемого значения — прерогатива каждой функции.
Для перегрузки функций просто определите две функции с одним и тем же
именем, которые отличаются количеством параметров или их типом.
Например, следующая программа перегружает функцию с именем add_values.
Первое определение функции складывает два значения типа int. Второе определение
функции складывает три значения. В процессе компиляции C++ корректно определяет
функцию, которую необходимо использовать:
#include <iostream.h>
int add_values(int a,int b)
{
MMMreturn(a + b);
)
int add_values (int a, int b, int c)
(
MMMreturn(a + b + c);
)
void main(void)
{
MMMcout << "200 + 801 = " << add_values(200, 801) << endl;
MMMcout << "100 + 201 + 700 = " << add_values(100, 201, 700) << endl;
}
Как видите, программа определяет две функции с именами add_values Первая
функция складывает два значения типа int, в то время как вторая складывает три
значения. Вы не обязаны что-либо предпринимать специально для того, чтобы
предупредить компилятор о перегрузке, просто используйте ее. Компилятор разгадает,
какую функцию следует использовать, основываясь на предлагаемых программой
параметрах.
Одним из наиболее общих случаев использования перегрузки является
применение функции для получения определенного результата, исходя из различных
параметров. Например, предположим, что в вашей программе есть функция с именем
day_of_week, которая возвращает текущий день недели (0 для воскресенья, 1 для
понедельника, ..., 6 для субботы). Ваша программа могла бы перегрузить эту функцию
таким образом, чтобы она верно возвращала день недели, если ей передан юлианский
день в качестве параметра, или если ей переданы день, месяц и год:
int day_of_week(int julian_day)
{
MMM// Операторы
}
int day_of_week(int month, int day, int year)
{
MMM// Операторы
}
Рекурсия
Как известно, в языке Си программу можно разбить на мелкие части,
представляющие собой функции. При использовании функций программа становится
более понятной, более легкой для программирования и отладки. Кроме того, функции,
созданные для одной программы, часто пригодны для использования в другой. При
выполнении программы одна функция может вызывать другую, которая, в свою очередь,
вызывает третью и т.д.
Рекурсивной функцией называется функция, которая для выполнения
определенной операции вызывает саму себя. Процесс вызова функцией самой себя
называется рекурсией. По мере возрастания сложности программ и функций может
оказаться, что при определении некоторых операций удобно использовать сами эти
операции. В таких случаях имеет смысл создавать рекурсивные функции. Классическим
примером рекурсивной обработки является вычисление факториала. Факториал значения
1 равен 1. Факториал значения 2 равен 2*1. Факториал значения 3 равен 3*2*1.
Аналогично, факториал значения 4 равен 4*3*2*1. Этот процесс может быть продолжен
до бесконечности. Если внимательно приглядеться к процессу вычисления факториала,
то можно увидеть, что факториал, например, от 4 равен 4-кратному значению факториала
от 3 (3*2*1). Аналогично, факториал от 3 равен 3-кратному значению факториала от 2
(2*1). Факториал от 2 равен двукратному значению факториала от 1 (1). В таблице
демонстрируется вычисление факториала.
Таблица. Вычисление факториала
Значение Вычисление Результат Факториал
1 1 1 1
2 2*1 2 2*Factorial(l)
3 3*2*1 6 3* Factorial(2)
4 4*3*2*1 24 4* Factorial(3)
5 5*4*3*2*1 120 5* Factorial(4)
В следующей программе представлена рекурсивная функция factorial, которая
используется для вычисления факториала значений от 1 до 5:
#include <stdio.h>
int factorial (int value)
{
if (value ==1)
return(1);
else
return(value * factorial(value-1));
}
void main(void)
{
int i;
for (i =1; i <= 5; i++)
printf("Факториал от %d равен %d\n", i, factorial(i));
}
Как можно видеть, функция factorial возвращает значение, которое основывается
на результате вызова самой этой функции.
При выполнении этой функции первым делом осуществляется проверка значения
параметра на равенство 1. Если значение равно 1, то функция возвращает 1. В
противном случае, в качестве результата возвращается значение, равное произведению
значения входного параметра и факториала от числа, равного значению параметра минус
1. Например, предположим, что функция вызывается со значением 3. Тогда в качестве
результата функцией будет возвращено 3*factorial(3-1). Обнаруживая в операторе return
вызов функции factorial, компилятор организует повторный вызов, на этот раз со
значением 3-1 или 2. Поскольку значение не равно 1, результатом выполнения функции
будет 2*factorial(2-1). Наконец, при следующем вызове функции значение параметра
равно 1, поэтому в качестве результата вызвавшей программе (функции) возвращается
значение 1.
Рекурсивная функция чем-то похожа на конструкцию цикла в том, что в обоих
случаях должно быть задано условие завершения. Если это не сделано, то функция
никогда не завершится. Для рассмотренной функции вычисления факториала условием
завершения является факториал от 1, который по определению равен 1.
Когда для реализации некоторой задачи функция обращается к самой себе,
говорят, что она выполняет прямую рекурсию. Изучив несколько примеров рекурсивных
функций, можно разобраться и в большинстве других, использующих прямую рекурсию.
Более сложная форма рекурсии, косвенная рекурсия, образуется, когда некоторая
функция (функция А) вызывает другую функцию (функцию В), которая в свою очередь
вызывает первую функцию (функцию А). Поскольку косвенная рекурсия имеет более
сложный код для понимания, следует по возможности избегать использования такого
вида рекурсии.
Встроенные функции
Единственное неудобство при использовании функций состоит в том, что они
увеличивают издержки (увеличивают время выполнения), помещая параметры в стек при
каждом вызове.
Для улучшения производительности за счет уменьшения издержек на вызов
функции вы можете заставить компилятор C++ встроить в программу код функции,
подобно тому, как это делается при замещении макрокоманд.
Используя встроенные (inline) функции, ваши программы остаются удобными для
чтения (читающий программу видит вызов функции), но вы избегаете издержек на вызов
функции, которые вызваны помещением параметров в стек и их последующим
извлечением из стека, а также переходом к телу функции и последующим возвратом из
нее.
Когда вы определяете в своей программе функцию, компилятор C++ переводит
код функции в машинный язык, сохраняя только одну копию инструкций функции внутри
вашей программы. Каждый раз, когда ваша программа вызывает функцию, компилятор
C++ помещает в программу специальные инструкции, которые заносят параметры
функции в стек и затем выполняют переход к инструкциям этой функции. Когда
операторы функции завершаются, выполнение программы продолжается с первого
оператора, который следует за вызовом функции. Помещение аргументов в стек и
переход в функцию и из нее вносит издержки, из-за которых ваша программа
выполняется немного медленнее, чем если бы она размещала те же операторы прямо
внутри программы при каждой ссылке на функцию. Например, предположим, что
следующая программа CALLBEEP.CPP вызывает функцию show_message, которая
указанное число раз выдает сигнал на динамик компьютера и затем выводит сообщение
на дисплей:
#include <iostream.b>
void show_message(int count, char *message)
{
MMMint i;
MMMfor (i = 0; i < count; i++) cout << '\a';
MMMcout << message << endl;
}
void main(void)
{
MMMshow_message(3, "Учимся программировать на языке C++");
MMMshow_mes sage(2, "Встроенные функции");
}
Следующая программа NO_CALL.CPP не вызывает функцию show_message.
Вместо этого она помещает внутри себя те же операторы функции при каждой ссылке на
функцию:
#include <iostream.h>
void main (void)
{
MMMint i;
MMMfor (i = 0; i < 3; i++) cout << '\a';
MMMcout << " Учимся программировать на языке C++" << endl;
MMMfor (i = 0; i < 2; i++) cout << '\a';
MMMcout << " Встроенные функции " << endl;
}
Обе программы выполняют одно и то же. Поскольку программа NO_CALL не
вызывает функцию show_message, она выполняется немного быстрее, чем программа
CALLBEEP. В данном случае разницу во времени выполнения определить невозможно,
но, если в обычной ситуации функция будет вызываться 1000 раз, вы, вероятно, заметите
небольшое увеличение производительности. Однако программа NO_CALL более
запутана, чем ее двойник CALL_BEEP, следовательно, более тяжела для восприятия.
При создании программ вы всегда должны попытаться определить, когда лучше
использовать обычные функции, а когда лучше воспользоваться встроенными
функциями. Для более простых программ предпочтительно использовать обычные
функции. Однако, если вы создаете программу, для которой производительность имеет
первостепенное значение, вам следовало бы уменьшить количество вызовов функций.
Один из способов уменьшения количества вызовов функций состоит в том, чтобы
поместить соответствующие операторы прямо в программу, как только что было сделано
в программе NO_CALL. Однако, как вы могли убедиться, замена только одной функции
внесла значительную путаницу в программу. К счастью, C++ предоставляет ключевое
слово inline, которое обеспечивает лучший способ.
Использование ключевого слова inline
При объявлении функции внутри программы C++ позволяет вам предварить имя
функции ключевым словом inline. Если компилятор C++ встречает ключевое слово inline,
он помещает в выполнимый файл (машинный язык) операторы этой функции в месте
каждого ее вызова. Таким образом, можно улучшить читаемость ваших программ на C++,
используя функции, и в то же время увеличить производительность, избегая издержек на
вызов функций. Следующая программа INLINE.CPP определяет функции тах и min как
inline:
#include <iostream.h>
inline int max(int a, int b)
{
MMMif (a > b) return(a);
MMMelse return(b) ;
}
inline int min(int a, int b)
{
MMMif (a < b) return(a);
MMMelse return(b);
}
void main(void)
{
MMMcout << "Минимум из 1001 и 2002 равен " << min(1001, 2002) << endl;
MMMcout << "Максимум из 1001 и 2002 равен " << max(1001, 2002) << endl;
}
В данном случае компилятор C++ заменит каждый вызов функции на
соответствующие операторы функции. Производительность программы увеличивается
без ее усложнения.
Обработка символьных данных
Вывод в C/C++
Выводом называется процедура переноса данных из памяти компьютера в другое
место. Данные можно вывести на экран, отпечатать на принтере или сохранить на диске в
виде файла. Кроме того, данные можно сохранить на магнитной ленте или послать по
телефонной линии через модем или по факсу.
Вывод данных не означает, что они удаляются из памяти компьютера или что
изменяется способ их хранения, компьютер просто копирует данные и посылает их куда-
то еще.
Функции, используемые для вывода данных, зависят от типа данных и способа их
представления. Наиболее прост вывод строк и символьных данных.
Функция puts()
Параметр (информация, заключенная в круглые скобки, которая выводится на
экран) должен относиться к одному из следующих типов данных:
строковый литерал:
puts("Всем привет!");
строковая константа:
#define MESSAGE "Всем привет"
main()
{
puts(MESSAGE);
}
строковая переменная:
char greeting[]="Всем привет";
main()
{
puts(geering);
}
Использование любого другого типа констант, переменных или литералов
приведет к ошибке компиляции. Строковый литерал, в отличие от имени константы или
переменной, должен быть заключен в двойные кавычки.
Большинство компиляторов выполняют перевод строки после выполнения
функции puts(). Это значит, что после того, как данные выведены на экран монитора,
курсор автоматически переходит в начало следующей строки.
Функция putchar()
Функция putchar() предназначена для вывода единичного символа на экран.
Параметром функции может являться:
символьный литерал:
putchar('H');
символьная константа:
#define INITIAL 'H'
main()
{
putchar(INITIAL);
}
символьная переменная:
main()
{
char letter;
letter='G';
putchar(letter);
}
С помощью функции putchar() можно отображать только один символ. Инструкция
putchar('Hi');
приведет к ошибке компиляции.
При выводе на экран символьного литерала или управляющего кода их следует
заключать в одинарные кавычки.
Большинство компиляторов Си не имеет автоматического перевода строки после
функции putchar(), и курсор остается сразу за выведенным символом, не переходя к
началу следующей строки. Для перехода на новую строку вы должны ввести
управляющий код \n.
Функция printf()
Функции puts() и putchar() используются довольно часто, но, к сожалению, их
возможности несколько ограничены. Ни одна из них не может обеспечить вывод
числовых данных, и обе они имеют только один аргумент (параметр). Это означает, что
обе функции могут отобразить только один объект.
Языки Си и Си++ имеют более многостороннюю функцию, называемую printf(). Она
позволяет выводить на дисплей данные всех типов и работать со списком из нескольких
аргументов. Кроме того, при вызове функции printf() можно определить способ
форматирования данных.
В простейшем случае функцию printf() можно использовать вместо функции puts()
для вывода строки:
#define MESSAGE "Привет!"
main()
{
printf(MESSAGE);
printf("Добро пожаловать в мой мир! ");
}
Так же как и puts(), функция printf() будет выводить на экран строки, заключенные в
кавычки, и значения строковых констант и переменных.
Для того чтобы иметь возможность форматировать данные всех типов, список
параметров, передаваемый функции printf(), делится на две части. Первый параметр
называется управляющей строкой или строкой формата. Этот параметр заключается в
кавычки и указывает компилятору, в какой позиции строки должны появиться данные.
Строка формата может содержать любой текст вместе с метками, которые называются
указателями формата и определяют тип данных, а также их расположение.
Каждый указатель формата начинается с символа процента (%), после которого
стоит буква, указывающая тип данных:
%d целое число
%u беззнаковое целое число
%f вещественное число типа float или double
%e вещественное число в экспоненциальной форме
%g
вещественное число, отображаемое по формату
%f или %e, в зависимости от того, какая
форма записи является более короткой
%c символ
%s строка
Таким образом, первая часть инструкции printf() записывается так:
printf("%d")
Знак процента говорит компилятору, что за ним последует указатель формата
(чтобы отобразить сам символ процента, напишите его дважды: printf("%%");).
Буква d указывает компилятору, что следует отобразить целое число, записанное
в десятичной системе счисления.
Второй частью списка параметров является список данных, содержащий
литералы, имена констант или имена переменных, значение которых необходимо
отобразить на дисплее. Список данных отделяется от строки формата запятой. Между
собой все элементы списка данных также разделяются запятыми. Когда компилятор
создает объектные коды, он подставляет на место указателей формата значения из
списка данных.
Простейший пример использования функции printf() приведен ниже:
printf("%d", 12);
В процессе выполнения этой инструкции значение 12 будет подставлено на место
указателя формата. В нашем примере мы на самом деле передали библиотечной
функции printf() два параметра: строку формата и числовой литерал12.
Строка формата может содержать и обыкновенный текст с включенными в него
указателями формата. Например, взгляните на инструкцию:
printf("Мне исполнилось %d лет", 12);
Строкой формата в этом примере является запись
"Мне исполнилось %d лет"
Указатель формата, %d, говорит о том, что мы хотим вставить число между
словами "Мне исполнилось" и словом "лет". Когда компилятор подставит число12 на
место указателя формата, мы увидим следующую фразу:
Мне исполнилось 12 лет
В этом примере функции передается одновременно и строковый литерал, и
числовое значение.
В данном случае тот же результат можно получить, передавая всю фразу целиком,
как параметр, одной из функций:
printf("Мне исполнилось 12 лет");