10. Классы памяти и разработка программ

ЛОКАЛЬНЫЕ И ГЛОБАЛЬНЫЕ ПЕРЕМЕННЫЕ
КЛАССЫ ПАМЯТИ
ФУНКЦИЯ ПОЛУЧЕНИЯ СЛУЧАЙНЫХ ЧИСЕЛ
ПРОВЕРКА ОШИБОК
МОДУЛЬНОЕ ПРОГРАММИРОВАНИЕ
СОРТИРОВКА

КЛЮЧЕВЫЕ СЛОВА
auto, extern, static, register

     Одно из достоинств языка Си состоит в том, что он позволяет управлять ключевыми механизмами программы. Классы памяти языка Си - пример такого управления; они дают возможность определить, с какими функциями связаны какие переменные и как долго переменная сохраняется в программе. Классы памяти - первая тема данной главы.

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

КЛАССЫ ПАМЯТИ И ОБЛАСТЬ ДЕЙСТВИЯ

Далее   Содержание

     Мы уже упоминали раньше, что локальные переменные известны только функциям, содержащим их. В языке Си предполагается также, что о глобальных переменных "знают" сразу несколько функций. Предположим, например, что и main( ), и critic( ) имеют доступ к переменной units. Это будет иметь место, если отнести units к "внешнему" классу памяти, как показано ниже:

/* глобальная переменная units */
int units;  /* внешняя переменная */
main( )
{
extern int units;
printf (" Сколько фунтов масла находится в бочонке?\n");
scanf (" %d" , &units);
while (units != 56) critic( );
printf(" Вы должны поискать в справочнике !\n");
} critic( )
{
extern int units;
printf (" He повезло, дружок. Попытайся снова.\n");
scanf (" %d" , &units);
}

Сколько фунтов масла находится в бочонке?
14
Не повезло, дружок. Попытайся снова.
56
Вы должны поискать в справочнике!

Обратите внимание, что второе значение units было прочитано функцией critic( ), однако main() также "узнала" это новое значение, когда оно вышло из цикла while.

     Мы сделали переменную units внешней, описав ее вне любого определения функции. Далее, внутри функций, использующих эту переменную, мы объявляем ее внешней при помощи ключевого слова extern, предшествующего спецификации типа переменной. Слово extern предлагает компьютеру искать определение этой переменной вне функции. Если бы мы опустили ключевое слово extern в функции critic( ), то компилятор создал бы в функции critic новую переменную и тоже назвал бы ее units. Тогда другая переменная units() [которая находится в main()] никогда не получила бы нового значения.

     Каждая переменная, как мы знаем, имеет тип. Кроме того, каждая переменная принадлежит к некоторому классу памяти. Есть четыре ключевых слова, используемые для описания классов памяти: extern (для внешнего), auto (для автоматического), static и register. До сих пор мы не обращали внимание на классы памяти, так как переменные, описанные внутри функции, считались относящимися к классу auto, если они не описывались иначе (по умолчанию они относились к классу auto).

     Определение класса памяти переменной зависит oт того, гд переменная описана и какое ключевое слово (если оно есть) используется.

     Класс памяти позволяет установить два факта. Во-первых, определить, какие функции имеют доступ к переменной. (Пределы, до которых переменная доступна, характеризуют ее "область действия".) Во-вторых, определить, как долго переменная находится в памяти. Теперь перейдем к свойствам каждого типа.

Автоматические переменные

Далее   Содержание

     По умолчанию переменные, описанные внутри функции, являются автоматическими. Можно, однако, это подчеркнуть явно с помощью ключевого слова auto:

