Язык Си - руководство для начинающих - M. УЭИТ

     Функция atof( ) выполняет подобные действия для чисел с плавающей точкой. Она возвращает тип double, поэтому должна быть описана как double в использующей ее программе.

     Простые версии atof( ) будут обрабатывать числа вида 10.2, 46 и - 124.26. Более мощные версии преобразуют также экспоненциальную запись, т. е. числа, подобные 1.25Е - 13.

     Ваша система может также иметь обратные функции, работающие в противоположном направлении. Функция itoa( ) будет преобразовывать целое в символьную строку, а функция ftoa( ) преобразовывать число с плавающей точкой в символьную строку.

ВЫХОД: exit( )

     Функция exit( ) даст вам удобный способ "покинуть" программу. Она часто используется для прекращения работы программы при появлении ошибки. Если к exit( ) обратились из функции, вызванной главной программой, то прекращает работу вся программа, а не только эта функция. В приведенном выше примере с функцией atoi( ) использование exit( ) позволяет нам избежать включения дополнительного оператора else для обхода остатка программы.

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

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

Есть еще одна тема, которую мы хотим обсудить.

РАСПРЕДЕЛЕНИЕ ПАМЯТИ: malloc( ) И са11ос( )

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

char place[ ] = "Залив Свиной печенки";

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

Или мы можем быть более конкретны и запросить определенный объем памяти:

int plates[100];

Это описание выделяет 100 ячеек памяти, каждая из которых предназначена для запоминания целого значения.

     Язык Си не останавливается на этом. Он позволяет вам распределять дополнительную память во время работы программы. Предположим, например, вы пишете диалоговую программу и не знаете заранее, сколько данных вам придется вводить. Можно выделить нужный вам (как вы считаете) объем памяти, а затем, если понадобится, потребовать еще. На рис. 15.5 дан пример, в котором используется функция malloc( ), чтобы сделать именно это. Кроме того, обратите внимание на то, как такая программа применяет указатели.

/* добавляет память, если необходимо */

#include <sldio.h>

#define STOP "  "   /* сигнал прекращения ввода */

#define BLOCK 100 /* байты памяти */

#define LIM 40     /* предельная длина вводимой строки */

#define MAX 50     /* максимальное число вводимых строк */

#define DRAMA 20000 /* большая задержка времени */

main( )

{

char store[BLOCK]; /* исходный блок памяти */

char symph[LIM]; /* приемник вводимых строк */

char *end;  /* указывает на конец памяти */

char *starts[MAX]; /* указывает на начала строк */

int index = 0; /* количество вводимых строк */

int count;  /* счетчик */

char *malloc( ); /* распределитель памяти */

starts[0] = store;

end = starts[0] + BLOCK - 1;

puts(" Назовите несколько симфонических оркестром.");

puts(" Вводите по одному: нажмите клавишу [ввод] в начале");

puts(" строки для завершения вашего списка. Хорошо, я готова." );

while(strcmp(fgets(symph, LIM, stdin), STOP) != 0 && index < MAX)

{ if(strlen(symph) > end - starts[index])

{ /* действия при недостатке памяти для запоминания вводимых данных*/

puts(" Подождите секунду. Я попробую найти дополнительную память.");

starts[index] = malloc(BLOCK);

end = starts[index] + BLOCK - 1;

for(count = 0; count < DRAMA; count++);

puts(" Нашла немного!" );  }

strcpy (starts [index], symph);

starts[index + 1] = starts[index] + strlen(symph) + 1;

if(++index < MAX)

    printf("Этo %d. Продолжайте, если хотите.n", index); }

puts(" Хорошо, вот что я получила:");

for(count = 0; count < index; count ++)

    puts(starts[count]);

}

РИС. 15.5. Программа, добавляющая память по требованию.

Вот образец работы программы:

Назовите несколько симфонических оркестров оркестров.

Вводите их по одному;  нажмите клавишу [ввод] в начале

строки для завершения нашего списка. Хорошо, я готова.

Сан-франциский симфонический.

Это 1. Продолжайте, если хотите.

Чикагский симфонический

Это 2. Продолжайте, если хотите.

Берлинский филармонический

Это 3. Продолжайте, если хотите.

Московский камерный

Это 4. Продолжайте, если хотите. Лондонский симфонический

Это 5. Продолжайте, если хотите. Венский филармонический

Подождите секунду.  Я попробую найти дополнительную память.

Нашла немного!

Это 6. Продолжайте, если хотите.

Питтсбургский симфонический

Это 7. Продолжайте, если хотите.

Хорошо, вот что я получила:

Сан-францизкий симфонический

Чикагский симфонический

Берлинский филармонический

Московский камерный

Лондонский симфонический

Венский филармонический

Питтсбургский симфонический

     Сначала давайте посмотрим, что делает функция malloc( ). Она берет аргумент в виде целого без знака, которое представляет количество требуемых байтов памяти. Так, malloc(BLOCK) требует 100 байт. Функция возвращает указатель на тип char в начало нового блока памяти. Мы использовали описание

char *malloc( );

чтобы предупредить компилятор, что malloc( ) возвращает указатель на тип char. Поэтому мы присвоили значение этого указателя элементу массива starts[index] при помощи оператора

starts[index] = malloc(BLOCK);

     Хорошо, давайте теперь рассмотрим проект программы, заключающийся в том, чтобы запомнить все исходные строки подряд в большом массиве store. Мы хотим использовать starts[0] для ссылки на начало первой строки, starts[l] - второй строки и т. д. На промежуточном этапе программа вводит строку в массив symph. Мы использовали fgets( ) вместо gets( ), чтобы ограничить входную строку длиной массива symph.

РИС. 15.6. Последовательные строки symph, записанные в массив store.

     Прежде чем копировать symph в store, мы должны проверить, достаточно ли для нее оставшегося места. Указатель end ссылается на конец памяти, а текущее значение starts[index] ссылается на начало неиспользованной памяти. Таким образом, мы можем сравнить разницу между этими двумя указателями с длиной symph и определить, достаточно ли осталось памяти.

     Если места недостаточно, вызываем malloc( ), чтобы подготовить дополнительную память. Мы устанавливаем starts[index] на начало нового блока памяти, a end - на конец нового блока. Заметим, что у нас нет имени этой новой памяти. Она не является, например, расширением store. У нас есть только обозначения указателей, ссылающихся на новую область памяти.

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

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

     Таким образом используется mаllос( ). Но предположим, что вы хотите работать с памятью типа int, а не char. Можете и здесь использовать mаllос( ). Вот как это делается:

char *malloc( ); /* по-прежнему описываем как указатель на char */

int *newmem;

newmem = (int *) malloc(l00); /* используем операцию приведения типа */

Снова требуется 100 байт. Операция приведения типа преобразует значение, возвращенное указателем на тип char, в указатель на тип int. Если, как в нашей системе, int занимает два байта памяти, это значит, что newmem + 1 будет увеличивать указатель на два байта, т. е. передвигать его к следующему целому. Это также означает, что 100 байт можно использовать для запоминания 50 целых чисел.