Структура программы на си. понятие о функциях
Программа на языке Си представляет собой набор последовательно описанных функций (процедуры и подпрограммы в языке Си считаются частным случаем функций). Каждая функция - самостоятельная единица программы, предназначенная для решения определенной задачи (или подзадачи). При описании она имеет следующий вид:
Тип_функцни Имя (<список аргументов>)
<описания аргументов>
{
<описания>
<операторы>
}
Отметим, что список аргументов может быть пустым (однако, скобки после имени функции сохраняются). В этом случае, естественно, нет и их описаний.
Имеется одна главная функция (с именем main), с которой начинается выполнение программы. Функции могут обращаться к другим функциям посредством конструкций вызова. Вызов функции используется при вычислении значения выражения. В результате вызова функция возвращает вычисленное значение, которое и является значением вызова функции. Попутно функция может преобразовывать значения своих аргументов. Такой результат вызова функции называется побочным эффектом.
В модуле, вызывающем данную функцию, тип возвращаемого ею значения должен быть описан (даже если это неопределенное значение) вместе с описанием переменных.
Пример. Пусть необходимо вывести на экран словосочетание «Простая функция без аргументов» 15 раз, используя функции.
Программа 97
#include<stdio.h>
main ()
(
int i,print() ;
for (i=l;i<=15;i++) print();
{
print() /* вызываемая функция без аргументов */
)
printf ("Простая функция без аргументов\n»);
}
Аргументы передаются по значению путем копирования в соответствующие (по порядку) параметры, указанные в определении функции. Соответствие аргументов и параметров по количеств) и типу не контролируется в языке Си. Такой контроль может быть выполнен с помощью дополнительных средств отладки.
Следует различать формальные аргументы, используемые при описании функций, и фактические, задаваемые при вызове функций. Формальный аргумент - переменная в вызываемой программе, а фактический аргумент - конкретное значение, присвоенное этой переменной вызывающей программой. Фактический аргумент может быть константой, переменной или даже более сложным выражением. Независимо от типа фактического аргумента он вначале вычисляется, а затем его величина (в данном случае некоторое целое число) передается функции (см. программу 97). Можно задавать список аргументов, разделенных запятыми. Пример: программа 98, которая находит числа х, у, z, принадлежащие отрезку [1;20] и удовлетворяющие условию x^2 = у^2 + z^2.
Программа 98
#include<stdio.h>
main()
(
int х, у, z, zero() ;
char p, q, ch() ;
x=2; y=45; z=0;
q=’o’;
printf("х» "); zero(x);
printf("x+y+(x+y)^z= "); zero(x+y+(x+y)^z) ;
printf("q= "); ch(q);
}
int zero(u)
int u;
(
printf("%d\n",u);
)
char ch(u)
char u;
{
printf("%c\n",u);
)
Результат работы программы:
x=2
x+y+(x+y)^z= 94
q=0
Программа 99
#include<stdio.h>
main()
(
int x,y,z;
int zero();
printf("Следующие величины могут быть сторонами прямоугольного треугольника:\n");
for (х=1;х<=20;х++)
for (у=1;у<=20;у++)
for (z=l;z<=20;z++)
if (y*y+z*z==x*x)
zero(x,у,z);
}
int zero(f,g,h)
int f,g,h;
(
printf ("x= %d, y= %d, 2=%d\n",f,g,h);
)
Результат работы программы:
следующие величины могут быть сторонами прямоугольного треугольника
х= 5, у= 3, z= 4
х= 5, у= 4, z= 3 x= 10, y= 6, z= 8
x= 10, y=8, z=6 x= 13, y=5, z= 12
x= 13, y= 12, z= 5 x= 15, y= 9, z= 12
x= 15, y= 12, z=9 x=17, y=8, z=15 x= 17, y= 15,
z=8 x=20, y=12, z=16
x=20, y= 16, z= 12
Завершает выполнение данной функции и передает управление вызывающей функции оператор return; в главной функции main он же вызывает завершение выполнения всей программы. Оператор return может содержать любое выражение:
return (<выражение>);
Если выражение не пусто, то вычисляется его значение, которое и становится значением данного вызова функции.
Достижение «конца» функции (правой закрывающей фигурной скобки) эквивалентно выполнению оператора return без возвращаемого значения (т.е. оператор return в конце функции может быть опущен).
Пример. Данная программа вычисляет факториал, если число меньше 8; если вводимое число больше или равно 8, то выводится сообщение «Очень большое число».
Программа 100
#include<stdio.h>
main()
{
int n, s() ;
printf("Введите число ");
scant("%d", &n) ;
if (n<8) printf(=%d", s(n)) ;
else printf("Очень большое число");
)
int s(x) /* определение функции с параметром */
int x;
{
int y,p=l;
for (y=x; y>0; y- ) p*=y;
return(p); /* Возвращает в основную программу значение р */
}
Результат работы программы:
1. Введите число 4
р=24
2.Введите число 9
Очень большое число
Пример: предположим, что нужно вычислить x2 (для некоторого неотрицательного целого у) (очевидный способ реализации возведения в целочисленную степень -многократное умножение, но существует более эффективный алгоритм, приведенный ниже).
Программа 101
#include<stdio.h>
main()
(
int а, Ь, x, у, z;
int odd() ;
printf("\nВведите x, у через пробел: ");
scanf("%d %d", &х, &у); а=х; Ь=у; z=l;
while (b!=0)
if (odd(b))
{ z=z*a; b- -;}
else
( a=a*a; b=b/2;}
printf("\n%d", z);
}
int odd(t)
int t;
(
return((t%2==0)? 0:1);
)
Результат работы программы:
Введитеx, у через пробел: 15 2
Если функции необходимо вернуть несколько значений, можно использовать два различных приема:
• применить глобальные переменные (в этом случае кроме изученных ранее характеристик переменных (имени, типа, значения), используется еще одна – класс памяти, см.ниже);
• применить переменные типа «указатель» в качестве аргументов функции. При вызове функции информация о переменной может передаваться функции в двух видах. Если мы используем форму обращения
function 1(х);
то происходит передача в функцию значения переменной х. Изменение этого значения в вызывающую функцию не возвращается. Если мы используем форму обращения
function2(&x);
то происходит передача адреса переменной х. Теперь измененное значение переменной х может использоваться в вызывающей функции. Первая форма обращения требует, чтобы определение функции включало в себя формальный аргумент того же типа,что и х:
function l(num)
int num;
Вторая форма обращения требует, чтобы определение функции включало в себя формальный аргумент, являющийся указателем на один из объектов соответствующеготипа:
function2(x)
int *x;
Обычно пользуются первой формой, если входное значение необходимо функции для некоторых вычислений или действий, и второй формой, если функция должна будет изменять значения переменных в вызывающей программе. Выше вторая форма вызова \же применялась при обращении к ф\нкции scanf(). Когда мы хотим ввести некоторое значение в переменную num, мы пишем scanf(''%d",&num). Данная функция читает значение, затем, используя адрес, который ей дается, помещает это значение в память.
Пример: пусть необходимо поменять местами заданные значения переменных х и у.
Программа 102
#include<stdio.h>
main()
{
int х, у;
int interchange(); /* описание функции типа int */
x=l; y=3;
printf("Имели... x=l y=3\n") ;
interchange(&x, &y); /* обращение к функции (в данном случае передаются адреса переменных) */
printf("Получили... x=%d y=%d", х, у);
}
/* вызываемая функция */
int interchange(u, v)
int *u, *v;
(
int p;
p=*\i; *u=*v; *v=p;
}
Результат работы программы:
Имели х=1 у=3
Получили х=3у=1
В этой программе в вызове функции interchange(&x,&y) вместо передачи значений х и у мы передаем их адреса. Это означает, что формальные аргументы и и v, имеющиеся в спецификации interchanage(u,v), при обращении будут заменены адресами и, следовательно, они должны быть описаны как указатели.
Поскольку х и у целого типа, u и v являются указателями на переменные целого типа, и мы вводим следующее описание:
int *u,*v; int p;
Оператор описания используется с целью резервирования памяти. Мы хотим поместить значение переменной х в переменную р, поэтому пишем: р=*u; Вспомните, что значение переменной u - это &х, поэтому переменная и ссылается на х. Это означает, что операция *u дает значение х, которое как раз нам и требуется. Мы не должны писать, например, так:
р = u; /* неправильно */
поскольку при этом происходит запоминание адреса переменнойх, а не ее значения.Аналогично, оператор *u = *v соответствует оператору х = у.
Тип функции определяется типом возвращаемого ею значения, а не типом ее аргументов. Если указание типа отсутствует, то по умолчанию считается, что функция имеет тип int. Если значения функции не принадлежат типу int, то необходимо указать ее тип в двух местах.
1. Описать тип функции в ее определении:
char pun(ch,n) /* функция возвращает символ */
int n;
char ch;
2. Описать тип функции также в вызывающей программе. Описание функции должно быть проведено наряду с описаниями переменных программы; необходимо только указать скобки (но не аргументы) для идентификации данного объекта как функции.
main()
{
char rch,pun();
КЛАССЫ ПАМЯТИ
Помимо изученных ранее характеристик переменных (имени, типа, значения), в ряде случаев оказывается важной еще одна - класс памяти. Класс памяти характеризует время существования и место хранения объекта в программе.
Для обозначения класса памяти в языке Си используются следующие служебные слова:
auto extern
register static
Автоматические объекты (auto) являются локальными по отношению к блоку и хранятся внутри того блока, где они описаны. Автоматические переменные можно инициализировать произвольными выражениями, включающими константы и ранее описанные переменные и функции.
Автоматические объекты существуют только во время выполнения данного блока и теряют свои значения при выходе из него. При каждом вхождении в блок им присваиваются начальные значения, заданные в описании. Если начальные значения не заданы, то значения автоматических объектов при входе в блок не определены. До сих пор в этом параграфе рассматривались именно автоматические объекты.
Объекты, описанные внутри блока с классом памяти register, называются регистровыми переменными. Они подчиняются всем правилам, касающимся автоматических переменных. Описание register указывает компилятору, что данная переменная будет часто использоваться. Когда это возможно, переменные, описанные как register, располагаются в машинных регистрах. Это приводит к меньшим по размерам и более быстрым программам.
Объекты, описанные внутри функции с добавлением класса памяти extern или описанные вне функции без оказания класса памяти, относятся к внешним объектам. Внешние объекты хранятся вне любой функции, входящей в состав программы, и существуют в течение выполнения всей программы. Они могут быть использованы для передачи значений между различными, в том числе и отдельно компилируемыми, функциями. Сами функции также являются внешними объектами, поскольку правила языка Си не позволяют определять одни функции внутри других. Внешние переменные можно инициализировать только выражениями с константами и указателями на ранее описанные объекты. По умолчанию (если не задана инициализация) внешние объекты получают нулевые начальные значения.
Внешние объекты делятся на внешние глобальные и внешние статические.
Важно различать описание внешнего объекта и его определение. Описание указывает свойства объекта (тип, размеры и т.д.); определение же вызывает еще и отведение памяти установке начального значения, если используется инициализация.
Например, появившиеся вне определения какой-либо функции строчки
int max;
char save[maxline];
определяют внешние переменные max и save, вызывают отведение для них места в памяти и служат в качестве описания для остальной части этого файла. В тожевремя строчки
extern int max;
extern char save[];
описывают в остальной части данного блока переменную max как int, a save как массив типа char (размеры которого указаны в другом месте), но не создают переменных и не отводят для них места в памяти.
Во всех блоках, составляющих исходную программу, должно содержаться только одно определение внешней переменной; другие блоки могут содержать описания extern для доступа к ней.
Программа 103
#include<stdio.h>
int i=0;
/* Класс памяти переменной - внешний. Область действия переменной -любая программа, */
/* загружающаяся с данным файлом. Время существования i=0 - все время выполнения программы. */
main() /* Блок уровня 1. */
(
auto int i=l;
/* В блоке 1 область действия i=l - функция main(). Время */
/* существования i=l - все время выполнения главной функции /*
/* main(). /*
printf("%d\n", i) ;
/* Если две переменные имеют одно и то же имя, то по этому */
/* имени обращаются к внутренней переменной, внешняя */
/* непосредственно недоступна, поэтому после выполнения */
/* блока 1 программа напечатает i=l. */
{ /* Блок уровня 2. */
int i=2;
/* Класс памяти переменной i=2 - auto. Область */
/* действия i=2 - блок 2, время существования - время */
/* существования блока 2. блок 2, время существования -*/
/* время существования блока 2. */
printf("%d\n", i) ;
/* Программа напечатает i=2. */
{ /* Блок уровня 3. */
i+=l; printf("%d\n", i);
/* Печатается самая внутренняя переменная с именем i,/*
/* которая после выполнения операции данного блока */
/* становится равной 3. */
}
/* Возвращение к блоку уровня 2. */
printf("%d\n", i) ;
/* Опять печатается i=3. */
)
/* Возвращение к блоку уровня 1. */
printf("%d", i) ;
/* Переменная i=3 исчезает. Теперь самой внутренней переменной */
/* с именем i будет i=l. */
)
Программа 104
#include<stdio.h>
int a;
main()
(
extern int a;
int P ();
a=6; P();
)
int P()
(
extern int a;
printf("a=%d",a);
}
Результат работы программы:
a=6
Областью действия статического внешнего объекта является модуль, в котором описан данный объект. При этом где-либо во внешних описаниях (т.е. вне определения функций) должно быть расположено определение внешнего статического объекта в виде
static <Спецификация типа> <Спецификация данных>;
На основании определения под объект отводится память и может быть произведена инициализация. Статические переменные можно инициализировать только выражениями с константами и с указателями на ранее описанные объекты.
При первом входе в соответствующую локальную область (блок или модуль) статические переменные инициализируются один раз (по умолчанию - нулем). При последующих входах в данную область статические переменные получают те значения, которые они имели при последнем выходе из области.
По умолчанию все функции данного модуля, расположенныениже определениястатического объекта, включаются в его область действия - в них не обязательно дополнительно описывать объект для получения к нему доступа. Функции, определения которых расположены в модуле выше определения внешнего статического объекта, для пол\чения доступа к нему должны содержать описание этого объекта с классом памяти extern.
Константы являются объектами статического класса памяти.
Функция может быть определена как статический внешний объект. В этом случае она будет доступной в любой точке данного мод\ля и не доступной за пределами модуля.
Программа 105
#include<stdio.h>
main()
(
int count;
int trystat () ;
for (count=l; count<=3; count++)
(
printf ("Итерация %d:\n", count);
trystat() ;
}
)
trystat ()
{
int fade=l;
static int stay=l;
printf("fade = %d и stay = %d\n", fade++, stay++) ;
}
Результат работы программы:
Итерация 1:
fade = 1 и stay = 1
Итерация 2:
fade = 1 и stay = 2
Итерация 3:
fade = 1 и stay = 3
Если мы лишь немного видоизменим в программе функцию trystat()
trystat()
{
int fade=l;
int stay=l;
printf("fade = %d и stay = %d\n", fade++, stay++);
}
то получим следующий результат:
Итерация 1:
fade = 1 и stay = 1
Итерация 2:
fade = 1 и stay = 1
Итерация 3:
fade = 1 и stay = 1
ФУНКЦИИ ВВОДA-ВЫВОДА
Средства ввода-вывода не являются составной частью языка Си. Имеется ряд библиотечных функций Си. обеспечивающих стандартною систему ввода-вывода для программ на Си. Макроопределения, описания переменных и определения этих функций содержатся в файле стандартных заголовков stdio h Поэтому, как указывалось выше, каждая пользовательская программа должна содержать в начале ссылку
#include <stdio.h>.
В примерах программ мы неоднократно использовали форматные функции ввода (scanf()) и вывода (printf()). Набор стандартных функций ввода и вывода значительно шире и включает большое число функций для работы с данными различного типа, различными устройствами, буферизованного и небуферизованного, форматного и бесформатного ввода и вывода.
Система ввода-вывода Си обеспечивает некоторый уровень абстракции между программистом и используемым устройством. Эта абстракция называется потоком, а фактическое устройство ввода-вывода называется файлом. Буферизованная файловая система преобразует каждое физическое устройство в логическое устройство,называемое потоком. Существуют потоки двух типов: текстовые и двоичные.
Текстовый поток - это последовательность символов, которая организуется в строки, завершающиеся символами новой строки. Обработка текстового потока предполагает преобразование данных из текстового (внешнего) представления в машинное (внутреннее) или наоборот. При обработке двоичного потока последовательность его байтов взаимно однозначно соответствует байтам во внешнем устройстве.
В языке программирования Си файл - это логическое понятие, которое система может относить к чему угодно (от дисковых файлов до терминалов). Поток связывается с конкретным файлом выполнением операции «открыть» Как только файл открывается, можно обмениваться информацией между ним и программой. Закрытие выводимого потока заставляет ЭВМ записывать содержимое этого потока на внешнее устройство Этот процесс обычно называется промыванием потока. В начале выполнения программы ЭВМ открывает три предопределенных текстовых потока stdin, stdout и stderr, связанных со стандартными устройствами ввода-вывода (консоль - клавиатура и дисплей). Допускается переадресация ввода-вывода к другим устройствам.
Простейшими функциями консольного ввода-вывод являются функцияgetche(),которая читает символ с клавиатуры, и функция putchar(), которая печатает символ на экране. Функция getche() ждет, пока не будет нажата клавиша, а затем возвращает ее значение, автоматически выдавая на экран «эхо» нажимаемой клавиши. Функция putchar() записывает ее символьный аргумент на экран в текущуюпозицию курсора.
Ниже приводится пример простой программы, которая принимает один символ с клавиатуры и выводит его на экран.
Программа 106
#include<stdio.h>
main()
(
char ch;
ch = getchar() ;
putchar(ch);
)
Есть две важные версии функции getche(). Первая – getchar()- буферирует ввод до тех пор, пока не введен возврат каретки. Второй версией является функция getch(), которая работает точно так же, как getchar(), за исключением того, что getch() не возвращает на экран эхо введенного символа.
Функции gets() и puts() позволяют читать и писать цепочки символов (строки) с консоли. Функция gets() читает цепочку символов, которая вводится с клавиатуры (ввод оканчивается возвратом каретки), помещает ее с адреса, который указывает ее аргумент - указатель символа. Функция puts() выводит на экран ее аргумент - цепочку символов, а затем символ новой строки. Например, нижеследующая программа читает цепочку в массив str и тут же печатает ее.
Программа 107
main ()
(
char str[80] ;
gets (str) ;
puts(str) ;
)
Функция puts() занимает меньше памяти и работает быстрее, чем printf() при выводе символьных цепочек, поэтому программисты часто используют функцию puts() в тех случаях, когда важно иметь высоко минимизированныйкод.
Таблица 3.4