main( )
{
auto int plox;

Так поступают, если хотят, например, показать, что определение переменной не нужно искать вне функции.

     Автоматические переменные имеют локальную область действия. Только функция, в которой переменная определена, "знает" ее. (Конечно, можно использовать аргументы для связи значения и адреса переменной с другой функцией, однако это частичное и косвенное "знание".) Другие функции могут использовать переменные с тем же самым именем, но это должны быть независимые переменные, находящиеся в разных ячейках памяти.

     Автоматическая переменная начинает существовать при вызове функции, содержащей ее. Когда функция завершает свою работу и возвращает управление туда, откуда ее вызвали, автоматическая переменная исчезает. Ячейка памяти может снова использоваться для чего-нибудь другого.

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

Внешние переменные

Далее   Содержание

     Переменная, описанная вне функции, является внешней. Внешнюю переменную можно также описать в функции, которая использует ее, при помощи ключевого слова extern. Описания могут выглядеть примерно так:

int errupt;   /* Три переменные, описанные вне функции */
char coal;
double up;
main( )
{
extern int errupt;	 /* объявлено, что 3 переменные */
extern char coal;	/* являются внешними */
extern double up;

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

     Если слово extern не включено в описание внутри функции, то под этим именем создается новая автоматическая переменная. Вы можете пометить вторую переменную как "автоматическую" с помощью слова auto и тем самым показать, что это ваше намерение, а не оплошность. Три примера демонстрируют четыре возможных комбинация описаний:

/* Пример1 */
int hocus;
main( ) {
extern int hocus;	/*	hocus	описана внешней	*/
...
}
magic( ) {
extern int	hocus;
...
}

/* Пример2 */
int hocus ;
main( )
{
extern int hocus;   /* hocus описана внешней	*/
...
}
magic( )
{
/* hocus не описана совсем */
...
}

Снова есть одна внешняя переменная hocus, известная обеим функциям. На этот раз она известна функции magic( ) по умолчанию.

/* Пример3 */
int hocus;
main( )
{
int hocus;   /* hocus описана и 
        является автоматической по умолчанию */
...
}
magic( )
 {
auto int hocus;	/* hocus описана автоматической */
...
}

В этом примере созданы три разные переменные с одинаковым именем. Переменная hocus в функции main( ) является автоматической по умолчанию и локальной для main( ), в функции magic( ) она явно описана автоматической и известна только для magic( ). Внешняя переменная hocus не известна ни main( ), ни magic( ), но обычно известна любой другой функции в файле, которая не имеет своей собственной локальной переменной hocus.

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

Статические переменные

Далее   Содержание

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

/* статическая переменная */
main( )
{
int count;
for (count = 1; count <= 3; count++)
{
printf(" Итерация %d:\n", count);
trystat( );
}
}
trystat( )
{
int fade = 1;
static int stay;	= 1; 
printf("fade =	%d и stay =	%d\n", fade++, stay++);
}

Заметим, что функция trystat( ) увеличивает каждую переменную после печати ее значения. Работа этой программы даст следующие результаты:

Итерация 1:
fade = 1 и staly = 1
Итерация 2:
fade = 1 и stay = 2
Итерация 3:
fade = 1 и stay = 3

Статическая переменная stay "помнит", что ее значение было увеличено на 1, в то время как для переменной fade начальное значение устанавливается каждый раз заново. Это указывает на разницу в инициализации: fade инициализируется каждый раз, когда вызывается trystat( ), в то время как stay инициализируется только один раэ при компиляции функции trystat( ).

Внешние статические переменные

Далее   Содержание

     Вы можете также описать статические переменные вне любой функции. Это создаст "внешнюю статическую" переменную. Разница между внешней переменной и внешней статической переменной заключается в области их действия. Обычная внешняя переменная может использоваться функциями в любом файле, в то время как внешняя статическая переменная может использоваться только функциями того же самого файла, причем после определения переменной. Вы описываете внешнюю статическую переменную, располагая ее определение вне любой функции.

static randx = 1;
rand( )
{

Немного позже мы приведем пример, в котором будет необходим этот тип переменной.

РИС. 10.1. Внешние и внешние статические переменные.

Регистровые переменные

Далее   Содержание

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

main( )
{
register int quick;

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

Какой класс памяти применять?

Далее   Содержание

     Ответ на вопрос почти всегда один - "автоматический". В конце концов почему этот класс памяти выбран по умолчанию? Мы знаем, что на первый взгляд использование внешних переменных очень соблазнительно. Опишите все ваши переменные как внешние, и у вас никогда не будет забот при использовании аргументов и указателей для связи между функциями в прямом и обратном направлениях. К сожалению, у вас возникнет проблема с функцией С, коварно изменяющей переменные в функции А, а это совсем не входит в паши интересы. Неоспоримый совокупный опыт использова-ния машин, накопленный в течение многих лет, свидетельствует о том, что такая проблема значительно перевешивает кажущуюся привлекательность широкого использования внешних переменных.

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

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


Резюме: Классы памяти

I. Ключевые слова: auto, extern, static, register

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

III. Свойства

КЛАСС ПАМЯТИ	КЛЮЧЕВОЕ СЛОВО	ПРОДОЛЖИТЕЛЬНОСТЬ СУЩЕСТВОВАНИЯ	ОБЛАСТЬ ДЕЙСТВИЯ
Автоматический Регистровый Статический	auto register static	Временно Временно Постоянно	Локальная Локальная Локальная
Внешний Внешний статический	extern static	Постоянно Постоянно	Глобальная (все файлы) Глобальная (один файл)

1. Разделим случайное число на 32768. В результате получим число х в диапазоне - 1 <= х < 1. (Мы должны превратить его в тип float, чтобы иметь десятичные дроби.)
2. Добавим 1. Наше новое число удовлетворяет отношению 0 < = х < 2.
3. Разделим на 2. Теперь имеем 0 <= х < 1.
4. Умножим на 6. Имеем 0 <= х < 6. (Близко к тому, что нужно, но 0 не является возможным значением.)
5. Прибавим 1: 1 <= х < 7. (Заметим, что эти числа все еще являются десятичными дробями.)
6. Преобразуем в целые числа. Теперь мы имеем целые в диапазоне от 1 до 6.
7. Для обобщения достаточно заменить значение 6 в п. 4 на число сторон.
Вот функция, которая выполняет эти действия:

/* электронное бросание костей */
#define SCALE 32768.0
rollem(sides) float sides;
{
float roll;
roll = ((float)rand( )/SCALE + 1.0) * sides/2.0 + 1.0;
return((int)roll);
}

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

/* многократное бросание кости */
main( )
{
int dice, count, roll, seed;
float sides;
printf(" Введите, пожалуйста, значение зерна. \n");
scanf(" %d, &seed);
srand(seed);
printf(" Введите число сторон кости, 0 для завершения. \n");
scanf(" %d", &sides);
while(sides > 0)
{ printf(" Сколько костей?\n");
scanf(" %d", &dice);
for( roll = 0, count = 1; count <= dice;	count++)
roll + = rollem(sides); /* бросание всех костей набора */
printf(" У вас выпало %d, для %d  %.0f-сторонних костей.\n", roll, dice, sides);
printf(" Сколько сторон? Введите 0 для завершения.\n"); 
scanf(" %f", &sides);
} printf(" Удачи вам!\n");
}

Введите значение зерна
1
Введите число сторон  кости,  0 для завершения.
6
Сколько костей?
2
У вас выпало 4 для 2 6-сторонних костей.
Сколько сторон ? Введите  0 для завершения. 
6
Сколько костей ?
2
У вас выпало 7 для 2  6-сторонних костей.
Сколько сторон? Введите  0 для завершения.
0
Удачи Вам!  
Спасибо.

     Вы можете использовать функцию rollem( ) по-разному. Пусть число сторон (sides) равно двум, тогда бросание) монеты даст следующий результат: "орел" выпал 2 раза, a "peшка" - один (или наоборот, смотря, что вы предпочитаете). Можно легко модифицировать программу, чтобы показать как отдельные результаты, так и итог. Или вы можете построить имитатор игры "крапс". Если вам нужно большое число бросаний, вы можете легко модифипировать свою программу и получить результат, подобный следующему:

Введите значение зерна.
10
Введите количество ходов; введите 0 для завершения.
18
Сколько сторон и сколько костей? 6   3
Здесь 18 ходов для 3  6-сторонних костей.
7 5  9 7 12 10 7 12 10 14
9 8 13 9 10 7 16 10
Сколько ходов? Введите 0 для завершения. 0

Использование функции rand( ) [но не rоllem( )] изменило бы вашу программу угадывания чисел: компьютер стал бы выбирать, а вы угадывать, вместо того чтобы сделать наоборот.

     Разработаем еще некоторые функции. Сначала мы хотим создать функцию, которая читает целые числа.

ФУНКЦИЯ ПОЛУЧЕНИЯ ЦЕЛЫХ ЧИСЕЛ: getint( )

Далее   Содержание

     Вероятно, наш проект покажется вам очень простым. В конце концов мы можем использовать функцию scanf( ) с форматом %d, если хотим прочитать целое число. Такой подход очень прост, но он имеет один большой недостаток. Если вы ошибочно напечатали, скажем Т вместо 6, scanf( ) попытается интерпретировать Т как целое число. Мы хотим создать функцию, которая проверяет вводимую информацию и предупреждает вас, если введено нецелое число. Теперь, может быть, наш проект уже не кажется таким простым. Однако не беспокойтесь - мы хорошо начали: у нас есть имя для новой функции. Мы назовем ее getint( ).

План	Далее   Содержание

     К счастью, мы уже выработали стратегию. Во-первых, заметим, что любую вводимую информацию можно читать как строку символов. Целое число 324, например, можно прочитать как строку из трех символов: символ '3', символ '2' и символ '4'. Это подсказывает нам следующий план:
1. Прочитать вводимую информацию как символьную строку.
2. Проверить, состоит ли строка только из символов цифр и стоит ли перед ними знак плюс или минус.
3. Если все это имеет место, превратить символьную строку в правильное числовое значение.
4. Если нет, выдать предупреждение.

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

     В частности, до того как мы займемся содержанием нашей функции getint( ), нужно точно решить, как она должна взаимодействовать со своим окружением: с какой информацией? Какую информацию она должна получать от вызывающей программы? Какую информацию должна возвращать? В каком виде должна быть эта информация? Снова мы рассматриваем функцию как черный ящик. Мы хотим знать, что входит в функцию и что выходит из нее и, наконец, что находится внутри ее. Этот подход помогает обеспечивать более однородное взаимодействие между различными частями программы. Иначе вы можете оказаться в положении человека, пытающегося установить трансмиссию автомашины "Волво" в автомобиль "Тойота". Сама функция правильная, но интерфейс является проблемой.

Поток информации для getint( )

Далее   Содержание

     Какой выход должна иметь наша функция? Во-первых, несомненно, что она должна была бы выдавать значение прочитанного числа. Конечно, функция scanf( ) уже делает так. Во-вторых, и это очень существенно, мы собираемся создать такую функцию, которая будет выдавать сообщения о состоянии, т. е. найдено или нет целое число. Чтобы функция была действительно полезной, она должна также сообщать о нахождении ею символа EOF. Тогда мы могли бы использовать функцию getint( ) в цикле while, который читает целые числа до тех пор, пока не обнаружит символ EOF. Короче говоря, нам нужно, чтобы getint( ) возвращала два значения: целое числе и состояние.

     Так как мы хотим иметь два значения, то с одной функцией return с этой задачей нам не справиться. Нам следует иметь два указателя. Однако полное решение задачи мы получим, если используем указатели для выполнения основной работы функции и функцию return для выдачи некоторого кода состояния. Именно это и делает функция scanf( ). Она возвращает количество символов, которые нашла, и символ EOF, если встречает его. Ранее мы не пользовались такой возможностью, но могли бы, если бы применяли вызов вида

status = scanf(" % d", &number);

status = getint(&number);

Правая часть равенства использует адрес переменной number, чтобы получить ее значение, a return применяется для получения значения переменной status.

РИС. 10.2. Создание функции getint( )

     Мы должны выбрать коды для выдачи сообщения о состоянии. Так как предполагается, что неописанные функции имеют тип int, наши коды должны состоять из целых чисел. Используем следующие коды для сообщения о состоянии:

-1 означает, что найден символ EOF.
1 означает, что найдена строка, содержащая не цифры.
0 означает, что найдена строка, содержащая только цифры.

     Нашу функцию getint( ) можно представить себе (рис. 10.2) как имеющую один вход и два выхода. На ее вход поступает адрес целой переменной, значение которой считывается. На первом выходе имеем значение считанного целого, полученного через указатель. (Таким образом, аргумент-указатель является двусторонним каналом передачи информации.) На втором выходе получаем код состояния, что обеспечивается функцией return. Отсюда следует, что "скелет" нашей функции должен выглядеть примерно так:

getint(ptint)
int *ptint;    /* указатель	на целое число */
{
int status;
...
return (status);
}

Замечательно! Теперь мы должны просто заполнить внутренность функции.

Содержание getint( )

Далее   Содержание

     Наш основной план для getint( ) в общих чертах на псевдокоде выглядит примерно так:

читаем на входе информацию в виде символов
помещаем символы в строку, пока не встретим символ EOF
если встретился символ EOF, устанавливаем состояние в STOP
в противном случае проверяем строку,
преобразуем символы в целое число, если возможно, и выдаем сообщение о состоянии (YESNUM или NONUM).

Здесь мы используем STOP, YESNUM и NONUM как символические константы, равные -1, 0 и 1, как описано выше.

     Рассмотрим еще некоторые вопросы. Как функция будет решать, что она достигла конца входной строки? Должны ли мы ограничивать длину строки?

     Мы вошли в область, где нам предстоит решать, что предпочесть: удобство программиста или удобство пользователя. Самым простым было бы предложить пользователю нажимать на клавишу [ввод], когда строку надо закончить. Это означало бы один ввод на строку. Для пользователя все же было бы приятнее, если бы функция могла размещать несколько чисел в одной и той же строке:

2   34    4542    2    98

Мы решили предоставить привилегию пользователю. Пусть функция будет считать, что строка начинается с символа, не являющегося пробелом или "новой строкой", и заканчивается символом пробела или "новой строкой". Такой ввод может производиться в одну строку или в несколько строк.

Мы ограничим вводимую строку 80 символами. Так как строки заканчиваются нуль-символом, нам нужен массив из 81 символа для включения в него этого символа. Это слишком щедро, потому что нам нужно только 6 символов для 16-разрядного целого числа и знака. Вы можете вводить более длинные числа, но их размер будет сокращен до размера строки.

Чтобы сделать программу более модульной, мы поручим преобразование "строка в целое число" другой функции, и назовем ее stoi( ). У нас будет также возврат функцией stoi( ) соответствующего кода состояния в функцию getint( ), a getint( ), в свою очередь, может передать код состояния своей вызывающей программе. Функция stoi( ) выполнит последние две строки нашего плана (на псевдокоде).

     Рис. 10.3 представляет программу для функции getint( );. Функция stoi( ) будет показана позже:

/* getint( ) */
#include 
#define LEN 81 /* максимальная длина строки */
#define STOP-1 /* коды состояний */
#define NONUM 1
#define YESNUM О
getint(ptint)
int  *ptint; /* указатель на вывод целого числа */
{
char intarr[LEN]; /* запоминание вводимой строки */
int ch;
int ind = 0; /* индекс массива */

while((ch = getchar( )) = = '\n' || ch == '  ' || ch == '\t');
/* обход начальных символов "новая строка", пробелов и табуляций */
while(ch != EOF && ch != '\n' && ch != '   ' && ind < LEM)
{
intarr[ind++] = ch; /* запись символа в массив */
ch = getchar( ); /* получение очередного символа */
}
intarr[ind] = '\0'; /* конец массива по нуль-символу */
if(ch == EOF)
return(STOP);
else                                                             
return(stoi(intarr, ptint) ); /* выполнение преобразования */
}

     Мы получаем символ сh. Если он является символом пробела, или "новой строки", или табуляции, мы берем следующий символ и так продолжаем до тех пор, пока не получим символ, отличающийся от перечисленных. Затем, если этот символ не EOF, помещаем его в массив. Продолжаем брать символы и помещать их в массив, пока не найдем запрещенный символ или не достигнем предельного размера строки. Далее помещаем нуль-символ (' \0') в следующую позицию массива, чтобы отметить конец строки. Таким образом, мы создали массив в виде стандартной символьной строки. Если EOF был последним прочитанным символом, возвращаем STOP; иначе идем дальше и пытаемся преобразовать строку. Мы вызываем новую функцию stoi( ), чтобы выполнить эту работу. Что делает stoi( )? При вводе она берет символьную строку и указатель на целую переменную, использует указатель для присваивания значения самой переменной, а также return для пересылки сообщения о состоянии, которое getint( ) передает затем функции getarray( ). Поразительно! Двойная игра! Вот менее компактный способ использования функции stoi( ):

status = stoi(intarr, print);
return (status);

Здесь status была бы переменной типа int. Первый оператор дает значение, на которое указывает ptint; она также присваивает значение переменной status. Второй оператор возвращает это значение программе, которая вызвала getint( ). Наша единственная строка программы имеет точно такой же эффект, за исключением того, что нам не нужна промежуточная переменная status. Теперь напишем функцию stol( ).

Преобразование строки в целое: stoi( )

Далее   Содержание

     Сначала опишем, каким должен быть вход и выход у этой функции. Вход будет символьной строкой, поэтому stoi( ) будет иметь символьную строку в качестве аргумента. На выходе должно быть получено два значения: состояние и преобразованное целое число. Мы применяем return для состояния и поэтому должны использовать указатель для возврата другого значения. Таким образом, появится второй аргумент - указатель на целое число. Скелет нашей функции будет выглядеть примерно так:

stoi(string, intptr)
char string[ ];  /* вводимая строка * /
int *intptr; /* указатель на переменную, получающую целое значение*/
{
int status;
...
return(status);
}

Прекрасно, а что можно сказать об алгоритме выполнения преобразования? На некоторое время проигнорируем знак и предположим, что строка содержит только цифры. Возьмем первый символ и преобразуем его в числовой эквивалент. Предположим, это символ '4'. Он имеет в коде ASCII числовое значение 52 и в таком виде запоминается. Если мы из него вычтем 48, то получим 4, т. е.

'4' - 48 = 4

'4' - '0' =4

     Действительно, этот последний оператор был бы справедлив в любом коде, в котором используются последовательные числа для представления последовательных цифр. Поэтому если num - числовое значение, a chn - символ цифры, то

num = chn - '0';

Итак, мы используем этот метод для преобразования первой цифры в число. Теперь возьмем следующий элемент массива. Если он '\0', то у нас была только одна цифра, и мы закончили работу. Предположим, однако, что этот элемент '3'. Превратим его в числовое значение 3. Но если оно равно 3, то 4 должно было быть числом 40, а оба числа вместе 43:

num = 10 * num + chn - '0';

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

     Вот определение функции stoi( ). Мы храним ее в том же файле, что и getint( ), так что она может использовать те же самые директивы #define.

/* превращает строку в целое число и сообщает о состоянии */
stoi(string, intptr)
char  string[ ];  /* строка, подлежащая преобразованию в целое*/
int *intptr;   /* значение целого */
{ 
int sign = 1; /* проверяет наличие знака +  или - */
int index = 0;
if(string[index] == '-' ||  string[index] == '+')
sign = (string[index ++] == '-') ? -1 : 1; /* установить знак */
*intptr = 0; /* начальное значение */ 
while(string[index] >= '0' && string[index] <= '9')
*intptr = 10 * (*intptr) + strmg[index++] - '0';
if(string[index] == '\0')
{
*intptr = sign * (*intptr);
 return(YESNUM); } 
else /* найден символ, отличный от цифры, знака или ' \0'  */
return(NONUM);
}

Оператор while продолжает работу, преобразуя цифры в числа, пока не достигнет нецифрового символа. Если это символ '\0', все прекрасно, потому что он означает конец строки. Любой другой нецифровой символ отсылает программу к else для сообщения об ошибке.

     Стандартная библиотека языка Си содержит функцию atoi( ) (перевод кода ASCII в целое число), очень похожую на stoi( ). Основная разница заключается в том, что stoi( ) проверяет на нецифровые строки, a atoi( ) использует return вместо указателя, для возврата числа, и пропускает пробел, как мы это делали в getint(). Можно было бы осуществить все проверки состояния в getint( ) и использовать atoi( ) вместо stoi( ), но мы полагаем, что было бы интереснее разрабoтать нашу собственную версию.

Проверка

Далее   Содержание

     Так ли уж правильны наши рассуждения? Давайте проверим нашу функцию на учебной программе:

/* проверка функции getint( )*/
#define STOP - 1
#define NONUM 1
#define YESNUM 0
main( )
{
int num, status;

printf(" Программа прекращает считывание чисел, если встречает EOF. \n" );
while((status = getint(&num)) != STOP)
if(status = = YESNUM)
printf(" Число %d принято. \n", num);
else
printf(" Это не целое число! Попытайтесь снова. \n");
printf("Этo оно. \n");
} 

Программа прекращает считывание чисел, если встречает EOF.
100   -23
Число 100 принято.
Чмсло -23 принято.
+892.
Число 892 принято.
wonk
Это не целое число! Попытейтесь снова.
23skidoo
Это не целое число! Попытайтесь снова.
775
Число 775 принято.
Клавиша [control z] (посылает символ EOF в нашу программу).
Это оно.

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

     Есть ли здесь ошибки? По меньшей мере одна. Если непосредственно за числом следует символ EOF без разделяющего пробела или символа новой строки, ввод прекращается, и это число не принимается во внимание:

706 EOF /* 706 принято*/
706 EOF /* 706 не принято*/

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

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

СОРТИРОВКА ЧИСЕЛ

Далее   Содержание

     Одним из наиболее распространенных тестов для машин является сортировка. Мы хотим разработать программу для сортировки целых чисел. Снова применим принцип черного ящика и подумаем в терминах ввода и вывода. Наш общий замысел, показанный на рис. 10.4, довольно прост.

РИС. 10.4. Программа сортировки, рассматриваемая как черный яшик

     На данном этапе программа еще недостаточно определена, чтобы ее кодировать. Следующий шаг заключается в определении главных задач, которые должна выполнить программа для достижения поставленных целей. Их три:
1. Считывание чисел.
2. Сортировка чисел.
3. Печать отсортированных чисел. На рис. 10.5 показано это разделение при движении от верхнего уровня конструкции вниз к более детальному.

РИС. 10.5 Программа сортировки: содержание

     Теперь мы имеем три черных ящика, каждый со своим входом и выходом. Можно передать каждую часть разным группам программистов, если мы уверены в том, что числа, выводимые блоком "считывание", представлены в той же самой форме, которую использует блок "сортировка" для ввода.

     Как вы можете видеть, делается упор на модульность. Мы разделили исходную задачу на три более мелких, но лучше управляемых.

     Что дальше? Теперь приложим наши усилия к каждому из трех модулей в отдельности, разделяя их на более простые элементы до тех пор, пока не достигнем момента, когда программа станет очевидной. Делая это, обратим внимание на такие важные проблемы, как выбор представления данных, локализация ошибок и передача информации. Вернемся к нашему примеру и займемся сначала задачей считывания.

Считывание числовых данных

Далее   Содержание

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

Выбор представления данных

Далее   Содержание

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

     Однако какого типа будет массив? Типа int? Типа double? Нам нужно знать, как такую программу можно будет применять. Предположим, что она должна работать с целыми числами. (А что если она должна применять и целые и нецелые числа? Это возможно, но потребуется работы больше, чем нам бы хотелось сейчас.) Будем использовать массив целых чисел для запоминания чисел, которые мы считываем.

Завершение ввода

Далее   Содержание

     Как программа "узнает", сколько ей нужно считать чисел? В гл. 8 мы обсудили несколько решений этой проблемы, большинство из которых были неудовлетворительны. Однако теперь, когда есть функция getint( ), у нас нет проблем. Вот один подход:

читаем число до тех пор пока не встретится символ EOF
заносим число в массив и
читаем следующее число, если массив не заполнен

     Заметим, что здесь есть два разных условия, приводящих к завершению этой части программы: символ EOF и заполнение массива.

Дальнейшие рассуждения

Далее   Содержание

     Прежде чем реализовать все это на языке Си, нам нужно еще решить, что будем делать с проверкой ошибок ? Должны ли мы превратить эту часть программы в функцию?

     Сначала мы решим, что делать, если пользователь вводит ошибочные данные, скажем букву вместо целого числа? Без функци getint( ) мы полагались бы на "гипотезу идеального пользователя", согласно которой пользователь не делает ошибок при вводе. Однако мы считаем, что эту гипотезу нельзя применять ник одному пользователю, кроме себя. К счастью, можно использовать способность функции getint() сообщать о состоянии, кто поможет нам выйти из затруднительного положения.

     Теперь займемся программированием, которое можно легко реализовать в main( ). Для соблюдения модульности следует использовать разные функции для каждой из трех основных частей программы, что мы как раз и сделаем. Входом для этой функции будут числа с клавиатуры или файл, а выходом - массив, содержащий неотсортированные числа. Было бы хорошо, если бы такая функция помогла основной программе узнать, сколько было считано чисел, поэтому предусмотрим это для выхода. Вконце концов нужно подумать и о пользователе. Мы заставим фикцию печатать сообщение, указывающее ее пределы, и, осуществлять эхо-печать входной информации.

main( ) и getarray( )

Далее   Содержание

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

Сначала напишем main( ):

/* сортировка 1 */
#define MAXSIZE 100 /* предельное количество сортируемых целых чисел */
main( ) 
{
int numbers [MAXSIZE]; /* массив для ввода */
int size; /* количество вводимых чисел */
size = getarray(numbers, MAXSIZE); /* запись чисел в массив */
sort(numbers, size); /* сортировка массива */
print(numbers,/size); /* печать отсортированного массива */
} 

Это общий вид программы. Функция getarray() размещает введенное числа в массиве numbers и выдает сообщение о том, сколько значений было считано; эта величина записывается в size. Затем идя функции sоrt( ) и print( ), которые мы еще должны написать; они сортируют массив и печатают результаты. Включая в них size, мы облегчаем им работу и избавляем от необходимости выполнять самим подсчет. Мы также снабдили getarray( ) переменной MAXSIZE, которая сообщает размер массива, необходимого для запоминания.

     Теперь, когда мы добавили size к передаваемой информации, нужно модифицировать рисунок нашего черного ящика. См. рис. 10.6.

РИС. 10.6. Программ: сортировки, дополнительные детали.

Теперь рассмотрим функцию getarray( ):

/* getarray( ), использующая getint( ) */
#define STOP  -1 /* признак EOF */
#define NONUM 1 /* признак нецифровой строки */
#define YESNUM 0 /* признак строки цифр */
getarray(array, limit);
int array[ ], limit;
{
int num, status;
int index = 0; /* индекс массива */
printf(" Эта программа прекращает считывание чисел после %d значений. \n", limit);
printf(" или если введен символ EOF.\n");
while(index < limit && (status = getint(&num)) != STOP)
{  /* прекращает считывание после достижения limit или EOF */
if(status == YESNUM)
{ array[index++] = num;
printf(" число %d принято.\n", num);
} else if(status == NONUM)
printf(" Это было не целое число! Попытайтесь снова. \n");
else
printf(" Этого не может быть! Что-то неправильно. \n");
if(index == limit) /* сообщить, если массив заполнен */
printf(" Все %d элементов массива заполнены. \n ", limit);
return(index);
}

     Так как немного трудно вспомнить значение, скажем кода -1, мы используем мнемонические символические константы для представления кодов состояния.

     Применяя эти коды, мы создаем getarray( ) для управления каждым из возможных значений состояния. Состояние STOP вызывает прекращение цикла чтения, если getint( ) находит на своем "пути" EOF. Состояние YESNUM говорит о запоминании числа в предлагаемом массиве. Кроме того, отсылается "эхо-число" пользователю, чтобы он знал, что оно принято. Состояние NONUM предписывает пользователю попытаться выполнить задачу еще раз. (Это признак "дружелюбия").

     У нас есть еще оператор else. Единственный путь достижения этого оператора возможен, если getint( ) возвращает значение, отличное от -1, 0 или 1. Однако это единственные значения, которые могут быть возвращены, поэтому else является, по-видимому бесполезным оператором. Почему он включен в программу? Мы вставили его как пример "защитного программирования", как способ защиты программы от будущей ошибки.

     Когда-нибудь мы (или кто-нибудь еще), может быть, решим обратиться к функции getint( ) и добавить в ее репертуар немного больше возможных значений состояния. Наиболее вероятно, что мы забудем (а они могут никогда не узнать), что getarray( ) предполагает только три возможных ответа. Поэтому мы включаем это последнее else, чтобы "поймать" любые новые ответы, которые появятся, и значительно упростить будущую отладку.

     Размер массива устанавливается в main(). Поэтому мы не задаем его, когда описываем аргумент-массив в getarray(). Мы ставим только квадратные скобки в оператор, чтобы указать, что аргумент является массивом.

int numbers [MAXSIZE]; /* размер задается в main */
int array[ ] /* нет определения размера в вызвавшей функции */

Использование массивов в функциях обсудим в гл. 12. Мы решили применить ключевое слово return для возврата числа прочитанных элементов. Таким образом, вызов нашей функции:

size = getarray(numbers);

присваивает значение переменной size и дает значения массиву numbers. Вы можете спросить, почему мы не использовали указатели в вызове

size = getаrray (numbers);

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

numbers == &numbers[0]

Когда функция getarray() создает массив array, то адрес элемента аrrау[0] совпадает с адресом элемента numbers[0] и т. д. для всех других индексов. Поэтому все манипуляции, которые выполняет qetarray( ) с аrrау[ ], фактически выполняются с numbers[ ]. Мы будем более подробно говорить о связи между указателями и массивами в гл. 12. Теперь же нам нужно усвоить, что функция воздействует на массив в вызывающей программе, если мы используем массив в качестве аргумента функции.

     В функциях, содержащих счетчики и пределы, таких как getarray( ), наиболее вероятным местом появления ошибок являются "граничные условия", где значения счетчиков достигают своих пределов. Мы собираемся прочитать максимальное количество чисел, указанное в MAXSIZE, или же мы намерены ограничиться одним? Хотим обратить внимание на детали, такие, как ++index или index++ и < или <=. Мы также должны помнить, что у массивов индексы начинаются с 0, а не с 1.

     Проверьте вашу программу и посмотрите, работает ли она так, как должна. Самое простое - предположить, что limit равен 1 и пройти по программе шаг за шагом.

     Обычно наиболее трудной частью программы является обеспечение ее взаимодействия с пользователем удобным и надежным способом. Это относится и к нашей программе. Теперь, когда мы справились с getarray( ), находим, что функция sort( ) должна быть проще и print( ) - тоже. Теперь перейдем к функции sort( ).

Сортировка данных

Далее   Содержание

     Рассмотрим еще раз функцию main( ):

main(  )
{
int numbers[MAXSIZE]; /* массив для ввода */
int size;     /* количество введенных элементов */
size = getarray(numbers, MAXSIZE); /* помещает ввод в массив */
sort(numbers, size); /* сортировка массива */
printf(numbers, size); /* печать отсортированного массива	*/
}

     Мы видим, что функция sort() имеет на входе массив целых чисел, предназначенных для сортировки, и счетчик количества элементов, подлежащих сортировке. На выходе получается массив, содержащий отсортированные числа. Мы все еще не решили, как выполнять сортировку, поэтому мы должны дополнительно уточнить это описание.

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

     Рассмотрим теперь метод, который будем использовать для сортировки. В настоящее время разработано много алгоритмов сортировки; возьмем один из самых простых.

Вот наш план на псевдокоде:
от n = первому элементу до n = ближайшему - к- последнему элементу находим самое большое из оставшихся чисел и помещаем его в n-ю позицию.

     Он выполняется примерно так. Сначала пусть n = 1. Мы просматриваем весь массив, находим самое большое число и помещаем его в первый элемент. Затем n = 2, и мы опять просматриваем весь массив, кроме первого элемента, находим самое большое из оставшихся чисел и помещаем его во второй элемент. Продолжаем этот процесс до тех пор, пока не достигнем ближайшего - к - последнему элементу. Теперь осталось только два элемента. Мы сравниваем эти числа и помещаем большее в элемент, ближайший - к - последнему. Оставшееся самое меньшее из всех чисел помещаем в последний элемент.

     Это выглядит очень похоже на задачу с циклом for, но мы все же должны описать процесс "найти и поместить" более детально. Как сделать так, чтобы мы находили каждый раз самое большое из оставшихся чисел? Вот один способ. Сравните первый и второй элементы оставшегося массива. Если второй больше, поменяйте их местами. Теперь сравните первый элемент с третьим. Если третий больше, поменяйте местами эти два. Каждый раз больший элемент перемещается вверх. Продолжаем таким образом, пока не сравним первый элемент с последним. Если мы дошли до конца, самое большое число теперь будет в первом элементе оставшегося массива. По существу мы имеем отсортированный массив для первого элемента, но остаток массива находится в беспорядке. На псевдокоде это можно выразить так:

для n = от второго до последнего элемента сравниваем n-й элемент с первым; если n-й больше, меняем их местами.

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

/* сортировка массива целых чисел в порядке убывания */
sortarray(array, limit)
int array[ ], limit;
{
int top, search;
for(top = 0; top < limit - 1; top++)
for(search = top + 1; search < limit; search++)
if(array [search] > array[top]  
interchange(&array[search], &array[top] );
} 

Мы помним, что первый элемент имеет индекс 0. Кроме того, еще в гл. 9 была создана функция обмена, поэтому мы использовали ее здесь. Так как функция interchange "работает" с двумя элементами массива, а не со всем массивом, мы должны использовать адреса только двух интересующих нас элементов. (В то время как имя array является указателем на весь массив, нам нужно применить операцию &, чтобы указывать на отдельные элементы.)

     Мы использовали top в качестве индекса для элемента массива, который следует заполнить, так как он является вершиной неотсортированной части массива. Индекс search перемещает по массиву в порядке убывания текущий элемент. Большинство текстов использует обозначения i и j для этих индексов, однако это осложняет ситуацию, если нужно посмотреть, что происходит.

     Этот алгоритм иногда называют "пузырьковой сортировкой", так как самое большое значение медленно поднимется вверх. Именно теперь мы должны написать функцию рrint( ).

Печать данных

Далее   Содержание

     Эта программа достаточно проста:

/* печать массива */
print(array, limit)
int array[ ], limit;
{
int index;
for(index = 0; index <= limit; index ++)
printf(" %d\n", array[index]);
}

Если мы хотим сделать что-нибудь другое, например печатать по строкам, а не в столбец, можно всегда вернуться и изменить эту функцию, оставив другие функции неизменными. Аналогично, если мы нашли алгоритм сортировки, который нам больше нравится, можно. заменить этот модули программы. Это один из приятных моментов модульной программы.

Результаты

Далее   Содержание

     Давайте скомпилируем и протестируем нашу программу сортировки. Чтобы упростить проверку граничных условий, временно изменим MAXSIZE на 5.

     В нашем первом тесте будем снабжать программу числами до тех пор, пока она не откажется их принимать.

     Эта программа прекращает считывание чисел после 5 значений, или если встретился символ EOF.

12 34 54 23 67
Все 5 элементов массива заполнены.
67
54
34
23
12

Программа считала 5 чисел и отсортировала их. Теперь посмотрим, как будет выглядеть результат, если она остановится, встретив символ EOF.

     Эта программа прекращает считывание чисел после 5 значений, или если встретился символ EOF.

456 928
-23  +16
Клавиша [control -z] (передает EOF в нашу систему)
928
456
16
-23

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

     Этим завершаются наши примеры в данной главе. Давайте теперь вернемся немного назад и сделаем обзор главы.

ОБЗОР

Далее   Содержание

     Чего же мы достигли? Если посмотреть с практической стороны, то мы разработали генератор случайных чисел и программу сортировки целых чисел. При этом создали функцию getint( ), которую можно использовать в других программах. Если посмотреть с педагогической точки зрения, то мы проиллюстрировали несколько основных принципов и концепций, полезных при создании программ.

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

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

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

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

ЧТО ВЫ ДОЛЖНЫ БЫЛИ УЗНАТЬ В ЭТОЙ ГЛАВЕ

Далее   Содержание

Как представлять функцию: черный ящик с информационным потоком.
Что такое "проверка ошибок" и почему эта процедура хороша.
Алгоритм сортировки.
Как заставить функцию изменять массив: function(array).
Как преобразовать строку цифр в число.
Классы памяти: auto, extern, static и register.
Область действия каждого класса памяти.
Какой класс памяти использовать: обычно auto.

ВОПРОСЫ И ОТВЕТЫ

Далее   Содержание

Вопросы

1. Что может сделать наш алгоритм сортировки неэффективным?
2. Как следует изменить нашу программу сортировки, чтобы она сортировала и по рядке возрастания, а не убывания?
3. Измените функцию print( ) таким образом, чтобы она печатала по 5 чисел в строке.
4. Как следует изменить функцию stoi( ), чтобы обрабатывать строки, представляющие восьмеричные числа?
5. Какие функции "знают" каждую переменную из описанных ниже? Есть ли здесь какие-нибудь ошибки?

/* файл1 */ 
int  daisy;
main( )
{
int lily;
}
petal( ) {
extern int daisy, lily;
}
/* файл2 */
static int lily;
int rose;
stem( ) {
int rose;
}
root( )
{
extern int daisy;
}

1. Предположим, что вы сортируете 20 чисел. Программа производит 19 сравнений, чтобы найти одно самое большое число. Затем делается 18 сравнений, чтобы найти следующее самое большое. Вся информация, полученная во время первого поиска "забывается" за исключением самого большого числа, поставленного на первое место. Второе самое большое число можно временно поместить на место с номером 1, а затем при сортировке опустить вниз. Много сравнений, выполнявшихся в первый раз, повторяется второй, третий раз и т. д.

2. Замените array[search] > array[top] на array[search] < array[top]

3.

/* печать массива */
print(array, limit)
int array[ ], limit);
{
int index;
for(index = 0; index < limit; index++)
{ printf("%10d", array[index]);
if(index % 5 == 4) primf("\n" );
} printf("\n");
}

4. Во-первых, обеспечьте, чтобы разрешенные символы были только цифрами от 0 до 7. Во-вторых, умножайте на 8 вместо 10 каждый раз, когда обнаружите новую цифру.

5. daisy известна функции main( ) по умолчанию и функциям petal( ) и rоо1( ) благодаря extern-описанию. Она не известна функции stem( ), потому что они находятся в разных файлах.
Первая lily локальна для main: ссылка на lily в petal( ) является ошибочной, потому что в каждом из этих файлов нет внешней lily.
Есть внешняя статическая lity, но она известна только функциям второго файла. Первая, внешняя rose, известна функции root( ), а функция stem( ) отменила ее своей собственной локальной rose.

УПРАЖНЕНИЯ

Содержание

1. Некоторые пользователи, возможно испугаются, если их попросить ввести символ EOF.
     а. Модифицируйте getarray( ) и вызываемые ею функции так, чтобы использовать символ # вместо EOF.
     б. Модифицируйте затем их так, чтобы можно было использовать либо EOF, либо #.

2. Создайте программу, которая сортирует числа типа float.

3. Создайте программу, превращающую смешанный текст из прописных и строчных букв в текст, состоящий только из прописных букв.

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

[Содержание] [Вверх]
Язык Си	Классы памяти и разработка программ