Язык Си - Уэйт, Прата, Мартин. M. уэит с. Прата д. Мартин
 Скачать 4.69 Mb.
|
|
*) определяет саму переменную как указатель. Описание вида int *pi; говорит, что pi - это указатель и что *pi - величина типа int. РИС. 9.5. Описание и использование указателей. Точно так же величина (*рс), на которую ссылается переменна рс, имеет тип char. Что можно сказать о самой переменной рс? Мы считаем, что она имеет тип "указатель на переменную типа char". Ее величина, являющаяся адресом,- это целое число без знака, поэтому при выводе на печать значения переменной рс мы будем пользоваться форматом %u. Использование указателей для связи между функциями Далее Содержание Мы только прикоснулись к обширному и увлекательному миру указателей. Сейчас нашей целью 190 является использование указателей для решения задачи об установлении связи между функциями. Ниже приводится программа, в которой указатели служат средством, обеспечивающим правильную работу функции, которая осуществляет обмен значениями переменных. Посмотрим, как она выглядит, выполним ее, а затем попытаемся понять, как она работает. /* обмен3 */ main( ) { int x = 5, у = 10; printf(" Вначале x = %d и у = %d.\n" , x, у); interchange(&x,&y); /* передача адресов функции */ printf(" Теперь x = %d и у = %d.\n", x, у); } interchange(u, v) int *u, *v; /* u и v являются указателями */ { int temp; temp = *u; /* temp присваивается значение, на которое указывает u */ *u = *v; *v = temp; } После всех встретившихся трудностей, проверим, работает ли этот вариант 1 Вначале x = 5 и y = 10. Теперь x = 10 и y = 5. Да программа работает. Посмотрим, как она работает. Во-первых, теперь вызов функции выглядит следующим образом: interchange(&x, &y); Вместо передачи значений х и у мы передаем их адреса. Это означает, что формальные аргументы u и v, имеющиеся в спецификации: interchange(u,v) при обращении будут заменены адресами и, следовательно, они должны быть описаны как указатели. Поскольку х и у - целого типа, u и v являются указателями на переменные целого типа, и мы вводим следующее описание: int *u, *v; Дале в теле функции оператор описания: int temp; используется с целью резервирования памяти. Мы хотим поместить значение переменной х в переменную temp, поэтому пишем: temp = *u; Вспомните, что значение переменной u - это &х, поэтому переменная u ссылается на х. Это означает, что операция *u дает значение x, которое как раз нам и требуется. Мы не должны писать, например, так: temp = u; /* неправильно */ поскольку при этом происходит запоминание адреса переменной х, а не ее значения; мы же пытаемся осуществить обмен значениями, а не адресами. 191 Точно так же, желая присвоить переменной у значение переменной х, мы пользуемся оператором: *u = *v; который соответствует оператору x = y; Подведем итоги. Нам требовалась функция, которая могла бы изменять значения переменных х и у. Путем передачи функции адресов переменных х и у мы предоставили ей возможность доступа к ним. Используя указатели и операцию *, функция смогла извлечь величины, помещенные в соответствующие ячейки памяти, и поменять их местами. Вообще говоря, при вызове функции информация о переменной может передаваться функции в двух видах. Если мы используем форму обращения: function1(х); происходит передача значения переменной х. Если же мы используем форму обращения: function2(&x); происходит передача адреса переменной х. Первая форма обращения требует, чтобы определение функции включало в себя формальный аргумент того же типа, что и х: functionl(num) int num; Вторая форма обращения требует, чтобы определение функции включало в себя формальный аргумент, являющийся указателем на объект соответствующего типа: function2(ptr) int *ptr; Пользуйтесь первой формой, если входное значение необходимо функции для некоторых вычислений или действий, и второй формой, если функция должна будет изменять значения переменных в вызывающей программе. Вторая форма вызова уже применялась при обращении к функции scanf( ). Когда мы хотим ввести некоторое значение в переменную num, мы пишем scanf("%d, &num). Данная функция читает величину, затем, используя адрес, который ей дается, помещает эту величину в память. Указатели позволяют обойти тот факт, что переменные функции interchange( ) являются локальными. Они дают возможность нашей функции "добраться" до функции main( ) и изменить величи ны описанных в ней объектов. Программисты, работающие на языке Паскаль, могут заметить, что первая форма вызова аналогична обращению с параметром-значением, а вторая - с параметром-переменной. У программистов, пишущих на языке Бейсик, понимание всей этой методики может вызвать некоторые затруднения. В этом случае если материал данного раздела покажется вам поначалу весьма не обычным, не сомневайтесь, что благодаря некоторой практике, все обсуждаемые средства станут простыми, естественными и удобными. Переменные: имена, адреса и значения Наше обсуждение указателей строится на рассмотрении связей между именами, aдреcaми и значениями переменных; дальше мы продолжим обсуждение этих вопросов. 192 При написании программы мы представляем себе переменную как объект, имеющий два атрибута: имя и значение. (Кроме указанных существуют еще и другие атрибуты, например тип, но это уже другой вопрос.) После компиляции программы и загрузки в память "с точки зрения машины" данная переменная имеет тоже два атрибута: адрес и значение. Адрес - это машинный вариант имени. Во многих языках программирования адрес объекта скрыт от программиста и считается относящимся к уровню машины. В языке Си благодаря операции & мы имеем возможность узнать и использовать адрес переменной: &bаrn - это адрес переменной bаrn. Мы можем получить значение переменной, соответствующее данному имени, используя только само имя: printf(" %d\n", barn) печатает значение переменной barn Мы можем также получить значение переменной, исходя из ее адреса, при помощи операции *: РИС. 9.6. Имена, адреса и величнны в системе с "байтовой адресацией" тина IBM PC. Дано pbarn = &bаrn; тогда *pbarn - это величина, помещенная по адресу &bаrn. Хотя мы и можем напечатать адрес переменной для удовлетворения своего любопытства, это не основное применение операции &. Более важным является то, что наличие операций &, * и указателей позволяет обрабатывать адреса и их содержимое в символическом виде, чем мы и занимались в программе обмен3. ИСПОЛЬЗОВАНИЕ НАШИХ ЗНАНИЙ О ФУНКЦИЯХ Далее Содержание Теперь, когда мы знаем о функциях немного больше, соберем вместе несколько поучительных примеров, но сначала решим, чем мы будет заниматься. Что вы скажете насчет функции возведения в степень, которая дает возможность возводить 2 в 5-ю степень или 3 в 3-ю и т. д.? Во-первых, необходимо решить, что будет служить входом программы. Это понятно: Cи требуется знать число, возводимое в степень, и показатель степени. Достичь этого можно путем введения двух аргументов: powеr(base, exp) int base, exp; (Мы ограничились здесь целыми числами, а также тем предположением, что результат будет 193 сравнительно невелик.) Далее требуется решить, что будет выходом функции. Ответ, конечно, тоже очевиден. Выходом должно быть одно число, являющееся значением переменной answer. Мы можем реализовать это с помощью оператора rеturn(answcr); Теперь для получения требуемого результата выберем алгоритм: установим переменную answer равной 1, умножим answer на base столько раз, сколько указывает exp. Возможно, не совсем ясно, как осуществить второй шаг, поэтому разобьем его дальше на более мелкие шаги: умножим answer на base и уменьшим на 1, остановимся, когда exp станет равной 0. Если значение exp равно, скажем 3, тогда использование такого алгоритма приведет к трем умножениям; поэтому данный способ кажется вполне разумным. Очень хорошо. Выразим теперь этот алгоритм в виде программы на языке Си. /* возводит основание в степень */ power(base, exp) int base, exp; { int answer; for (answer = 1; exp > 0; exp--) answer = answer* base; return(answer); } Теперь проверим ее работу с помощью драйвера. /* проверка возведения в степень */ main( ) { int x; х = power(2,3); printf(" %d\n", x); x = power(-3,3); prinif(" %d\n", x); x = power(4, -2); printf(" %d\n", x); x = power(5, 10); printf(" %d\n", x); } Объединим указанные две функции, проведем компиляцию и выполним данную программу. Результаты оказываются следующими: 8 -27 1 761 Итак, 2 в 3-й степени - это 8, а - 3 в 3-й равно -27. Пока все правильно. Но 4 в степени -2 равно 1/16, а не 1. А 5 в 10-й степени, если память нам не изменяет,- это 9 765 625. В чем дело? Во-первых, программа не предназначалась для обработки отрицательных степеней, поэтому она и не смогла справиться с этой задачей. Во-вторых, в нашей системе величины типа int не могут превосходить 65 535. Можно расширить программу путем включения в нее обработки отрицательных степеней и использования чисел с плавающей точкой для представления переменных base и answer. В любом случае показатель степени должен выражаться целым числом, потому что это число выполняемых 194 умножений; нельзя произвести 2,31 умножения. /* возводит основание в степень*/ double powеr(base, еxp) double, base; int exp; { double answer; if(exp > 0) { for(answer = 1.0; exp > 0; exp --) answer * = base; return(answer); } else if(base != 0) { for(answer = 1.0; exp < 0; exp++ ) answer /= base; return(answer); } else /* base = 0 и еxp <= 0 */ { printf(" Нельзя возводить 0 в %d стeпень!\n", exp); return(0); } } Необходимо отметить здесь несколько моментов. Первый: самым главным является то, что мы должны описать тип функции! Переменная answer имеет тип double, следовательно, сама функция power() тоже должна быть типа double, так как ей присваивается величина, возвращаемая оператором return. Почему, спросите вы, мы не описывали тип функции раньше? Дело в том, что по умолчанию в языке Си функция имеет тип int (для большинства функций это так), если не указано что-то иное. Второй: мы хотели показать, что не забыли те новые операции присваивания, которые ввели в гл. 8. Третий: в соответствии с алгебраическими правилами возведение в отрицательную степень было преобразовано в деление. Это внесло опасность деления на нуль, но в данном случае мы предусмотрели выдачу сообщения об ошибке и возврат значения 0, чтобы работа программы не прекращалась. Мы можем воспользоваться тем же драйвером при условии, что тип функции power( ) там тоже описан. /* проверка возведения в степень */ main( ) { double x; double power( ); /* это пример oписания функции */ x = power(2.0, 3); printf(" %.0f \n", x); x = power(-3.0, 3); printf(" %.0f\n" , x); x = power(4.0, -2); printf(" %.4f\n", x); x = power(5.0, 10); print f ("%.0f \n", x); } На этот раз результаты работы программы выглядят вполне удовлетворительно. 8 -27 0.0625 9765625 Данный пример побуждает нас ввести следующий короткий раздел. ОПИСАНИЕ ТИПОВ ФУНКЦИЙ Далее Содержание 195 Тип функции определяется типом возвращаемого ею значения, а не типом ее аргументов. Если указание типа отсутствует, то по умолчанию считается, что функция имеет тип int. Если значения функции не принадлежат типу int, то необходимо указать ее тип в двух местах. 1. Описать тип функции в ее определении: char pun(ch, n) /* функция возвращает символ */ int n; char ch; float raft(num) /* функция возвращает величину типа float */ int num; 2. Описать тип функции также в вызывающей программе. Описание функции должно быть приведено наряду с описаниями переменных программы; необходимо только указать скобки (но не аргументы) для идентификации данного объекта как функции. main( ) { char rch, pun( ); float raft; } Запомните! Если функция возвращает величину не типа int, указывайте тип функции там, где она определяется, и там, где она используется. Резюме: функции 1. Форма записи Типичное определение функции имеет следующий вид: имя (список аргументов) описание аргументов тело функции Наличие списка аргументов и описаний не является обязательным. Переменные, отличные от аргументов, описываются внутри тела, которое заключается в фигурные скобки. Пример: diff(x, у) /* имя функции и список аргументов */ ini x, у; /* описание аргументов */ { /* начало тела функции */ int z; /* описание локальной переменной */ z = х - у; return(z); } /* конец тела функции */ II. Передача значений функции: Аргументы используются для передачи значений из вызывающей программы и функцию. Если значения переменных а и b будут 5 и 2, то при вызове с = diff(а,b); осуществляется передача этих значений переменным х и у. Значения 5 и 2 называют ся фактическими аргументами, а переменные х и у, указанные в описании функции: diff( ) - формальными аргументами. Использование ключевого слова return позволяет передавать в вызывающую программу одно значение из вызываемой функции. В нашем примере переменной с присваивается значение переменной z, равное 3. 196 Обычно выполнение функции не оказывает никакого влияния на значения переменных вызывающей программы. Чтобы иметь возможность непосредственно изменять значения переменных вызывающей программы, необходимо использовать указатели в качестве аргументов. Это может оказаться необходимым в случае, если в вызывающую программу требуется передать более чем одно значение. III. Тип функции Функции должны иметь тот же тип, что и значения, которые они возвращают в качестве результатов. По умолчанию предполагается, что функции имеют тип int. Если функция имеет другой тип, он должен быть указан и в вызывающей программе, и в самом определении функции. Пример main( ) { float q, x, duff( ); /* описание в вызывающей программе */ int n; q = duff(х, n); } float duff(u, k); /* описание в определении функции */ float u; int k; { float tor; return(tor); /* возвращает значение типа float */ } В ЯЗЫКЕ СИ ВСЕ ФУНКЦИИ РАВНОПРАВНЫ Далее Содержание Все функции в программе, написанной на языке Си, равноправны: каждая из них может вызывать любую другую функцию и в свою очередь каждая может быть вызвана любой другой функцией. Это делает функции языка Си несколько отличными от процедур Паскаля, поскольку процедуры в Паскале могут быть вложены в другие процедуры (причем, процедуры, содержащиеся в одном гнезде, являются недоступными для процедур, расположенных в другом). Нет ли у функции main( ) какой-то специфики? Безусловно, есть; она заключается в том, что после "сборки" программы, состоящей из нескольких функций, ее выполнение начинается с первого оператора функции main( ). Но этим ее исключительность и граничивается. Даже функция main( ) может быть вызвана другими функциями, как показывает приведенный ниже пример: /* вызов функции main( ) */ #include main( ) { char ch; printf (" Укажите произвольный символ. Q - признак конца работы. \n"); ch = getchar( ); printf ("Так! Вы указали %с!\n", ch); if(ch != 'Q') more( ); } more( ); { main( ); } Функция main( ) вызывает more(), а функция more() вызывает main()! После вызова функции main( ) ее выполнение начинается с самого начала; мы организовали цикл с взаимным вызовом. 197 Функция может даже вызывать сама себя. Упростим предыдущий пример следующим образом: /* main.main */ #include main( ) { char ch; printf (" Укажите произвольный символ. Q - признак конца работы.\n"); ch = getchar( ); printf ("Так! Вы указали %с!\n", ch); if(ch != 'Q') main( ); } Ниже приводятся результаты одного прогона программы, показывающие, что она работает. Обратите внимание на то, как обрабатывается символ "новая строка", который передается программе при нажатии клавиши [ввод]. Введите произвольный символ. Q - признак конца работы. I Так! Вы указали I ! Введите произвольный символ. Q - признак конца работы. ! Так! Вы указали ! ! Введите произвольный символ. Q - признак конца работы. Q Так! Вы указали Q ! Действие, состоящее в том, что функция вызывает сама себя, называется "рекурсией". Цикл, который мы создали, используя рекурсию, отличается от циклов while и do while. Когда функция main( ) вызывает сама себя, не происходит передачи управления на ее начало. Вместо этого в памяти машины создаются копни всего набора переменных функции main( ). Если вы выведете на печать адреса переменных в обычном цикле, то увидите, что эти адреса не изменяются от итерации к итерации. Что же касается рассматриваемого здесь цикла, то в нем адрес используемой переменной меняется, поскольку при каждом выполнении тела цикла создается новая копия переменной ch. Если программа циклически выполняется 20 раз, то будет создано 20 различных копий переменной, каждая из которых носит имя ch, но имеет свой собственный адрес. Компиляция программ, состоящих из двух или более функций Простейший способ использования нескольких функций в одной программе заключается в том, чтобы поместить их в один файл, после чего осуществить компиляцию программы, содержащейся в этом файле так, как будто она состояла из одной функции. Второй способ заключается и применении директивы |