WWW.DISSERS.RU

БЕСПЛАТНАЯ ЭЛЕКТРОННАЯ БИБЛИОТЕКА

   Добро пожаловать!

Pages:     | 1 || 3 | 4 |   ...   | 6 |

«А. Богатырёв, 1992-96 -1- Си в UNIX™ А. Богатырёв Язык Си в системе UNIX ...»

-- [ Страница 2 ] --

} } Ответ: потому, что в каждом файле описана глобальная переменная x. Надо в одном из них (или в обоих сразу) сделать x локальным именем (исключить его из интерфейса модуля):

static int x=...;

Почему в следующем примере компилятор сообщает "_f дважды определено"?

файл A.c файл B.c --------------------------------------------------- int x;

extern int x;

main(){ f(5);

g(77);

} g(n){ f(x+n);

} f(n) { x=n;

} f(m){ printf("%d\n", m);

} Ответ: надо сделать в файле B.c функцию f локальной: static f(m)...

Хоть в одном файле должна быть определена функция main, вызываемая системой при запуске про граммы. Если такой функции нигде нет - компилятор выдает сообщение "_main неопределено". Функция main должна быть определена один раз! В файле она может находиться в любом месте - не требуется, чтобы она была самой первой (или последней) функцией файла‡.

1.140. В чем ошибка?

файл A.c файл B.c --------------------------------------------------- extern int x;

extern int x;

main(){ x=2;

f(){ f();

printf("%d\n", x);

} } Ответ: переменная x в обоих файлах объявлена как extern, в результате память для нее нигде не выделена, т.е. x не определена ни в одном файле. Уберите одно из слов extern!

1.141. В чем ошибка?

‡ Можно задать Makefile вида CFLAGS = -O AB: A.o B.o cc A.o B.o -o AB A.o: A.c cc -c $(CFLAGS) A.c B.o: B.c cc -c $(CFLAGS) B.c и собирать программу просто вызывая команду make.

‡ Если вы пользуетесь "новым" стилем объявления функций, но не используете прототипы, то следует определять каждую функцию до первого места ее использования, чтобы компилятору в точке вызова был известен ее заголовок. Это приведет к тому, что main() окажется последней функцией в файле - ее не вы зывает никто, зато она вызывает кого-то еще.

А. Богатырёв, 1992-96 - 63 - Си в UNIX™ файл A.c файл B.c --------------------------------------------------- int x;

extern double x;

......

Типы переменных не совпадают. Большинство компиляторов не ловит такую ошибку, т.к. каждый файл ком пилируется отдельно, независимо от остальных, а при "склейке" файлов в общую выполняемую программу компоновщик знает лишь имена переменных и функций, но не их типы и прототипы. В результате про грамма нормально скомпилируется и соберется, но результат ее выполнения будет непредсказуем! Поэтому объявления extern тоже полезно выносить в include-файлы:

файл proto.h ----------------- extern int x;

файл A.c файл B.c ------------------ ----------------- #include "proto.h" #include "proto.h" int x;

...

то, что переменная x в A.c оказывается описанной и как extern - вполне допустимо, т.к. в момент настоя щего объявления этой переменной это слово начнет просто игнорироваться (лишь бы типы в объявлении с extern и без него совпадали - иначе ошибка!).

1.142. Что печатает программа и почему?

int a = 1;

/* пример Bjarne Stroustrup-а */ void f(){ int b = 1;

static int c = 1;

printf("a=%d b=%d c=%d\n", a++, b++, c++);

} void main(){ while(a < 4) f();

} Ответ:

a=1 b=1 c= a=2 b=1 c= a=3 b=1 c= 1.143. Автоматическая переменная видима только внутри блока, в котором она описана. Что напечатает программа?

/* файл A.c */ int x=666;

/*глоб.*/ main(){ f(3);

printf(" ::x = %d\n", x);

g(2);

g(5);

printf(" ::x = %d\n", x);

} g(n){ static int x=17;

/*видима только в g*/ printf("g::x = %2d g::n = %d\n", x++, n);

if(n) g(n-1);

else x = 0;

} /* файл B.c */ extern x;

/*глобал*/ f(n){ /*локал функции*/ x++;

/*глобал*/ { int x;

/*локал блока*/ x = n+1;

/*локал*/ n = 2*x;

/*локал*/ } x = n-1;

/*глобал*/ } А. Богатырёв, 1992-96 - 64 - Си в UNIX™ 1.144. Функция, которая • не содержит внутри себя статических переменных, хранящих состояние процесса обработки данных (функция без "памяти");

• получает значения параметров только через свои аргументы (но не через глобальные статические пере менные);

• возвращает значения только через аргументы, либо как значение функции (через return);

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

FILE *fp;

... /* глобальный аргумент */ char delayedInput () { static char prevchar;

/* память */ char c;

c = prevchar;

prevchar = getc (fp);

return c;

} А вот ее реентерабельный эквивалент:

char delayedInput (char *prevchar, FILE *fp) { char c;

c = *prevchar;

*prevchar = getc (fp);

return c;

} /* вызов: */ FILE *fp1, *fp2;

char prev1, prev2, c1, c2;

... x1 = delayedInput (&prev1, fp1);

x2 = delayedInput (&prev2, fp2);

...

Как видим, все "запоминающие" переменные (т.е. prevchar) вынесены из самой функции и подаются в нее в виде аргумента.

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

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

Вот еще один пример на эту тему. Не-реентерабельный вариант:

int x, y, result;

int f (){ static int z = 4;

y = x + z;

z = y - 1;

return x/2;

} Вызов: x=13;

result = f();

printf("%d\n", y);

А вот реентерабельный эквивалент:

А. Богатырёв, 1992-96 - 65 - Си в UNIX™ int y, result, zmem = 4;

int f (/*IN*/ int x, /*OUT*/ int *ay, /*INOUT*/ int *az){ *az = (*ay = x + *az) - 1;

return x/2;

} Вызов: result = f(13, &y, &zmem);

printf("%d\n", y);

1.145. То, что формат заголовка функции должен быть известен компилятору до момента ее использова ния, побуждает нас помещать определение функции до точки ее вызова. Так, если main вызывает f, а f вызывает g, то в файле функции расположатся в порядке { } g() {... g();

... } f() main(){... f();

... } Программа обычно разрабатывается "сверху-вниз" - от main к деталям. Си же вынуждает нас размещать функции в программе в обратном порядке, и в итоге программа читается снизу-вверх - от деталей к main, и читать ее следует от конца файла к началу!

Так мы вынуждены писать, чтобы удовлетворить Си-компилятор:

#include unsigned long g(unsigned char *s){ const int BITS = (sizeof(long) * 8);

unsigned long sum = 0;

for(;

*s;

s++){ sum ^= *s;

/* cyclic rotate left */ sum = (sum<<1)|(sum>>(BITS-1));

} return sum;

} void f(char *s){ printf("%s %lu\n", s, g((unsigned char *)s));

} int main(int ac, char *av[]){ int i;

for(i=1;

i < ac;

i++) f(av[i]);

return 0;

} А вот как мы разрабатываем программу:

А. Богатырёв, 1992-96 - 66 - Си в UNIX™ #include int main(int ac, char *av[]){ int i;

for(i=1;

i < ac;

i++) f(av[i]);

return 0;

} void f(char *s){ printf("%s %lu\n", s, g((unsigned char *)s));

} unsigned long g(unsigned char *s){ const int BITS = (sizeof(long) * 8);

unsigned long sum = 0;

for(;

*s;

s++){ sum ^= *s;

/* cyclic rotate left */ sum = (sum<<1)|(sum>>(BITS-1));

} return sum;

} и вот какую ругань производит Си-компилятор в ответ на эту программу:

"0000.c", line 10: identifier redeclared: f current : function(pointer to char) returning void previous: function() returning int : "0000.c", line "0000.c", line 13: identifier redeclared: g current : function(pointer to uchar) returning ulong previous: function() returning int : "0000.c", line Решением проблемы является - задать прототипы (объявления заголовков) всех функций в начале файла (или даже вынести их в header-файл).

#include int main(int ac, char *av[]);

void f(char *s);

unsigned long g(unsigned char *s);

...

Тогда функции будет можно располагать в тексте в любом порядке.

1.146. Рассмотрим процесс сборки программы из нескольких файлов на языке Си. Пусть мы имеем файлы file1.c, file2.c, file3.c (один из них должен содержать среди других функций функцию main). Ключ компилятора -o заставляет создавать выполняемую программу с именем, указанным после этого ключа.

Если этот ключ не задан - будет создан выполняемый файл a.out cc file1.c file2.c file3.c -o file Мы получили выполняемую программу file. Это эквивалентно 4-м командам:

-c file1.c получится file1.o cc -c file2.c file2.o cc -c file3.c file3.o cc file1.o file2.o file3.o -o file cc Ключ -c заставляет компилятор превратить файл на языке Си в "объектный" файл (содержащий машинные команды;

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

† На самом деле, для "склейки" объектных файлов в выполняемую программу, команда /bin/cc вызы вает программу /bin/ld - link editor, linker, редактор связей, компоновщик.

А. Богатырёв, 1992-96 - 67 - Си в UNIX™ Если у нас уже есть какие-то готовые объектные файлы, мы можем транслировать только новые Си файлы:

cc -c file4.c cc file1.o file2.o file3.o file4.o -o file или (что то же самое, но cc сам разберется, что надо делать) cc file1.o file2.o file3.o file4.c -o file Существующие у нас объектные файлы с отлаженными функциями удобно собрать в библиотеку - файл специальной структуры, содержащий все указанные файлы (все файлы склеены в один длинный файл, раз деляясь специальными заголовками, см. include-файл ):

ar r file.a file1.o file2.o file3.o Будет создана библиотека file.a, содержащая перечисленные.o файлы (имена библиотек в UNIX имеют суффикс.a - от слова archive, архив). После этого можно использовать библиотеку:

cc file4.o file5.o file.a -o file Механизм таков: если в файлах file4.o и file5.o не определена какая-то функция (функции), то просматрива ется библиотека, и в список файлов для "склейки" добавляется файл из библиотеки, содержащий определе ние этой функции (из библиотеки он не удаляется!). Тонкость: из библиотеки берутся не ВСЕ файлы, а лишь те, которые содержат определения недостающих функций‡. Если, в свою очередь, файлы, извлекае мые из библиотеки, будут содержать неопределенные функции - библиотека (библиотеки) будут просмо трены еще раз и.т.д. (на самом деле достаточно максимум двух проходов, так как при первом просмотре библиотеки можно составить ее каталог: где какие функции в ней содержатся и кого вызывают). Можно указывать и несколько библиотек:

cc file6.c file7.o \ file.a mylib.a /lib/libLIBR1.a -o file Таким образом, в команде cc можно смешивать имена файлов: исходных текстов на Си.c, объектных фай лов.o и файлов-библиотек.a.

Просмотр библиотек, находящихся в стандартных местах (каталогах /lib и /usr/lib), можно включить и еще одним способом: указав ключ -l. Если библиотека называется /lib/libLIBR1.a или /usr/lib/libLIBR2.a то подключение делается ключами и -lLIBR1 -lLIBR соответственно.

cc file1.c file2.c file3.o mylib.a -lLIBR1 -o file Список библиотек и ключей -l должен идти после имен всех исходных.c и объектных.o файлов.

Библиотека стандартных функций языка Си /lib/libc.a (ключ -lc) подключается автоматически ("под ключить" библиотеку - значит вынудить компилятор просматривать ее при сборке, если какие-то функции, использованные вами, не были вами определены), то есть просматривается всегда (именно эта библиотека содержит коды, например, для printf, strcat, read).

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

• описание (документация).

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

Таким образом вы знаете, как надо вызывать библиотечные функции и какие структуры данных вы должны использовать в своей программе для обращения к ним (хотя и не имеете текстов самих библиотечных функций, т.е. не знаете, как они устроены. Например, вы часто используете printf(), но задумываетесь ли вы о ее внутреннем устройстве?). Некоторые библиотечные функции могут быть вообще написаны не на Си, а ‡ Поэтому библиотека может быть очень большой, а к нашей программе "приклеится" лишь неболь шое число файлов из нее. В связи с этим стремятся делать файлы, помещаемые в библиотеку, как можно меньше: 1 функция;

либо "пачка" функций, вызывающих друг друга.

А. Богатырёв, 1992-96 - 68 - Си в UNIX™ на ассемблере или другом языке программирования††. Еще раз обращаю ваше внимание, что библиотека содержит не исходные тексты функций, а скомпилированные коды (и include-файлы содержат (как правило) не тексты функций, а только описание форматов данных)! Библиотека может также содержать статические данные, вроде массивов строк-сообщений об ошибках.

Посмотреть список файлов, содержащихся в библиотеке, можно командой ar tv имяФайлаБиблиотеки а список имен функций - командой nm имяФайлаБиблиотеки Извлечь файл (файлы) из архива (скопировать его в текущий каталог), либо удалить его из библиотеки можно командами ar x имяФайлаБиблиотеки имяФайла1...

ar d имяФайлаБиблиотеки имяФайла1...

где... означает список имен файлов.

"Лицом" библиотек служат прилагаемые к ним include-файлы. Системные include-файлы, содержа щие общие форматы данных для стандартных библиотечных функций, хранятся в каталоге /usr/include и подключаются так:

для /usr/include/файл.h надо #include <файл.h> для /usr/include/sys/файл.h #include (sys - это каталог, где описаны форматы данных, используемых ядром ОС и системными вызовами). Ваши собственные include-файлы (посмотрите в предыдущий раздел!) ищутся в текущем каталоге и включаются при помощи #include "файл.h" /* */./файл.h #include "../h/файл.h" /* */../h/файл.h #include "/usr/my/файл.h" /* /usr/my/файл.h */ Непременно изучите содержимое стандартных include-файлов в своей системе!

В качестве резюме - схема, поясняющая "превращения" Си-программы из текста на языке програм мирования в выполняемый код: все файлы.c могут использовать общие include-файлы;

их подстановку в текст, а также обработку #define произведет препроцессор cpp file1.c file2.c file3.c | | | "препроцессор" | cpp | cpp | cpp | | | "компиляция" | cc -c | cc -c | cc -c | | | file1.o file2.o file3.o | | | -----------*---------- | Неявно добавятся:

ld |<----- /lib/libc.a (библ. станд. функций) | /lib/crt0.o (стартер) "связывание" | "компоновка" |<----- Явно указанные библиотеки:

| -lm /lib/libm.a V a.out 1.147. Напоследок - простой, но жизненно важный совет. Если вы пишете программу, которую вставите в систему для частого использования, поместите в исходный текст этой программы идентификационную строку наподобие static char id[] = "This is /usr/abs/mybin/xprogram";

†† Обратите внимание, что библиотечные функции не являются частью ЯЗЫКА Си как такового. То, что в других языках (PL/1, Algol-68, Pascal) является частью языка (встроено в язык)- в Си вынесено на уровень библиотек. Например, в Си нет оператора вывода;

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

А. Богатырёв, 1992-96 - 69 - Си в UNIX™ Тогда в случае аварии в файловой системе, если вдруг ваш файл "потеряется" (то есть у него пропадет имя - например из-за порчи каталога), то он будет найден программой проверки файловой системы - fsck - и помещен в каталог /lost+found под специальным кодовым именем, ничего общего не имеющим со старым.

Чтобы понять, что это был за файл и во что его следует переименовать (чтобы восстановить правильное имя), мы применим команду strings имя_файла Эта команда покажет все длинные строки из печатных символов, содержащиеся в данном файле, в частно сти и нашу строку id[]. Увидев ее, мы сразу поймем, что файл надо переименовать так:

mv имя_файла /usr/abs/mybin/xprogram 1.148. Где размещать include-файлы и как программа узнает, где же они лежат? Стандартные системные include-файлы размещены в /usr/include и подкаталогах. Если мы пишем некую свою программу (проект) и используем директивы #include "имяФайла.h" то обычно include-файлы имяФайла.h лежат в текущем каталоге (там же, где и файлы с программой на Си).

Однако мы можем помещать ВСЕ наши include-файлы в одно место (скажем, известное группе программи стов, работающих над одним и тем же проектом). Хорошее место для всех ваших личных include-файлов каталог (вами созданный) $HOME/include где $HOME - ваш домашний каталог. Хорошее место для общих include-файлов - каталог /usr/local/include Как сказать компилятору, что #include "" файлы надо брать из определенного места, а не из текущего ката лога? Это делает ключ компилятора cc -Iимя_каталога...

Например:

/* Файл x.c */ #include "x.h" int main(int ac, char *av[]){....

return 0;

} И файл x.h находится в каталоге /home/abs/include/x.h (/home/abs - мой домашний каталог). Запуск про граммы на компиляцию выглядит так:

cc -I/home/abs/include -O x.c -o x или cc -I$HOME/include -O x.c -o x Или, если моя программа x.c находится в /home/abs/progs cc -I../include -O x.c -o x Ключ -O задает вызов компилятора с оптимизацией.

Ключ -I оказывает влияние и на #include <> директивы тоже. Для ОС Solaris на машинах Sun про граммы для оконной системы X Window System содержат строки вроде #include #include На Sun эти файлы находятся не в /usr/include/X11, а в /usr/openwin/include/X11. Поэтому запуск на компи ляцию оконных программ на Sun выглядит так:

cc -O -I/usr/openwin/include xprogram.c \ -o xprogram -L/usr/openwin/lib -lX где -lX11 задает подключение графической оконной библиотеки Xlib.

Если include-файлы находятся во многих каталогах, то можно задать поиск в нескольких каталогах, к примеру:

cc -I/usr/openwin/include -I/usr/local/include -I$HOME/include...

А. Богатырёв, 1992-96 - 70 - Си в UNIX™ 2. Массивы, строки, указатели.

Массив представляет собой агрегат из нескольких переменных одного и того же типа. Массив с име нем a из LENGTH элементов типа TYPE объявляется так:

TYPE a[LENGTH];

Это соответствует тому, что объявляются переменные типа TYPE со специальными именами a[0], a[1],..., a[LENGTH-1]. Каждый элемент массива имеет свой номер - индекс. Доступ к x-ому элементу массива осу ществляется при помощи операции индексации:

int x =... ;

/* целочисленный индекс */ TYPE value = a[x];

/* чтение x-ого элемента */ a[x] = value;

/* запись в x-тый элемент */ В качестве индекса может использоваться любое выражение, выдающее значение целого типа: char, short, int, long. Индексы элементов массива в Си начинаются с 0 (а не с 1), и индекс последнего элемента мас сива из LENGTH элементов - это LENGTH-1 (а не LENGTH). Поэтому цикл по всем элементам массива - это TYPE a[LENGTH];

int indx;

for(indx=0;

indx < LENGTH;

indx++)...a[indx]...;

indx < LENGTH равнозначно indx <= LENGTH-1. Выход за границы массива (попытка чтения/записи несуще ствующего элемента) может привести к непредсказуемым результатам и поведению программы. Отметим, что это одна из самых распространенных ошибок.

Статические массивы можно объявлять с инициализацией, перечисляя значения их элементов в {} через запятую. Если задано меньше элементов, чем длина массива - остальные элементы считаются нулями:

int a10[10] = { 1, 2, 3, 4 };

/* и 6 нулей */ Если при описании массива с инициализацией не указать его размер, он будет подсчитан компилятором:

int a3[] = { 1, 2, 3 };

/* как бы a3[3] */ В большинстве современных компьютеров (с фон-Неймановской архитектурой) память представляет собой массив байт. Когда мы описываем некоторую переменную или массив, в памяти выделяется непре рывная область для хранения этой переменной. Все байты памяти компьютера пронумерованы. Номер байта, с которого начинается в памяти наша переменная, называется адресом этой переменной (адрес может иметь и более сложную структуру, чем просто целое число - например состоять из номера сегмента памяти и номера байта в этом сегменте). В Си адрес переменной можно получить с помощью операции взятия адреса &. Пусть у нас есть переменная var, тогда &var - ее адрес. Адрес нельзя присваивать целой переменной;

для хранения адресов используются указатели (смотри ниже).

Данное может занимать несколько подряд идущих байт. Размер в байтах участка памяти, требуемого для хранения значения типа TYPE, можно узнать при помощи операции sizeof(TYPE), а размер переменной - при помощи sizeof(var). Всегда выполняется sizeof(char)==1. В некоторых машинах адреса переменных (а также агрегатов данных - массивов и структур) кратны sizeof(int) или sizeof(double) - это так называемое "выравнивание (alignment) данных на границу типа int". Это позволяет делать доступ к данным более быстрым (аппаратура работает эффективнее).

Язык Си предоставляет нам средство для работы с адресами данных - указатели (pointer)†. Указа тель физически - это адрес некоторой переменной ("указуемой" переменной). Отличие указателей от машинных адресов состоит в том, что указатель может содержать адреса данных только определенного типа. Указатель ptr, который может указывать на данные типа TYPE, описывается так:

/* переменная */ TYPE var;

/* объявление ук-ля */ TYPE *ptr;

ptr = & var;

В данном случае мы занесли в указательную переменную ptr адрес переменной var. Будем говорить, что указатель ptr указывает на переменную var (или, что ptr установлен на var). Пусть TYPE равно int, и у нас есть массив и указатели:

int array[LENGTH], value;

int *ptr, *ptr1;

Установим указатель на x-ый элемент массива † В данной книге слова "указатель" и "ссылка" употребляются в одном и том же смысле. Если вы обратитесь к языку Си++, то обнаружите, что там эти два термина (pointer и reference) означают разные по нятия (хотя и сходные).

А. Богатырёв, 1992-96 - 71 - Си в UNIX™ ptr = & array[x];

Указателю можно присвоить значение другого указателя на такой же тип. В результате оба указателя будут указывать на одно и то же место в памяти: ptr1 = ptr;

Мы можем изменять указуемую переменную при помощи операции * *ptr = 128;

/* занести 128 в указуемую перем. */ value = *ptr;

/* прочесть указуемую переменную */ В данном случае мы заносим и затем читаем значение переменной array[x], на которую поставлен указа тель, то есть *ptr означает сейчас array[x] Таким образом, операция * (значение по адресу) оказывается обратной к операции & (взятие адреса):

& (*ptr) == ptr и * (&value) == value Операция * объясняет смысл описания TYPE *ptr;

оно означает, что значение выражения *ptr будет иметь тип TYPE. Название же типа самого указателя - это (TYPE *). В частности, TYPE может сам быть указатель ным типом - можно объявить указатель на указатель, вроде char **ptrptr;

Имя массива - это константа, представляющая собой указатель на 0-ой элемент массива. Этот ука затель отличается от обычных тем, что его нельзя изменить (установить на другую переменную), поскольку он сам хранится не в переменной, а является просто некоторым постоянным адресом.

массив указатель _ array: | array[0] | ptr:| * | | array[1] | | | array[2] |<--------- сейчас равен &array[2] |... | Следствием такой интерпретации имен массивов является то, что для того чтобы поставить указатель на начало массива, надо писать ptr = array;

или ptr = &array[0];

но не ptr = &array;

Операция & перед одиноким именем массива не нужна и недопустима!

Такое родство указателей и массивов позволяет нам применять операцию * к имени массива:

value = *array;

означает то же самое, что и value = array[0];

Указатели - не целые числа! Хотя физически это и номера байтов, адресная арифметика отлича ется от обычной. Так, если дан указатель TYPE *ptr;

и номер байта (адрес), на который указывает ptr, равен byteaddr, то ptr = ptr + n;

/* n - целое, может быть и < 0 */ заставит ptr указывать не на байт номер byteaddr + n, а на байт номер byteaddr + (n * sizeof(TYPE)) то есть прибавление единицы к указателю продвигает адрес не на 1 байт, а на размер указываемого указа телем типа данных! Пусть указатель ptr указывает на x-ый элемент массива array. Тогда после TYPE *ptr2 = array + L;

/* L - целое */ TYPE *ptr1 = ptr + N;

/* N - целое */ ptr += M;

/* M - целое */ указатели указывают на ptr1 == &array[x+N] и == &array[x+M] ptr ptr2 == &array[L] Если мы теперь рассмотрим цепочку равенств *ptr2 = *(array + L) = *(&array[L]) = array[L] то получим ОСНОВНОЕ ПРАВИЛО: пусть ptr - указатель или имя массива. Тогда операции индексации, взятия значе ния по адресу, взятия адреса и прибавления целого к указателю связаны соотношениями:

тождественно *(ptr+x) ptr[x] тождественно &ptr[x] ptr+x (тождества верны в обе стороны), в том числе при x==0 и x < 0. Так что, например, А. Богатырёв, 1992-96 - 72 - Си в UNIX™ ptr[-1] означает *(ptr-1) ptr[0] означает *ptr Указатели можно индексировать подобно массивам. Рассмотрим пример:

/* индекс: 0 1 2 3 4 */ double numbers[5] = { 0.0, 1.0, 2.0, 3.0, 4.0 };

double *dptr = &numbers[2];

double number = dptr[2];

/* равно 4.0 */ numbers: [0] [1] [2] [3] [4] | [-2] [-1] [0] [1] [2] dptr поскольку если dptr = &numbers[x] = numbers + x то dptr[i] = *(dptr + i) = = *(numbers + x + i) = numbers[x + i] Указатель на один тип можно преобразовать в указатель на другой тип: такое преобразование не вызывает генерации каких-либо машинных команд, но заставляет компилятор изменить параметры адрес ной арифметики, а также операции выборки данного по указателю (собственно, разница в указателях на данные разных типов состоит только в размерах указуемых типов;

а также в генерации команд `->' для выборки полей структур, если указатель - на структурный тип).

Целые (int или long) числа иногда можно преобразовывать в указатели. Этим пользуются при напи сании драйверов устройств для доступа к регистрам по физическим адресам, например:

unsigned short *KISA5 = (unsigned short *) 0172352;

Здесь возникают два тонких момента:

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

2. Структура адреса, поддерживаемая процессором, может не соответствовать формату целых (или длинных целых) чисел. Так обстоит дело с IBM PC 8086/80286, где адрес состоит из пары short int чисел, хранящихся в памяти подряд. Однако весь адрес (если рассматривать эти два числа как одно длинное целое) не является обычным long-числом, а вычисляется более сложным способом: адрес ная пара SEGMENT:OFFSET преобразуется так unsigned short SEGMENT, OFFSET;

/*16 бит: [0..65535]*/ unsigned long ADDRESS = (SEGMENT << 4) + OFFSET;

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

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

Отметим, что указатель можно направить в неправильное место - на участок памяти, содержащий данные не того типа, который задан в описании указателя;

либо вообще содержащий неизвестно что:

int i = 2, *iptr = &i;

double x = 12.76;

iptr += 7;

/* куда же он указал ?! */ iptr = (int *) &x;

i = *iptr;

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

При передаче имени массива в качестве параметра функции, как аргумент передается не копия САМОГО МАССИВА (это заняло бы слишком много места), а копия АДРЕСА 0-ого элемента этого массива А. Богатырёв, 1992-96 - 73 - Си в UNIX™ (т.е. указатель на начало массива).

){ x++;

} f(int x g(int xa[]){ xa[0]++;

} int a[2] = { 1, 1 };

/* объявление с инициализацией */ main(){ f(a[0]);

printf("%d\n",a[0]);

/* a[0] осталось равно 1*/ );

printf("%d\n",a[0]);

/* a[0] стало равно 2 */ g(a } В f() в качестве аргумента передается копия элемента a[0] (и изменение этой копии не приводит к измене нию самого массива - аргумент x является локальной переменной в f()), а в g() таким локалом является АДРЕС массива a - но не сам массив, поэтому xa[0]++ изменяет сам массив a (зато, например, xa++ внутри g() изменило бы лишь локальную указательную переменную xa, но не адрес массива a).

Заметьте, что поскольку массив передается как указатель на его начало, то размер массива в объ явлении аргумента можно не указывать. Это позволяет одной функцией обрабатывать массивы разной длины:

вместо Fun(int xa[5]) {... } можно Fun(int xa[] ) {... } или даже Fun(int *xa ) {... } Если функция должна знать длину массива - передавайте ее как дополнительный аргумент:

int sum( int a[], int len ){ int s=0, i;

for(i=0;

i < len;

i++) s += a[i];

return( s );

}... int arr[10] = {... };

... int sum10 = sum(arr, 10);

...

Количество элементов в массиве TYPE arr[N];

можно вычислить специальным образом, как #define LENGTH (sizeof(arr) / sizeof(arr[0])) или #define LENGTH (sizeof(arr) / sizeof(TYPE)) Оба способа выдадут число, равное N. Эти конструкции обычно употребляются для вычисления длины мас сивов, задаваемых в виде TYPE arr[] = {....... };

без явного указания размера. sizeof(arr) выдает размер всего массива в байтах. sizeof(arr[0]) выдает раз мер одного элемента. И все это не зависит от типа элемента (просто потому, что все элементы массивов имеют одинаковый размер).

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

С массивами байт можно использовать следующую конструкцию, задающую массивы (строки) одина кового размера:

char stringA [ITSSIZE];

char stringB [sizeof stringA];

В данном разделе мы в основном будем рассматривать строки и указатели на символы.

2.1. Операции взятия адреса объекта и разыменования указателя - взаимно обратны.

TYPE objx;

TYPE *ptrx = &objx;

/* инициализируем адресом objx */ *(&objx) = objx;

&(*ptrx) = ptrx;

Вот пример того, как можно заменить условный оператор условным выражением (это удастся не всегда):

А. Богатырёв, 1992-96 - 74 - Си в UNIX™ if(c) a = 1;

else b = 1;

Предупреждение: такой стиль не способствует понятности программы и даже компактности ее кода.

#include int main(int ac, char *av[]){ int a, b, c;

a = b = c = 0;

if(av[1]) c = atoi(av[1]);

*(c ? &a : &b) = 1;

/* !!! */ printf("cond=%d a=%d b=%d\n", c, a, b);

return 0;

} 2.2. Каким образом инициализируются по умолчанию внешние и статические массивы? Инициализируются ли по умолчанию автоматические массивы? Каким образом можно присваивать значения элементам мас сива, относящегося к любому классу памяти?

2.3. Пусть задан массив int arr[10];

что тогда означают выражения:

arr[0] *arr *arr + arr[2] *(arr + 2) arr &arr[2] arr+ 2.4. Правильно ли написано увеличение величины, на которую указывает указатель a, на единицу?

*a++;

Ответ: нет, надо:

(*a)++;

или *a += 1;

2.5. Дан фрагмент текста:

char a[] = "xyz";

char *b = a + 1;

Чему равны "abcd"[3] b[-1] b[2] (Ответ: 'x', '\0', 'd' ) Можно ли написать a++ ? То же про b++ ? Можно ли написать b=a ? a=b ? (нет, да, да, нет) 2.6. Ниже приведена программа, вычисляющая среднее значение элементов массива int arr [] = {1, 7, 4, 45, 31, 20, 57, 11};

main () { int i;

long sum;

for ( i = 0, sum = 0L;

i < (sizeof(arr)/sizeof(int));

i++ ) sum += arr[i];

printf ("Среднее значение = %ld\n", sum/8) } Перепишите указанную программу с применением указателей.

2.7. Что напечатается в результате работы программы?

char arr[] = {'С', 'Л', 'А', 'В', 'А'};

main () { char *pt;

int i;

pt = arr + sizeof(arr) - 1;

for( i = 0;

i < 5;

i++, pt-- ) А. Богатырёв, 1992-96 - 75 - Си в UNIX™ printf("%c %c\n", arr[i], *pt);

} Почему массив arr[] описан вне функции main()? Как внести его в функцию main() ? Ответ: написать вну три main static char arr[]=...

2.8. Можно ли писать на Си так:

f( n, m ){ int x[n];

int y[n*2];

int z[n * m];

...

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

2.9. Предположим, что у нас есть описание массива static int mas[30][100];

a) выразите адрес mas[22][56] иначе b) выразите адрес mas[22][0] двумя способами c) выразите адрес mas[0][0] тремя способами 2.10. Составьте программу инициализации двумерного массива a[10][10], выборки элементов с a[5][5] до a[9][9] и их распечатки. Используйте доступ к элементам по указателю.

2.11. Составьте функцию вычисления скалярного произведения двух векторов. Длина векторов задается в качестве одного из аргументов.

2.12. Составьте функцию умножения двумерных матриц a[][] * b[][].

2.13. Составьте функцию умножения трехмерных матриц a[][][] * b[][][].

2.14. Для тех, кто программировал на языке Pascal: какая допущена ошибка?

char a[10][20];

char c;

int x,y;

...

c = a[x,y];

Ответ: многомерные массивы в Си надо индексировать так:

c = a[x][y];

В написанном же примере мы имеем в качестве индекса выражение x,y (оператор "запятая") со значением y, т.е.

c = a[y];

Синтаксической ошибки нет, но смысл совершенно изменился!

2.15. Двумерные массивы в памяти представляются как одномерные. Например, если int a[N][M];

то конструкция a[y][x] превращается при компиляции в одномерную конструкцию, подобную такой:

int a[N * M];

/* массив развернут построчно */ #define a_yx(y, x) a[(x) + (y) * M] то есть a[y][x] есть *(&a[0][0] + y * M + x) Следствием этого является то, что компилятор для генерации индексации двумерных (и более) массовов должен знать M - размер массива по 2-ому измерению (а также 3-ему, 4-ому, и.т.д.). В частности, при передаче многомерного массива в функцию А. Богатырёв, 1992-96 - 76 - Си в UNIX™ f(arr) int arr[N][M];

{... } /* годится */ f(arr) int arr[] [M];

{... } /* годится */ f(arr) int arr[] [];

{... } /* не годится */ f(arr) int (*arr)[M];

{... } /* годится */ f(arr) int *arr [M];

{... } /* не годится:

это уже не двумерный массив, а одномерный массив указателей */ А также при описании внешних массивов:

extern int a[N][M];

/* годится */ extern int a[ ][M];

/* годится */ extern int a[ ][ ];

/* не годится: компилятор не сможет сгенерить операцию индексации */ Вот как, к примеру, должна выглядеть работа с двумерным массивом arr[ROWS][COLS], отведенным при помощи malloc();

void f(int array[][COLS]){ int x, y;

for(y=0;

y < ROWS;

y++) for(x=0;

x < COLS;

x++) array[y][x] = 1;

} void main(){ int *ptr = (int *) malloc(sizeof(int) * ROWS * COLS);

f( (int (*) [COLS]) ptr);

} 2.16. Как описывать ссылки (указатели) на двумерные массивы? Рассмотрим такую программу:

#include #define First #define Second char arr[First][Second] = { "ABC.", { 'D', 'E', 'F', '?', '\0' }, { 'G', 'H', 'Z', '!', '\0' } };

char (*ptr)[Second];

main(){ int i;

ptr = arr;

/* arr и ptr теперь взаимозаменимы */ for(i=0;

i < First;

i++) printf("%s\t%s\t%c\n", arr[i], ptr[i], ptr[i][2]);

} Указателем здесь является ptr. Отметим, что у него задана размерность по второму измерению: Second, именно для того, чтобы компилятор мог правильно вычислить двумерные индексы.

Попробуйте сами объявить char (*ptr)[4];

char (*ptr)[6];

char **ptr;

и увидеть, к каким невеселым эффектам это приведет (компилятор, кстати, будет ругаться;

но есть вероят ность, что он все же странслирует это для вас. Но работать оно будет плачевно). Попробуйте также использовать ptr[x][y].

Обратите также внимание на инициализацию строк в нашем примере. Строка "ABC." равносильна объявлению { 'A', 'B', 'C', '.', '\0' }, А. Богатырёв, 1992-96 - 77 - Си в UNIX™ 2.17. Массив s моделирует двумерный массив char s[H][W];

Перепишите пример при помощи указателей, избавьтесь от операции умножения. Прямоугольник (x0,y0,width,height) лежит целиком внутри (0,0,W,H).

char s[W*H];

int x,y;

int x0,y0,width,height;

for(x=0;

x < W*H;

x++) s[x] = '.';

...

for(y=y0;

y < y0+height;

y++) for(x=x0;

x < x0+width;

x++) s[x + W*y] = '*';

Ответ:

char s[W*H];

int i,j;

int x0,y0,width,height;

char *curs;

...

for(curs = s + x0 + W*y0, i=0;

i < height;

i++, curs += W-width) for(j=0;

j < width;

j++) *curs++ = '*';

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

2.18. Что означают описания?

int i;

// целое.

int *pi;

// указатель на целое.

int *api[3];

// массив из 3х ук-лей на целые.

int (*pai)[3];

// указатель на массив из 3х целых.

// можно описать как int **pai;

int fi();

// функция, возвращающая целое.

int *fpi();

// ф-ция, возвр. ук-ль на целое.

int (*pfi)();

// ук-ль на ф-цию, возвращающую целое.

int *(*pfpi)();

// ук-ль на ф-цию, возвр. ук-ль на int.

int (*pfpfi())();

// ф-ция, возвращающая указатель на // "функцию, возвращающую целое".

int (*fai())[3];

// ф-ция, возвр. ук-ль на массив // из 3х целых. иначе ее // можно описать как int **fai();

int (*apfi[3])();

// массив из 3х ук-лей на функции, // возвращающие целые.

Переменные в Си описываются в формате их использования. Так описание int (*f)();

означает, что f можно использовать в виде int value;

value = (*f)(1, 2, 3 /* список аргументов */);

Однако из такого способа описания тип самой описываемой переменной и его смысл довольно неоче видны. Приведем прием (позаимствованный из журнала "Communications of the ACM"), позволяющий про яснить смысл описания. Описание на Си переводится в описание в стиле языка Algol-68. Далее означает "указатель на ТИП" ref ТИП "функция, возвращающая ТИП" proc() ТИП "массив из элементов ТИПа" array of ТИП "x имеет тип ТИП" x: ТИП Приведем несколько примеров, из которых ясен и способ преобразования:

int (*f())();

означает (*f())() : int *f() : proc() int f() : ref proc() int f : proc() ref proc() int то есть f - функция, возвращающая указатель на функцию, возвращающую целое.

А. Богатырёв, 1992-96 - 78 - Си в UNIX™ int (*f[3])();

означает (*f[])() : int *f[] : proc() int f[] : ref proc() int f : array of ref proc() int f - массив указателей на функции, возвращающие целые. Обратно: опишем g как указатель на функцию, возвращающую указатель на массив из 5и указателей на функции, возвращающие указатели на целые.

g : ref p() ref array of ref p() ref int *g : p() ref array of ref p() ref int (*g)() : ref array of ref p() ref int *(*g)() : array of ref p() ref int (*(*g)())[5] : ref p() ref int *(*(*g)())[5] : p() ref int (*(*(*g)())[5])(): ref int *(*(*(*g)())[5])(): int int *(*(*(*g)())[5])();

В Си невозможны функции, возвращающие массив:

proc() array of...

а только proc() ref array of...

Само название типа (например, для использования в операции приведения типа) получается вычеркиванием имени переменной (а также можно опустить размер массива):

g = ( int *(*(*(*)())[])() ) 0;

2.19. Напишите функцию strcat(d,s), приписывающую строку s к концу строки d.

Ответ:

char *strcat(d,s) register char *d, *s;

{ while( *d ) d++;

/* ищем конец строки d */ while( *d++ = *s++ );

/* strcpy(d, s) */ return (d-1);

/* конец строки */ } Цикл, помеченный "strcpy" - это наиболее краткая запись операторов do{ char c;

c = (*d = *s);

s++;

d++;

} while(c != '\0');

На самом деле strcat должен по стандарту возвращать свой первый аргумент, как и функция strcpy:

char *strcat(d,s) register char *d, *s;

{ char *p = d;

while( *d ) d++;

strcpy(d, s);

return p;

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

2.20. Напишите программу, которая объединяет и распечатывает две строки, введенные с терминала. Для ввода строк используйте функцию gets(), а для их объединения - strcat(). В другом варианте используйте sprintf(result,"%s%s",s1,s2);

2.21. Модифицируйте предыдущую программу таким образом, чтобы она выдавала длину (число симво лов) объединенной строки. Используйте функцию strlen(). Приведем несколько версий реализации strlen:

/* При помощи индексации массива */ int strlen(s) char s[];

{ int length = 0;

for(;

s[length] != '\0';

length++);

return (length);

} /* При помощи продвижения указателя */ int strlen(s) char *s;

А. Богатырёв, 1992-96 - 79 - Си в UNIX™ { int length;

for(length=0;

*s;

length++, s++);

return length;

} /* При помощи разности указателей */ int strlen(register char *s) { register char *p = s;

while(*p) p++;

/* ищет конец строки */ return (p - s);

} Разность двух указателей на один и тот же тип - целое число:

если TYPE *p1, *p2;

то p2 - p1 = целое число штук TYPE лежащих между p2 и p если p2 = p1 + n то p2 - p1 = n Эта разность может быть и отрицательной если p2 < p1, то есть p2 указывает на более левый элемент мас сива.

2.22. Напишите оператор Си, который обрубает строку s до длины n букв. Ответ:

if( strlen(s) > n ) s[n] = '\0';

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

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

на последний байт. Ответ:

#define isdigit(c) ('0' <= (c) && (c) <= '9') int atoi(s) register char *s;

{ register int res=0, neg=0;

for(;

;

s++){ switch(*s){ case ' ': case '\t': continue;

case '-': neg++;

case '+': s++;

} break;

} while(isdigit(*s)) res = res * 10 + *s++ - '0';

return( neg ? -res : res );

} int backatoi(s) register char *s;

{ int res=0, pow=1;

while(isdigit(*s)){ res += (*s-- - '0') * pow;

pow *= 10;

} if(*s == '-') res = -res;

return res;

} 2.24. Можно ли для занесения в массив s строки "hello" написать char s[6];

s = "hello";

или char s[6], d[] = "hello";

s = d;

Ответ: нет. Массивы в Си нельзя присваивать целиком. Для пересылки массива байт надо использовать функцию strcpy(s,d). Здесь же мы пытаемся изменить адрес s (имя массива - это адрес начала памяти, выделенной для хранения массива), сделав его равным адресу безымянной строки "hello" (или массива d во А. Богатырёв, 1992-96 - 80 - Си в UNIX™ втором случае). Этот адрес является константой и не может быть изменен!

Заметим однако, что описание массива с инициализацией вполне допустимо:

char s[6] = "hello";

или char s[6] = { 'h', 'e', 'l', 'l', 'o', '\0' };

или char s[] = "hello";

или char s[] = { "hello" };

В этом случае компилятор резервирует память для хранения массива и расписывает ее байтами начального значения. Обратите внимание, что строка в двойных кавычках (если ее рассматривать как массив букв) имеет длину на единицу больше, чем написано букв в строке, поскольку в конце массива находится символ '\0' - признак конца, добавленный компилятором. Если бы мы написали char s[5] = "hello";

то компилятор сообщил бы об ошибке, поскольку длины массива (5) недостаточно, чтобы разместить байт. В третьей строке примера написано s[], чтобы компилятор сам посчитал необходимую длину мас сива.

Наконец, возможна ситуация, когда массив больше, чем хранящаяся в нем строка. Тогда "лишнее" место содержит какой-то мусор (в static-памяти изначально - байты \0).

char s[12] = "hello";

содержит: h e l l o \0 ? ? ? ? ? ?

В программах текстовой обработки под "длиной строки" обычно понимают количество букв в строке НЕ счи тая закрывающий байт '\0'. Именно такую длину считает стандартная функция strlen(s). Поэтому следует различать такие понятия как "(текущая) длина строки" и "длина массива, в котором хранится строка":

sizeof(s). Для написанного выше примера эти значения равны соответственно 5 и 12.

Следует также отличать массивы от указателей:

char *sp = "bye bye";

sp = "hello";

будет вполне законно, поскольку в данном случае sp - не имя массива (т.е. константа, равная адресу начала массива), а указатель (переменная, хранящая адрес некоторой области памяти). Поскольку указатель - это переменная, то ее значение изменять можно: в данном случае sp сначала содержала адрес безымянного массива, в котором находится "bye bye";

затем мы занесли в sp адрес безымянного массива, хранящего строку "hello". Здесь не происходит копирования массива, а происходит просто присваивание переменной sp нового значения адреса.

Предостережем от возможной неприятности:

char d[5];

char s[] = "abcdefgh";

strcpy(d, s);

Длины массива d просто не хватит для хранения такой длинной строки. Поскольку это ничем не контроли руется (ни компилятором, ни самой strcpy, ни вами явным образом), то при копировании строки "избыточ ные" байты запишутся после массива d поверх других данных, которые будут испорчены. Это приведет к непредсказуемым эффектам.

Некоторые возможности для контроля за длиной строк-аргументов вам дают функции strncpy(d,s,len);

strncat(d,s,len);

strncmp(s1,s2,len). Они пересылают (сравнивают) не более, чем len первых символов строки s (строк s1, s2). Посмотрите в документацию! Напишите функцию strncmp (сравнение строк по пер вым len символам), посмотрев на функцию strncpy:

char *strncpy(dst, src, n) register char *dst, *src;

register int n;

{ char *save;

for(save=dst;

--n >= 0;

) if( !(*dst++ = *src++)){ while(--n >= 0) *dst++ = '\0';

return save;

} return save;

} Отметьте, что strncpy обладает одним неприятным свойством: если n <= strlen(src), то строка dst не будет А. Богатырёв, 1992-96 - 81 - Си в UNIX™ иметь на конце символа '\0', то есть будет находиться в некорректном (не каноническом) состоянии.

Ответ:

int strncmp(register char *s1, register char *s2, register int n) { if(s1 == s2) return(0);

while(--n >= 0 && *s1 == *s2++) if(*s1++ == '\0') return(0);

return((n < 0)? 0: (*s1 - *--s2));

} 2.25. В чем ошибка?

#include /* для putchar */ char s[] = "We don't need no education";

main(){ while(*s) putchar(*s++);

} Ответ: здесь s - константа, к ней неприменима операция ++. Надо написать char *s = "We don't need no education";

сделав s указателем на безымянный маccив. Указатель уже можно изменять.

2.26. Какие из приведенных конструкций обозначают одно и то же?

char a[] = "";

/* пустая строка */ char b[] = "\0";

char c = '\0';

char z[] = "ab";

char aa[] = { '\0' };

char bb[] = { '\0', '\0' };

char xx[] = { 'a', 'b' };

char zz[] = { 'a', 'b', '\0' };

char *ptr = "ab";

2.27. Найдите ошибки в описании символьной строки:

main() { char mas[] = {'s', 'o', 'r', 't'};

/* "sort" ? */ printf("%s\n", mas);

} Ответ: строка должна кончаться '\0' (в нашем случае printf не обнаружив символа конца строки будет выда вать и байты, находящиеся в памяти после массива mas, т.е. мусор);

инициализированный массив не может быть автоматическим - требуется static:

main() { static char mas[] = {'s', 'o', 'r', 't', '\0'};

} Заметим, что main(){ char *mas = "sort";

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

2.28. В чем ошибка? Программа собирается из двух файлов: a.c и b.c командой cc a.c b.c -o ab a.c b.c -------------------------------------------------- int n = 2;

extern int n;

char s[] = "012345678";

extern char *s;

main(){ f(){ f();

s[n] = '+';

printf("%s\n", s );

} } Ответ: дело в том, что типы (char *) - указатель, и char[] - массив, означают одно и то же только при А. Богатырёв, 1992-96 - 82 - Си в UNIX™ объявлении формального параметра функции:

f(char *arg){...} f(char arg[]){...} это будет локальная переменная, содержащая указатель на char (т.е. адрес некоторого байта в памяти).

Внутри функции мы можем изменять эту переменную, например arg++. Далее, и (char *) и char[] одина ково используются, например, оба эти типа можно индексировать: arg[i]. Но вне функций они объявляют разные объекты! Так char *p;

это скалярная переменная, хранящая адрес (указатель):

-------- ------ p:| *--|----->| '0' | char -------- | '1' | char...

тогда как char a[20];

это адрес начала массива (а вовсе не переменная):

------ a:| '0' | char | '1' | char...

В нашем примере в файле b.c мы объявили внешний массив s как переменную. В результате компилятор будет интерпретировать начало массива s как переменную, содержащую указатель на char.

------ s:| '0' | \ это будет воспринято как | '1' | / адрес других данных.

| '2' |...

И индексироваться будет уже ЭТОТ адрес! Результат - обращение по несуществующему адресу. То, что написано у нас, эквивалентно char s[] = "012345678";

char **ss = s;

/* s - как бы "массив указателей" */ /* первые байты s интерпретируются как указатель: */ char *p = ss[0];

p[2] = '+';

Мы же должны были объявить в b.c extern char s[];

/* размер указывать не требуется */ Вот еще один аналогичный пример, который пояснит вам, что происходит (а заодно покажет порядок байтов в long). Пример выполнялся на IBM PC 80386, на которой sizeof(char *) = sizeof(long) = a.c b.c -------------------------------------------------- char s[20] = {1,2,3,4};

extern char *s;

main(){ f(){ /*печать указателя как long */ f();

printf( "%08lX\n", s );

} } печатается 04030201.

2.29. Что напечатает программа?

static char str1[ ] = "abc";

static char str2[4];

strcpy( str2, str1 );

/* можно ли написать str2 = str1;

? */ printf( str1 == str2 ? "равно":"не равно" );

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

Ответ: сравниваются адреса массивов, хранящих строки. Так А. Богатырёв, 1992-96 - 83 - Си в UNIX™ char str1[2];

char str2[2];

main(){ printf( str1 < str2 ? "<":">");

} печатает <, а если написать char str2[2];

char str1[2];

то напечатается >.

2.30. Напишите программу, спрашивающую ваше имя до тех пор, пока вы его правильно не введете. Для сравнения строк используйте функцию strcmp() (ее реализация есть в главе "Мобильность").

2.31. Какие значения возвращает функция strcmp() в следующей программе?

#include main() { printf("%d\n", strcmp("abc", "abc"));

/* 0 */ printf("%d\n", strcmp("ab", "abc"));

/* -99 */ printf("%d\n", strcmp("abd", "abc"));

/* 1 */ printf("%d\n", strcmp("abc", "abd"));

/* -1 */ printf("%d\n", strcmp("abc", "abe"));

/* -2 */ } 2.32. В качестве итога предыдущих задач: помните, что в Си строки (а не адреса) надо сравнивать как if( strcmp("abc", "bcd") < 0)... ;

if( strcmp("abc", "bcd") == 0)... ;

вместо if( "abc" < "bcd" )... ;

if( "abc" == "bcd" )... ;

и присваивать как char d[80], s[80];

strcpy( d, s );

вместо d = s;

2.33. Напишите программу, которая сортирует по алфавиту и печатает следующие ключевые слова языка Си:

int char double long for while if 2.34. Вопрос не совсем про строки, скорее про цикл: чем плоха конструкция?

char s[] = "You're a smart boy, now shut up.";

int i, len;

for(i=0;

i < strlen(s);

i++) putchar(s[i]);

Ответ: в соответствии с семантикой Си цикл развернется примерно в i=0;

LOOP: if( !(i < strlen(s))) goto ENDLOOP;

putchar(s[i]);

i++;

goto LOOP;

ENDLOOP: ;

Заметьте, что хотя длина строки s не меняется, strlen(s) вычисляется на КАЖДОЙ итерации цикла, совер шая лишнюю работу! Борьба с этим такова:

for(i=0, len=strlen(s);

i < len;

i++ ) putchar(s[i]);

или for(i=0, len=strlen(s);

len > 0;

i++, --len ) putchar(s[i]);

Аналогично, в цикле А. Богатырёв, 1992-96 - 84 - Си в UNIX™ while( i < strlen(s))...;

функция тоже будет вычисляться при каждой проверке условия! Это, конечно, относится к любой функции, используемой в условии, а не только к strlen. (Но, разумеется, случай когда функция возвращает признак "надо ли продолжать цикл" - совсем другое дело: такая функция обязана вычисляться каждый раз).

2.35. Что напечатает следующая программа?

#include main(){ static char str[] = "До встречи в буфете";

char *pt;

pt = str;

puts(pt);

puts(++pt);

str[7] = '\0';

puts(str);

puts(pt);

puts(++pt);

} 2.36. Что напечатает следующая программа?

main() { static char name[] = "Константин";

char *pt;

pt = name + strlen(name);

while(--pt >= name) puts(pt);

} 2.37. Что напечатает следующая программа?

char str1[] = "abcdef";

char str2[] = "xyz";

main(){ register char *a, *b;

a = str1;

b = str2;

while( *b ) *a++ = *b++;

printf( "str=%s a=%s\n", str1, a );

a = str1;

b = str2;

while( *b ) *++a = *b++;

printf( "str=%s a=%s\n", str1, a );

} Ответ:

str=xyzdef a=def str=xxyzef a=zef 2.38. Что печатает программа?

char *s;

for(s = "Ситроен";

*s;

s+= 2){ putchar(s[0]);

if(!s[1]) break;

} putchar('\n');

2.39. Что напечатает программа? Рассмотрите продвижение указателя s, указателей - элементов массива strs[]. Разберитесь с порядком выполнения операций. В каких случаях ++ изменяет указатель, а в каких букву в строке? Нарисуйте себе картинку, изображающую состояние указателей - она поможет вам распу тать эти спагетти. Уделите разбору этого примера достаточное время!

#include /* определение NULL */ /* Латинский алфавит: abcdefghijklmnopqrstuvwxyz */ char *strs[] = { "abcd","ABCD","0fpx","159", "hello","-gop","A1479",NULL А. Богатырёв, 1992-96 - 85 - Си в UNIX™ };

main(){ char c, **s = strs, *p;

c = *++*s;

printf("#1 %d %c %s\n", s-strs, c, *s);

c = **++s;

printf("#2 %d %c %s\n", s-strs, c, *s);

c = **s++;

printf("#3 %d %c %s\n", s-strs, c, *s);

c = ++**s;

printf("#4 %d %c %s\n", s-strs, c, *s);

c = (**s)++;

printf("#5 %d %c %s\n", s-strs, c, *s);

c = ++*++*s;

printf("#6 %d %c %s\n", s-strs, c, *s);

c = *++*s++;

printf("#7 %d %c %s %s\n", s-strs, c, *s, strs[2]);

c = ++*++*s++;

printf("#8 %d %c %s %s\n", s-strs, c, *s, strs[3]);

c = ++*++*++s;

printf("#9 %d %c %s\n", s-strs,c,*s);

c = ++**s++;

printf("#10 %d %c %s\n",s-strs,c,*s);

p = *s;

c = ++*(*s)++;

printf("#11 %d %c %s %s %s\n",s-strs,c,*s,strs[6],p);

c = ++*((*s)++);

printf("#12 %d %c %s %s\n", s-strs, c, *s, strs[6]);

c = (*++(*s))++;

printf("#13 %d %c %s %s\n", s-strs, c, *s, strs[6]);

for(s=strs;

*s;

s++) printf("strs[%d]=\"%s\"\n", s-strs, *s);

putchar('\n');

} Печатается:

#1 0 b bcd strs[0]="bcd" #2 1 A ABCD strs[1]="ABCD" #3 2 A 0fpx strs[2]="px" #4 2 1 1fpx strs[3]="69" #5 2 1 2fpx strs[4]="hello" #6 2 g gpx strs[5]="iop" #7 3 p 159 px strs[6]="89" #8 4 6 hello #9 5 h hop #10 6 i A #11 6 B 1479 1479 B #12 6 2 479 #13 6 7 89 Учтите, что конструкция char *strs[1] = { "hello" };

означает, что в strs[0] содержится указатель на начальный байт безымянного массива, содержащего строку "hello". Этот указатель можно изменять! Попробуйте составить еще подобные примеры из *, ++, ().

2.40. Что печатает программа?

char str[25] = "Hi, ";

char *f(char **s){ int cnt;

for(cnt=0;

**s != '\0';

(*s)++, ++cnt);

return("ny" + (cnt && (*s)[-1] == ' ') + (!cnt));

} void main(void){ char *s = str;

if( *f(&s) == 'y') strcat(s, "dude");

else strcat(s, " dude");

printf("%s\n", str);

} Что она напечатает, если задать char str[25]="Hi,";

или char str[25]="";

2.41. В чем состоит ошибка? (Любимая ошибка начинающих) А. Богатырёв, 1992-96 - 86 - Си в UNIX™ main(){ char *buf;

/* или char buf[];

*/ gets( buf );

printf( "%s\n", buf );

} Ответ: память под строку buf не выделена, указатель buf не проинициализирован и смотрит неизвестно куда. Надо было писать например так:

char buf[80];

или char mem[80], *buf = mem;

Обратите на этот пример особое внимание, поскольку, описав указатель (но никуда его не направив), новички успокаиваются, не заботясь о выделении памяти для хранения данных. Указатель должен указывать на ЧТО-ТО, в чем можно хранить данные, а не "висеть", указывая "пальцем в небо"! Запись информации по "висячему" указателю разрушает память программы и приводит к скорому (но часто не немедленному и потому таинственному) краху.

Вот программа, которая также использует неинициализированный указатель. На машине SPARCstation 20 эта программа убивается операционной системой с диагностикой "Segmentation fault" (SIGSEGV). Это как раз и значит обращение по указателю, указывающему "пальцем в небо".

main(){ int *iptr;

int ival = *iptr;

printf("%d\n", ival);

} 2.42. Для получения строки "Life is life" написана программа:

main(){ char buf[ 60 ];

strcat( buf, "Life " );

strcat( buf, "is " );

strcat( buf, "life" );

printf( "%s\n", buf );

} Что окажется в массиве buf?

Ответ: в начале массива окажется мусор, поскольку автоматический массив не инициализируется байтами '\0', а функция strcat() приписывает строки к концу строки. Для исправления можно написать *buf = '\0';

перед первым strcat()-ом, либо вместо первого strcat()-а написать strcpy( buf, "Life " );

2.43. Составьте макроопределение copystr(s1, s2) для копирования строки s2 в строку s1.

2.44. Составьте макроопределение lenstr(s) для вычисления длины строки.

Многие современные компиляторы сами обращаются с подобными короткими (1-3 оператора) стан дартными функциями как с макросами, то есть при обращении к ним генерят не вызов функции, а подста вляют текст ее тела в место обращения. Это делает объектный код несколько "толще", но зато быстрее. В расширенных диалектах Си и в Си++ компилятору можно предложить обращаться так и с вашей функцией для этого функцию следует объявить как inline (такие функции называются еще "intrinsic").

2.45. Составьте рекурсивную и нерекурсивную версии программы инвертирования (зеркального отображе ния) строки:

abcdef --> fedcba.

2.46. Составьте функцию index(s, t), возвращающую номер первого вхождения символа t в строку s;

если символ t в строку не входит, функция возвращает -1.

Перепишите эту функцию с указателями, чтобы она возвращала указатель на первое вхождение сим вола. Если символ в строке отсутствует - выдавать NULL. В UNIX System-V такая функция называется strchr. Вот возможный ответ:

А. Богатырёв, 1992-96 - 87 - Си в UNIX™ char *strchr(s, c) register char *s, c;

{ while(*s && *s != c) s++;

return *s == c ? s : NULL;

} Заметьте, что p=strchr(s,'\0');

выдает указатель на конец строки. Вот пример использования:

extern char *strchr();

char *s = "abcd/efgh/ijklm";

char *p = strchr(s, '/');

printf("%s\n", p==NULL ? "буквы / нет" : p);

if(p) printf("Индекс вхождения = s[%d]\n", p - s );

2.47. Напишите функцию strrchr(), указывающую на последнее вхождение символа. Ответ:

char *strrchr(s, c) register char *s, c;

{ char *last = NULL;

do if(*s == c) last = s;

while(*s++);

return last;

} Вот пример ее использования:

extern char *strrchr();

char p[] = "wsh";

/* эталон */ main(argc, argv) char *argv[];

{ char *s = argv[1];

/* проверяемое имя */ /* попробуйте вызывать * a.out csh * a.out /bin/csh * a.out wsh * a.out /usr/local/bin/wsh */ char *base = (base = strrchr(s, '/')) ? base+1 : s;

if( !strcmp(p, base)) printf("Да, это %s\n", p);

else printf("Нет, это %s\n", base);

/* еще более изощренный вариант: */ if( !strcmp(p,(base=strrchr(s,'/')) ? ++base :

(base=s)) ) printf("Yes %s\n", p);

else printf("No %s\n", base);

} 2.48. Напишите макрос substr(to,from,n,len) который записывает в to кусок строки from начиная с n-ой позиции и длиной len. Используйте стандартную функцию strncpy.

Ответ:

#define substr(to, from, n, len) strncpy(to, from+n, len) или более корректная функция:

char *substr(to, from, n, len) char *to, *from;

{ int lfrom = strlen(from);

if(n < 0 ){ len += n;

n = 0;

} if(n >= lfrom || len <= 0) *to = '\0';

/* пустая строка */ else{ /* длина остатка строки: */ if(len > lfrom-n) len = lfrom - n;

strncpy(to, from+n, len);

to[len] = '\0';

} return to;

} А. Богатырёв, 1992-96 - 88 - Си в UNIX™ 2.49. Напишите функцию, проверяющую, оканчивается ли строка на ".abc", и если нет - приписывающую ".abc" к концу. Если же строка уже имеет такое окончание - ничего не делать. Эта функция полезна для генерации имен файлов с заданным расширением. Сделайте расширение аргументом функции.

Для сравнения конца строки s со строкой p следует использовать:

int ls = strlen(s), lp = strlen(p);

if(ls >= lp && !strcmp(s+ls-lp, p))...совпали...;

2.50. Напишите функции вставки символа c в указанную позицию строки (с раздвижкой строки) и удаления символа в заданной позиции (со сдвижкой строки). Строка должна изменяться "на месте", т.е. никуда не копируясь. Ответ:

/* удаление */ char delete(s, at) register char *s;

{ char c;

s += at;

if((c = *s) == '\0') return c;

while( s[0] = s[1] ) s++;

return c;

} /* либо просто strcpy(s+at, s+at+1);

*/ /* вставка */ insert(s, at, c) char s[], c;

{ register char *p;

s += at;

p = s;

while(*p) p++;

/* на конец строки */ p[1] = '\0';

/* закрыть строку */ for( ;

p != s;

p-- ) p[0] = p[-1];

*s = c;

} 2.51. Составьте программу удаления символа c из строки s в каждом случае, когда он встречается.

Ответ:

delc(s, c) register char *s;

char c;

{ register char *p = s;

while( *s ) if( *s != c ) *p++ = *s++;

else s++;

*p = '\0';

/* не забывайте закрывать строку ! */ } 2.52. Составьте программу удаления из строки S1 каждого символа, совпадающего с каким-либо симво лом строки S2.

2.53. Составьте функцию scopy(s,t), которая копирует строку s в t, при этом символы табуляции и пере вода строки должны заменяться на специальные двухсимвольные последовательности "\n" и "\t". Исполь зуйте switch.

2.54. Составьте функцию, которая "укорачивает" строку, заменяя изображения спецсимволов (вроде "\n") на сами эти символы ('\n'). Ответ:

extern char *strchr();

void unquote(s) char *s;

{ static char from[] = "nrtfbae", to [] = "\n\r\t\f\b\7\33";

char c, *p, *d;

for(d=s;

c = *s;

s++) if( c == '\\'){ if( !(c = *++s)) break;

А. Богатырёв, 1992-96 - 89 - Си в UNIX™ p = strchr(from, c);

*d++ = p ? to[p - from] : c;

}else *d++ = c;

*d = '\0';

} 2.55. Напишите программу, заменяющую в строке S все вхождения подстроки P на строку Q, например:

P = "ура";

Q = "ой";

S = "ура-ура-ура!";

Результат: "ой-ой-ой!" 2.56. Кроме функций работы со строками (где предполагается, что массив байт завершается признаком конца '\0'), в Си предусмотрены также функции для работы с массивами байт без ограничителя. Для таких функций необходимо явно указывать длину обрабатываемого массива. Напишите функции: пересылки мас сива длиной n байт memcpy(dst,src,n);

заполнения массива символом c memset(s,c,n);

поиска вхождения символа в массив memchr(s,c,n);

сравнения двух массивов memcmp(s1,s2,n);

Ответ:

#define REG register char *memset(s, c, n) REG char *s, c;

{ REG char *p = s;

while( --n >= 0 ) *p++ = c;

return s;

} char *memcpy(dst, src, n) REG char *dst, *src;

REG int n;

{ REG char *d = dst;

while( n-- > 0 ) *d++ = *src++;

return dst;

} char *memchr(s, c, n) REG char *s, c;

{ while(n-- && *s++ != c);

return( n < 0 ? NULL : s-1 );

} int memcmp(s1, s2, n) REG char *s1, *s2;

REG n;

{ while(n-- > 0 && *s1 == *s2) s1++, s2++;

return( n < 0 ? 0 : *s1 - *s2 );

} Есть такие стандартные функции.

2.57. Почему лучше пользоваться стандартными функциями работы со строками и памятью (strcpy, strlen, strchr, memcpy,...)?

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

2.58. Рассмотрим программу, копирующую строку саму в себя:

#include #include char string[] = "abcdefghijklmn";

void main(void){ memcpy(string+2, string, 5);

printf("%s\n", string);

exit(0);

Она печатает abababahijklmn. Мы могли бы ожидать, что кусок длины 5 символов "abcde" будет скопирован как есть: ab[abcde]hijklmn, а получили ab[ababa]hijklmn - циклическое повторение первых двух символов строки... В чем дело? Дело в том, что когда области источника (src) и получателя (dst) перекрываются, то в А. Богатырёв, 1992-96 - 90 - Си в UNIX™ некий момент *src берется из УЖЕ перезаписанной ранее области, то есть испорченной! Вот программа, иллюстрирующая эту проблему:

#include #include #include char string[] = "abcdefghijklmn";

char *src = &string[0];

char *dst = &string[2];

int n = 5;

void show(int niter, char *msg){ register length, i;

printf("#%02d %s\n", niter, msg);

length = src-string;

putchar('\t');

for(i=0;

i < length+3;

i++) putchar(' ');

putchar('S');

putchar('\n');

printf("\t...%s...\n", string);

length = dst-string;

putchar('\t');

for(i=0;

i < length+3;

i++) putchar(' ');

putchar('D');

putchar('\n');

} void main(void){ int iter = 0;

while(n-- > 0){ show(iter, "перед");

*dst++ = toupper(*src++);

show(iter++, "после");

} exit(0);

} Она печатает:

А. Богатырёв, 1992-96 - 91 - Си в UNIX™ #00 перед S...abcdefghijklmn...

D #00 после S...abAdefghijklmn...

D #01 перед S...abAdefghijklmn...

D #01 после S...abABefghijklmn...

D #02 перед S...abABefghijklmn...

D #02 после S...abABAfghijklmn...

D #03 перед S...abABAfghijklmn...

D #03 после S...abABABghijklmn...

D #04 перед S...abABABghijklmn...

D #04 после S...abABABAhijklmn...

D Отрезки НЕ перекрываются, если один из них лежит либо целиком левее, либо целиком правее другого (n длина обоих отрезков).

dst src src dst ######## @@@@@@@@ @@@@@@@@ ######## dst+n <= src или src+n <= dst dst <= src-n или dst >= src+n Отрезки перекрываются в случае ! (dst <= src - n || dst >= src + n) = (dst > src - n && dst < src + n) При этом опасен только случай dst > src. Таким образом опасная ситуация описывается условием src < dst && dst < src + n (если dst==src, то вообще ничего не надо делать). Решением является копирование "от хвоста к голове":

А. Богатырёв, 1992-96 - 92 - Си в UNIX™ void bcopy(register char *src, register char *dst, register int n){ if(dst >= src){ dst += n-1;

src += n-1;

while(--n >= 0) *dst-- = *src--;

}else{ while(n-- > 0) *dst++ = *src++;

} } Или, ограничиваясь только опасным случаем:

void bcopy(register char *src, register char *dst, register int n){ if(dst==src || n <= 0) return;

if(src < dst && dst < src + n) { dst += n-1;

src += n-1;

while(--n >= 0) *dst-- = *src--;

}else memcpy(dst, src, n);

} Программа #include #include #include char string[] = "abcdefghijklmn";

char *src = &string[0];

char *dst = &string[2];

int n = 5;

void show(int niter, char *msg){ register length, i;

printf("#%02d %s\n", niter, msg);

length = src-string;

putchar('\t');

for(i=0;

i < length+3;

i++) putchar(' ');

putchar('S');

putchar('\n');

printf("\t...%s...\n", string);

length = dst-string;

putchar('\t');

for(i=0;

i < length+3;

i++) putchar(' ');

putchar('D');

putchar('\n');

} А. Богатырёв, 1992-96 - 93 - Си в UNIX™ void main(void){ int iter = 0;

if(dst==src || n <= 0){ printf("Ничего не надо делать\n");

return;

} if(src < dst && dst < src + n) { dst += n-1;

src += n-1;

while(--n >= 0){ show(iter, "перед");

*dst-- = toupper(*src--);

show(iter++, "после");

} }else while(n-- > 0){ show(iter, "перед");

*dst++ = toupper(*src++);

show(iter++, "после");

} exit(0);

} Печатает А. Богатырёв, 1992-96 - 94 - Си в UNIX™ #00 перед S...abcdefghijklmn...

D #00 после S...abcdefEhijklmn...

D #01 перед S...abcdefEhijklmn...

D #01 после S...abcdeDEhijklmn...

D #02 перед S...abcdeDEhijklmn...

D #02 после S...abcdCDEhijklmn...

D #03 перед S...abcdCDEhijklmn...

D #03 после S...abcBCDEhijklmn...

D #04 перед S...abcBCDEhijklmn...

D #04 после S...abABCDEhijklmn...

D Теперь bcopy() - удобная функция для копирования и сдвига массивов, в частности массивов указателей.

Пусть у нас есть массив строк (выделенных malloc-ом):

char *lines[NLINES];

Тогда циклическая перестановка строк выглядит так:

void scrollUp(){ char *save = lines[0];

bcopy((char *) lines+1, /* from */ (char *) lines, /* to */ sizeof(char *) * (NLINES-1));

lines[NLINES-1] = save;

} void scrollDown(){ char *save = lines[NLINES-1];

bcopy((char *) &lines[0], /* from */ (char *) &lines[1], /* to */ sizeof(char *) * (NLINES-1));

lines[0] = save;

} Возможно, что написание по аналогии функции для копирования массивов элементов типа (void *) - обоб щенных указателей - может оказаться еще понятнее и эффективнее. Такая функция - memmove - стан дартно существует в UNIX SVR4. Заметьте, что порядок аргументов в ней обратный по отношению к bcopy. Следует отметить, что в SVR4 все функции mem... имеют указатели типа (void *) и счетчик типа size_t - тип для количества байт (вместо unsigned long);

в частности длина файла имеет именно этот тип (смотри системные вызовы lseek и stat).

А. Богатырёв, 1992-96 - 95 - Си в UNIX™ #include void memmove(void *Dst, const void *Src, register size_t n){ register caddr_t src = (caddr_t) Src, dst = (caddr_t) Dst;

if(dst==src || n <= 0) return;

if(src < dst && dst < src + n) { dst += n-1;

src += n-1;

while(--n >= 0) *dst-- = *src--;

}else memcpy(dst, src, n);

} caddr_t - это тип для указателей на БАЙТ, фактически это (unsigned char *). Зачем вообще понадобилось использовать caddr_t? Затем, что для void *pointer;

int n;

значение pointer + n не определено и невычислимо, ибо sizeof(void) не имеет смысла - это не 0, а просто ошибка, диагностиру емая компилятором!

2.59. Еще об опечатках: вот что бывает, когда вместо знака `=' печатается `-' (на клавиатуре они находятся рядом...).

#include #include char *strdup(const char *s){ extern void *malloc();

return strcpy((char *)malloc(strlen(s)+1), s);

} char *ptr;

void main(int ac, char *av[]){ ptr - strdup("hello");

/* подразумевалось ptr =... */ *ptr = 'H';

printf("%s\n", ptr);

free(ptr);

exit(0);

} Дело в том, что запись (а часто и чтение) по *pointer, где pointer==NULL, приводит к аварийному прекраще нию программы. В нашей программе ptr осталось равным NULL - указателем в никуда. В операционной системе UNIX на машинах с аппаратной защитой памяти, страница памяти, содержащая адрес NULL (0) бывает закрыта на запись, поэтому любое обращение по записи в эту страницу вызывает прерывание от диспетчера памяти и аварийное прекращение процесса. Система сама помогает ловить ваши ошибки (но уже во время выполнения программы). Это ОЧЕНЬ частая ошибка - запись по адресу NULL. MS DOS в таких случаях предпочитает просто зависнуть, и вы бываете вынуждены играть аккорд из трех клавиш Ctrl/Alt/Del, так и не поняв в чем дело.

2.60. Раз уж речь зашла о функции strdup (кстати, это стандартная функция), приведем еще одну функцию для сохранения строк.

А. Богатырёв, 1992-96 - 96 - Си в UNIX™ char *savefromto(register char *from, char *upto) { char *ptr, *s;

if((ptr = (char *) malloc(upto - from + 1)) == NULL) return NULL;

for(s = ptr;

from < upto;

from++) *s++ = *from;

*s = '\0';

return ptr;

} Сам символ (*upto) не сохраняется, а заменяется на '\0'.

2.61. Упрощенный аналог функции printf.

/* * Машинно - независимый printf() (упрощенный вариант).

* printf - Форматный Вывод.

*/ #include #include #include #include #include extern int errno;

/* код системной ошибки, формат %m */ /* чтение значения числа */ #define GETN(n,fmt) \ n = 0;

\ while(isdigit(*fmt)){ \ n = n*10 + (*fmt - '0');

\ fmt++;

\ } А. Богатырёв, 1992-96 - 97 - Си в UNIX™ void myprintf(fmt, va_alist) register char *fmt;

va_dcl { va_list ap;

char c, *s;

int i;

int width, /* минимальная ширина поля */ prec, /* макс. длина данного */ sign, /* выравнивание: 1 - вправо, -1 - влево */ zero, /* ширина поля начинается с 0 */ glong;

/* требуется длинное целое */ va_start(ap);

for(;

;

){ while((c = *fmt++) != '%'){ if( c == '\0' ) goto out;

putchar(c);

} sign = 1;

zero = 0;

glong = 0;

if(*fmt == '-'){ sign = (-1);

fmt++;

} if(*fmt == '0'){ zero = 1;

fmt++;

} if(*fmt == '*'){ width = va_arg(ap, int);

if(width < 0){ width = -width;

sign = -sign;

} fmt++;

}else{ GETN(width, fmt);

} width *= sign;

if(*fmt == '.'){ if(*++fmt == '*'){ prec = va_arg(ap, int);

fmt++;

}else{ GETN(prec, fmt);

} }else prec = (-1);

/* произвольно */ if( *fmt == 'l' ){ glong = 1;

fmt++;

} А. Богатырёв, 1992-96 - 98 - Си в UNIX™ switch(c = *fmt++){ case 'c':

putchar(va_arg(ap, int));

break;

case 's':

prStr(width, prec, va_arg(ap, char *));

break;

case 'm':

prStr(width, prec, strerror(errno));

break;

/* strerror преобразует код ошибки в строку-расшифровку */ case 'u':

prUnsigned(width, glong ? va_arg(ap, unsigned long) :

(unsigned long) va_arg(ap, unsigned int), 10 /* base */, zero);

break;

case 'd':

prInteger(width, glong ? va_arg(ap, long) : (long) va_arg(ap, int), 10 /* base */, zero);

break;

case 'o':

prUnsigned(width, glong ? va_arg(ap, unsigned long) :

(unsigned long) va_arg(ap, unsigned int), 8 /* base */, zero);

break;

case 'x':

prUnsigned(width, glong ? va_arg(ap, unsigned long) :

(unsigned long) va_arg(ap, unsigned int), 16 /* base */, zero);

break;

case 'X':

prUnsigned(width, glong ? va_arg(ap, unsigned long) :

(unsigned long) va_arg(ap, unsigned int), -16 /* base */, zero);

break;

case 'b':

prUnsigned(width, glong ? va_arg(ap, unsigned long) :

(unsigned long) va_arg(ap, unsigned int), 2 /* base */, zero);

break;

case 'a': /* address */ prUnsigned(width, (long) (char *) va_arg(ap, char *), 16 /* base */, zero);

break;

case 'A': /* address */ prUnsigned(width, (long) (char *) va_arg(ap, char *), -16 /* base */, zero);

break;

case 'r':

prRoman(width, prec, va_arg(ap, int));

break;

case '%':

putchar('%');

break;

default:

putchar(c);

break;

} } out:

va_end(ap);

} /* --------------------------------------------------------- */ int strnlen(s, maxlen) char *s;

{ register n;

for( n=0;

*s && n < maxlen;

n++, s++ );

return n;

} А. Богатырёв, 1992-96 - 99 - Си в UNIX™ /* Печать строки */ static prStr(width, prec, s) char *s;

{ int ln;

/* сколько символов выводить */ int toLeft = 0;

/* к какому краю прижимать */ if(s == NULL){ pr( "(NULL)", 6);

return;

} /* Измерить длину и обрубить длинную строку.

* Дело в том, что строка может не иметь \0 на конце, тогда * strlen(s) может привести к обращению в запрещенные адреса */ ln = (prec > 0 ? strnlen(s, prec) : strlen(s));

/* ширина поля */ if( ! width ) width = (prec > 0 ? prec : ln);

if( width < 0){ width = -width;

toLeft = 1;

} if( width > ln){ /* дополнить поле пробелами */ if(toLeft){ pr(s, ln);

prSpace(width - ln, ' ');

} else { prSpace(width - ln, ' ');

pr(s, ln);

} } else { pr(s, ln);

} } /* Печать строки длиной l */ static pr(s, ln) register char *s;

register ln;

{ for( ;

ln > 0 ;

ln-- ) putchar( *s++ );

} /* Печать n символов c */ static prSpace(n, c) register n;

char c;

{ for( ;

n > 0 ;

n-- ) putchar( c );

} /* --------------------------------------------------------- */ static char *ds;

/* Римские цифры */ static prRoman(w,p,n){ char bd[60];

ds = bd;

if( n < 0 ){ n = -n;

*ds++ = '-';

} prRdig(n,6);

*ds = '\0';

prStr(w, p, bd);

} static prRdig(n, d){ if( !n ) return;

if( d ) prRdig( n/10, d - 2);

tack(n%10, d);

} А. Богатырёв, 1992-96 - 100 - Си в UNIX™ static tack(n, d){ static char im[] = " MDCLXVI";

/*..1000 500 100 50 10 5 1 */ if( !n ) return;

if( 1 <= n && n <= 3 ){ repeat(n, im[d+2]);

return;

} if( n == 4 ) *ds++ = im[d+2];

if( n == 4 || n == 5 ){ *ds++ = im[d+1];

return;

} if( 6 <= n && n <= 8 ){ *ds++ = im[d+1];

repeat(n - 5, im[d+2] );

return;

} /* n == 9 */ *ds++ = im[d+2];

*ds++ = im[d];

} static repeat(n, c) char c;

{ while( n-- > 0 ) *ds++ = c;

} /* --------------------------------------------------------- */ static char aChar = 'A';

static prInteger(w, n, base, zero) long n;

{ /* преобразуем число в строку */ char bd[128];

int neg = 0;

/* < 0 */ if( n < 0 ){ neg = 1;

n = -n;

} if( base < 0 ){ base = -base;

aChar = 'A';

} else { aChar = 'a';

} ds = bd;

prUDig( n, base );

*ds = '\0';

/* Теперь печатаем строку */ prIntStr( bd, w, zero, neg );

} static prUnsigned(w, n, base, zero) unsigned long n;

{ char bd[128];

if( base < 0 ){ base = -base;

aChar = 'A';

} else { aChar = 'a';

} ds = bd;

prUDig( n, base );

*ds = '\0';

/* Теперь печатаем строку */ prIntStr( bd, w, zero, 0 );

} static prUDig( n, base ) unsigned long n;

{ unsigned long aSign;

if((aSign = n/base ) > 0 ) prUDig( aSign, base );

aSign = n % base;

*ds++ = (aSign < 10 ? '0' + aSign : aChar + (aSign - 10));

} А. Богатырёв, 1992-96 - 101 - Си в UNIX™ static prIntStr( s, width, zero, neg ) char *s;

{ int ln;

/* сколько символов выводить */ int toLeft = 0;

/* к какому краю прижимать */ ln = strlen(s);

/* длина строки s */ /* Ширина поля: вычислить, если не указано явно */ if( ! width ){ width = ln;

/* ширина поля */ if( neg ) width++;

/* 1 символ для минуса */ } if( width < 0 ){ width = -width;

toLeft = 1;

} if( ! neg ){ /* Положительное число */ if(width > ln){ if(toLeft){ pr(s, ln);

prSpace(width - ln, ' ');

} else { prSpace(width - ln, zero ? '0' : ' ');

pr(s, ln);

} } else { pr(s, ln);

} }else{ /* Отрицательное число */ if(width > ln){ /* Надо заполнять оставшуюся часть поля */ width -- ;

/* width содержит одну позицию для минуса */ if(toLeft){ putchar('-');

pr(s, ln);

prSpace(width - ln, ' ');

} else{ if( ! zero ){ prSpace(width - ln, ' ');

putchar('-');

pr(s,ln);

} else { putchar('-');

prSpace(width - ln, '0');

pr(s, ln);

} } } else { putchar('-');

pr(s, ln);

} } } А. Богатырёв, 1992-96 - 102 - Си в UNIX™ /* --------------------------------------------------------- */ main(){ int i, n;

static char s[] = "Hello, world!\n";

static char p[] = "Hello, world";

long t = 7654321L;

myprintf( "%%abc%Y\n");

myprintf( "%s\n", "abs" );

myprintf( "%5s|\n", "abs" );

myprintf( "%-5s|\n", "abs" );

myprintf( "%5s|\n", "xyzXYZ" );

myprintf( "%-5s|\n", "xyzXYZ" );

myprintf( "%5.5s|\n", "xyzXYZ" );

myprintf( "%-5.5s|\n", "xyzXYZ" );

myprintf( "%r\n", 444 );

myprintf( "%r\n", 999 );

myprintf( "%r\n", 16 );

myprintf( "%r\n", 18 );

myprintf( "%r\n", 479 );

myprintf( "%d\n", 1234 );

myprintf( "%d\n", -1234 );

myprintf( "%ld\n", 97487483 );

myprintf( "%2d|%2d|\n", 1, -3 );

myprintf( "%-2d|%-2d|\n", 1, -3 );

myprintf( "%02d|%2d|\n", 1, -3 );

myprintf( "%-02d|%-2d|\n", 1, -3 );

myprintf( "%5d|\n", -12 );

myprintf( "%05d|\n", -12 );

myprintf( "%-5d|\n", -12 );

myprintf( "%-05d|\n", -12 );

for( i = -6;

i < 6;

i++ ) myprintf( "width=%2d|%0*d|%0*d|%*d|%*d|\n", i, i, 123, i, -123, i, 123, i, -123);

myprintf( "%s at location %a\n", s, s );

myprintf( "%ld\n", t );

n = 1;

t = 1L;

for( i=0;

i < 34;

i++ ){ myprintf( "for %2d |%016b|%d|%u|\n\t |%032lb|%ld|%lu|\n", i, n, n, n, t, t, t );

n *= 2;

t *= 2;

} myprintf( "%8x %8X\n", 7777, 7777 );

myprintf( "|%s|\n", p );

myprintf( "|%10s|\n", p );

myprintf( "|%-10s|\n", p );

myprintf( "|%20s|\n", p );

myprintf( "|%-20s|\n", p );

myprintf( "|%20.10s|\n", p );

myprintf( "|%-20.10s|\n", p );

myprintf( "|%.10s|\n", p );

} А. Богатырёв, 1992-96 - 103 - Си в UNIX™ Выдача этой программы:

%abcY abs abs| abs | xyzXYZ| xyzXYZ| xyzXY| xyzXY| CDXLIV CMXCIX XVI XVIII CDLXXIX - 1|-3| 1 |-3| 01|-3| 1 |-3| -12| -0012| -12 | -12 | width=-6|123 |-123 |123 |-123 | width=-5|123 |-123 |123 |-123 | width=-4|123 |-123|123 |-123| width=-3|123|-123|123|-123| width=-2|123|-123|123|-123| width=-1|123|-123|123|-123| width= 0|123|-123|123|-123| width= 1|123|-123|123|-123| width= 2|123|-123|123|-123| width= 3|123|-123|123|-123| width= 4|0123|-123| 123|-123| width= 5|00123|-0123| 123| -123| Hello, world!

at location for 0 |0000000000000001|1|1| |00000000000000000000000000000001|1|1| for 1 |0000000000000010|2|2| |00000000000000000000000000000010|2|2| for 2 |0000000000000100|4|4| |00000000000000000000000000000100|4|4| for 3 |0000000000001000|8|8| |00000000000000000000000000001000|8|8| for 4 |0000000000010000|16|16| |00000000000000000000000000010000|16|16| for 5 |0000000000100000|32|32| |00000000000000000000000000100000|32|32| for 6 |0000000001000000|64|64| |00000000000000000000000001000000|64|64| for 7 |0000000010000000|128|128| |00000000000000000000000010000000|128|128| for 8 |0000000100000000|256|256| |00000000000000000000000100000000|256|256| for 9 |0000001000000000|512|512| |00000000000000000000001000000000|512|512| for 10 |0000010000000000|1024|1024| |00000000000000000000010000000000|1024|1024| for 11 |0000100000000000|2048|2048| |00000000000000000000100000000000|2048|2048| for 12 |0001000000000000|4096|4096| |00000000000000000001000000000000|4096|4096| А. Богатырёв, 1992-96 - 104 - Си в UNIX™ for 13 |0010000000000000|8192|8192| |00000000000000000010000000000000|8192|8192| for 14 |0100000000000000|16384|16384| |00000000000000000100000000000000|16384|16384| for 15 |1000000000000000|32768|32768| |00000000000000001000000000000000|32768|32768| for 16 |10000000000000000|65536|65536| |00000000000000010000000000000000|65536|65536| for 17 |100000000000000000|131072|131072| |00000000000000100000000000000000|131072|131072| for 18 |1000000000000000000|262144|262144| |00000000000001000000000000000000|262144|262144| for 19 |10000000000000000000|524288|524288| |00000000000010000000000000000000|524288|524288| for 20 |100000000000000000000|1048576|1048576| |00000000000100000000000000000000|1048576|1048576| for 21 |1000000000000000000000|2097152|2097152| |00000000001000000000000000000000|2097152|2097152| for 22 |10000000000000000000000|4194304|4194304| |00000000010000000000000000000000|4194304|4194304| for 23 |100000000000000000000000|8388608|8388608| |00000000100000000000000000000000|8388608|8388608| for 24 |1000000000000000000000000|16777216|16777216| |00000001000000000000000000000000|16777216|16777216| for 25 |10000000000000000000000000|33554432|33554432| |00000010000000000000000000000000|33554432|33554432| for 26 |100000000000000000000000000|67108864|67108864| |00000100000000000000000000000000|67108864|67108864| for 27 |1000000000000000000000000000|134217728|134217728| |00001000000000000000000000000000|134217728|134217728| for 28 |10000000000000000000000000000|268435456|268435456| |00010000000000000000000000000000|268435456|268435456| for 29 |100000000000000000000000000000|536870912|536870912| |00100000000000000000000000000000|536870912|536870912| for 30 |1000000000000000000000000000000|1073741824|1073741824| |01000000000000000000000000000000|1073741824|1073741824| for 31 |10000000000000000000000000000000|-2147483648|2147483648| |10000000000000000000000000000000|-2147483648|2147483648| for 32 |0000000000000000|0|0| |00000000000000000000000000000000|0|0| for 33 |0000000000000000|0|0| |00000000000000000000000000000000|0|0| 1e61 1E |Hello, world| |Hello, world| |Hello, world| | Hello, world| |Hello, world | | Hello, wor| |Hello, wor | |Hello, wor| 2.62. Рассмотрим программу суммирования векторов:

int A[1024], B[1024], C[1024];

...

for(i=0;

i < 1024;

i++) C[i] = A[i] + B[i];

А почему бы не for(i=1024-1;

i >=0 ;

--i)...;

А почему бы не в произвольном порядке?

foreach i in (0..1023)...;

Данный пример показывает, что некоторые операции обладают врожденным паралеллизмом, ведь все сложений можно было бы выполнять параллельно! Однако тупой компилятор будет складывать их именно в том порядке, в котором вы ему велели. Только самые современные компиляторы на многопроцессорных А. Богатырёв, 1992-96 - 105 - Си в UNIX™ системах умеют автоматически распараллеливать такие циклы. Сам язык Си не содержит средств указания параллельности (разве что снова - библиотеки и системные вызовы для этого).

А. Богатырёв, 1992-96 - 106 - Си в UNIX™ 3. Мобильность и машинная зависимость программ. Проблемы с русскими буквами.

Программа считается мобильной, если она без каких-либо изменений ее исходного текста (либо после настройки некоторых констант при помощи #define и #ifdef) транслируется и работает на разных типах машин (с разной разрядностью, системой команд, архитектурой, периферией) под управлением опе рационных систем одного семейства. Заметим, что мобильными могут быть только исходные тексты про грамм, объектные модули для разных процессоров, естественно, несовместимы!

3.1. Напишите программу, печатающую размер типов данных char, short, int, long, float, double, (char *) в байтах. Используйте для этого встроенную операцию sizeof.

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

1) Наибольшее допустимое знаковое целое.

2) Наибольшее беззнаковое целое.

3) Наибольшее по абсолютной величине отрицательное целое.

4) Точность значения |x|, отличающегося от 0, где x - вещественное число.

5) Наименьшее значение e, такое что машина различает числа 1 и 1+e (для вещественных чисел).

3.3. Составьте мобильную программу, выясняющую длину машинного слова ЭВМ (число битов в перемен ной типа int). Указание: для этого можно использовать битовые сдвиги.

3.4. Надо ли писать в своих программах определения #define EOF (-1) #define NULL ((char *) 0) /* или ((void *)0) */ Ответ: НЕТ. Во-первых, эти константы уже определены в include-файле, подключаемом по директиве #include поэтому правильнее написать именно эту директиву. Во-вторых, это было бы просто неправильно: конкрет ные значения этих констант на данной машине (в данной реализации системы) могут быть другими! Чтобы придерживаться тех соглашений, которых придерживаются все стандартные функции данной реализации, вы ДОЛЖНЫ брать эти константы из .

По той же причине следует писать #include int fd = open( имяФайла, O_RDONLY);

/* O_WRONLY, O_RDWR */ вместо int fd = open( имяФайла, 0);

/* 1, 2 */ 3.5. Почему может завершаться по защите памяти следующая программа?

#include #include time_t t;

extern time_t time();

...

t = time(0);

/* узнать текущее время в секундах с 1 Янв. 1970 г.*/ Ответ: дело в том, что прототип системного вызова time() это:

time_t time( time_t *t );

то есть аргумент должен быть указателем. Мы же вместо указателя написали в качестве аргумента 0 (типа int). На машине IBM PC AT 286 указатель - это 2 слова, а целое - одно. Недостающее слово будет взято из стека произвольно. В результате time() получает в качестве аргумента не нулевой указатель, а мусор.

Правильно будет написать:

t = time(NULL);

либо (по определению time()) time( &t );

а еще более корректно так:

А. Богатырёв, 1992-96 - 107 - Си в UNIX™ t = time((time_t *)NULL);

Мораль: везде, где требуется нулевой указатель, следует писать NULL (или явное приведение нуля к типу указателя), а не просто 0.

3.6. Найдите ошибку:

void f(x, s) long x;

char *s;

{ printf( "%ld %s\n", x, s );

} void main(){ f( 12, "hello" );

} Эта программа работает на IBM PC 386, но не работает на IBM PC 286.

Ответ. Здесь возникает та же проблема, что и в примере про sin(12). Дело в том, что f требует пер вый аргумент типа long (4 байта на IBM PC 286), мы же передаем ей int (2 байта). В итоге в x попадает неверное значение;

но более того, недостающие байты отбираются у следующего аргумента - s. В итоге и адрес строки становится неправильным, программа обращается по несуществующему адресу и падает. На IBM PC 386 и int и long имеют длину 4 байта, поэтому там эта ошибка не проявляется!

Опять-таки, это повод для использования прототипов функций (когда вы прочитаете про них - верни тесь к этому примеру!). Напишите прототип void f(long x, char *s);

и ошибки не будет.

В данном примере мы использовали тип void, которого не сушествовало в ранних версиях языка Си.

Этот тип означает, что функция не возвращает значения (то есть является "процедурой" в смысле языков Pascal или Algol). Если мы не напишем слово void перед f, то компилятор будет считать функцию f возвра щающей целое (int), хотя эта функция ничего не возвращает (в ней нет оператора return). В большинстве случаев это не принесет вреда и программа будет работать. Но зато если мы напишем int x = f((long) 666, "good bye" );

то x получит непредсказуемое значение. Если же f описана как void, то написанный оператор заставит ком пилятор сообщить об ошибке.

Тип (void *) означает указатель на что угодно (понятно, что к такому указателю операции [], *, -> неприменимы: сначала следует явно привести указатель к содержательному типу "указатель на тип"). В частности, сейчас стало принято считать, что функция динамического выделения памяти (memory allocation) malloc() (которая отводит в куче‡ область памяти заказанного размера и выдает указатель на нее) имеет прототип:

void *malloc(unsigned size);

/* size байт */ char *s = (char *) strlen(buf)+1 );

malloc( struct ST *p = (struct ST *) malloc( sizeof(struct ST));

/* или sizeof(*p) */ хотя раньше принято было char *malloc();

3.7. Поговорим про оператор sizeof. Отметим распространенную ошибку, когда sizeof принимают за функцию. Это не так! sizeof вычисляется компилятором при трансляции программы, а не программой во время выполнения. Пусть char a[] = "abcdefg";

char *b = "hijklmn";

Тогда есть 8 (байт \0 на конце - считается) sizeof(a) есть 2 на PDP-11 (размер указателя) sizeof(b) есть strlen(a) есть strlen(b) Если мы сделаем ‡ "Куча" (heap, pool) - область статической памяти, увеличивающаяся по мере надобности, и предна значенная как раз для хранения динамически отведенных данных.

А. Богатырёв, 1992-96 - 108 - Си в UNIX™ b = "This ia a new line";

strcpy(a, "abc");

то все равно sizeof(b) останется равно sizeof(a) Таким образом sizeof выдает количество зарезервированной для переменной памяти (в байтах), незави симо от текущего ее содержимого.

Операция sizeof применима даже к выражениям. В этом случае она сообщает нам, каков будет раз мер у результата этого выражения. Само выражение при этом не вычисляется, так в double f(){ printf( "Hi!\n");

return 12.34;

} main(){ int x = 2;

long y = 4;

printf( "%u\n", sizeof(x + y + f()));

} будет напечатано значение, совпадающее с sizeof(double), а фраза "Hi!" не будет напечатана.

Когда оператор sizeof применяется к переменной (а не к имени типа), можно не писать круглые скобки:

но sizeof(char *);

sizeof x;

3.8. Напишите объединение, в котором может храниться либо указатель, либо целое, либо действительное число. Ответ:

union all{ char *s;

int i;

double f;

} x;

x.i = 12 ;

printf("%d\n", x.i);

x.f = 3.14;

printf("%f\n", x.f);

x.s = "Hi, there";

printf("%s\n", x.s);

printf("int=%d double=%d (char *)=%d all=%d\n", sizeof(int), sizeof(double), sizeof(char *), sizeof x);

В данном примере вы обнаружите, что размер переменной x равен максимальному из размеров типов int, double, char *.

Если вы хотите использовать одну и ту же переменную для хранения данных разных типов, то для получения мобильной программы вы должны пользоваться только объединениями и никогда не привязы ваться к длине слова и представлению этих типов данных на конкретной ЗВМ! Раньше, когда программисты не думали о мобильности, они писали программы, где в одной переменой типа int хранили в зависимости от нужды то целые значения, то указатели (это было на машинах PDP и VAX). Увы, такие программы оказа лись непереносимы на машины, на которых sizeof(int) != sizeof(char *), более того, они оказались весьма туманны для понимания их другими людьми. Не следуйте этому стилю (такой стиль американцы называют "poor style"), более того, всеми силами избегайте его!

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

/* СТИЛЬ ПЕРВЫЙ: ЯВНЫЕ ПРЕОБРАЗОВАНИЯ ТИПОВ */ typedef void *PTR;

/* универсальный указатель */ struct a { int x, y;

PTR pa;

} A;

struct b { double u, v;

PTR pb;

} B;

#define Aptr(p) ((struct a *)(p)) #define Bptr(p) ((struct b *)(p)) PTR ptr1, ptr2;

main(){ ptr1 = &A;

ptr2 = &B;

Bptr(ptr2)->u = Aptr(ptr1)->x = 77;

printf("%f %d\n", B.u, A.x);

} /* СТИЛЬ ВТОРОЙ: ОБ'ЕДИНЕНИЕ */ /* предварительное объявление: */ extern struct a;

extern struct b;

/* универсальный тип данных: */ typedef union everything { А. Богатырёв, 1992-96 - 109 - Си в UNIX™ int i;

double d;

char *s;

struct a *ap;

struct b *bp;

} ALL;

struct a { int x, y;

ALL pa;

} A;

struct b { double u, v;

ALL pb;

} B;

ALL ptr1, ptr2, zz;

main(){ ptr1.ap = &A;

ptr2.bp = &B;

zz.i = 77;

ptr2.bp->u = ptr1.ap->x = zz.i;

printf("%f %d\n", B.u, A.x);

} 3.9. Для выделения классов символов (например цифр), следует пользоваться макросами из include-файла Так вместо if( '0' <= c && c <= '9' )...

следует использовать #include .....

if(isdigit(c))...

и вместо if((c >='a' && c <= 'z') || (c >= 'A' && c <= 'Z'))...

надо if(isalpha(c))...

Дело в том, что сравнения < и > зависят от расположения букв в используемой кодировке. Но например, в кодировке КОИ-8 русские буквы расположены НЕ в алфавитном порядке. Вследствие этого, если для char c1, c2;

c1 < c то это еще не значит, что буква c1 предшествует букве c2 в алфавите! Лексикографическое сравнение тре бует специальной перекодировки букв к "упорядоченной" кодировке.

Аналогично, сравнение if( c >= 'а' && c <= 'я' ) скорее всего не даст ожидаемого результата. Макроопределения же в используют массив фла гов для каждой буквы кодировки, и потому не зависят от порядка букв (и работают быстрее). Идея реализа ции такова:

extern unsigned char _ctype[];

/*массив флагов*/ #define US(c) (sizeof(c)==sizeof(char)?((c)&0xFF):(c)) /* подавление расширения знакового бита */ /* Ф Л А Г И */ #define _U 01 /* uppercase: большая буква */ #define _L 02 /* lowercase: малая буква */ #define _N 04 /* number: цифра */ #define _S 010 /* space: пробел */ /*... есть и другие флаги... */ #define isalpha(c) ((_ctype+1)[US(c)] & (_U|_L) ) #define isupper(c) ((_ctype+1)[US(c)] & _U ) #define islower(c) ((_ctype+1)[US(c)] & _L ) #define isdigit(c) ((_ctype+1)[US(c)] & _N ) #define isalnum(c) ((_ctype+1)[US(c)] & (_U|_L|_N)) #define tolower(c) ((c) + 'a' - 'A' ) #define toupper(c) ((c) + 'A' - 'a' ) где массив _ctype[] заполнен заранее (это проинициализированные статические данные) и хранится в стан дартной библиотеке Си. Вот его фрагмент:

А. Богатырёв, 1992-96 - 110 - Си в UNIX™ unsigned char _ctype[256 /* размер алфавита */ + 1] = { /* EOF код (-1) */ 0,...

/* '1' код 061 0x31 */ _N,...

/* 'A' код 0101 0x41 */ _U,...

/* 'a' код 0141 0x61 */ _L,...

};

Выигрыш в скорости получается вот почему: если мы определим† #define isalpha(c) (((c) >= 'a' && (c) <= 'z') || \ ((c) >= 'A' && (c) <= 'Z')) то этот оператор состоит из 7 операций. Если же мы используем isalpha из (как определено выше) - мы используем только две операции: индексацию и проверку битовой маски &. Операции _ctype+ и _U|_L вычисляются до констант еще при компиляции, и поэтому не вызывают генерации машинных команд.

Определенные выше toupper и tolower работают верно лишь в кодировке ASCII‡, в которой все латинские буквы расположены подряд и по алфавиту. Обратите внимание, что tolower имеет смысл приме нять только к большим буквам, а toupper - только к маленьким:

if( isupper(c) ) c = tolower(c);

Существует еще черезвычайно полезный макрос isspace(c), который можно было бы определить как #define isspace(c) (c==' ' ||c=='\t'||c=='\f'|| \ c=='\n'||c=='\r') или #define isspace(c) (strchr(" \t\f\n\r",(c)) != NULL) На самом деле он, конечно, реализован через флаги в _ctype[]. Он используется для определения симво лов-пробелов, служащих заполнителями промежутков между словами текста.

Есть еще два нередко используемых макроса: isprint(c), проверяющий, является ли c ПЕЧАТНЫМ символом, т.е. имеющим изображение на экране;

и iscntrl(c), означающий, что символ c является управля ющим, т.е. при его выводе на терминал ничего не изобразится, но терминал произведет некоторое дей ствие, вроде очистки экрана или перемещения курсора в каком-то направлении. Они нужны, как правило, для отображения управляющих ("контроловских") символов в специальном печатном виде, вроде ^A для кода '\01'.

Задание: исследуйте кодировку и на вашей машине. Напишите функцию лексикографиче ского сравнения букв и строк.

Указание: пусть буквы имеют такие коды (это не соответствует реальности!):

буква: а б в г д е код: 1 4 2 5 3 нужно: 0 1 2 3 4 Тогда идея функции Ctou перекодировки к упорядоченному алфавиту такова:

unsigned char UU[] = { 5, 0, 2, 4, 1, 3 };

/* в действительности - 256 элементов: UU[256] */ Ctou(c) unsigned char c;

{ return UU[c];

} int strcmp(s1, s2) char *s1, *s2;

{ /* Проигнорировать совпадающие начала строк */ while(*s1 && *s1 == *s2) s1++, s2++;

/* Вернуть разность [не]совпавших символов */ return Ctou(*s1) - Ctou(*s2);

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

‡ ASCII - American Standard Code for Information Interchange - наиболее распространенная в мире ко дировка (Американский стандарт).

А. Богатырёв, 1992-96 - 111 - Си в UNIX™ Разберитесь с принципом формирования массива UU.

3.10. В современных UNIX-ах с поддержкой различных языков таблица ctype загружается из некоторых системных файлов - для каждого языка своя. Для какого языка - выбирается по содержимому переменной окружения LANG. Если переменная не задана - используется значение "C", английский язык. Загрузка таблиц должна происходить явно, вызовом...

#include ...

main(){ setlocale(LC_ALL, "");

...

все остальное...

} 3.11. Вернемся к нашей любимой проблеме со знаковым битом у типа char.

#include #include #include int main(int ac, char *av[]){ char c;

char *string = "абвгдежзиклмноп";

setlocale(LC_ALL, "");

for(;

c = *string;

string++){ #ifdef DEBUG printf("%c %d %d\n", *string, *string, c);

#endif if(isprint(c)) printf("%c - печатный символ\n", c);

} return 0;

} Эта программа неожиданно печатает % a.out в - печатный символ з - печатный символ И все. В чем дело???

Рассмотрим к примеру символ 'г'. Его код '\307'. В операторе c = *string;

Символ c получает значение -57 (десятичное), которое ОТРИЦАТЕЛЬНО. В системном файле /usr/include/ctype.h макрос isprint определен так:

#define isprint(c) ((_ctype + 1)[c] & (_P|_U|_L|_N|_B)) И значение c используется в нашем случае как отрицательный индекс в массиве, ибо индекс приводится к типу int (signed). Откуда теперь извлекается значение флагов - нам неизвестно;

можно только с уверенно стью сказать, что НЕ из массива _ctype.

Проблему решает либо использование isprint(c & 0xFF) либо isprint((unsigned char) c) либо объявление в нашем примере unsigned char c;

В первом случае мы явно приводим signed к unsigned битовой операцией, обнуляя лишние биты. Во вто ром и третьем - unsigned char расширяется в unsigned int, который останется положительным. Вероятно, второй путь предпочтительнее.

А. Богатырёв, 1992-96 - 112 - Си в UNIX™ 3.12. Итак, снова напомним, что русские буквы char, а не unsigned char дают отрицательные индексы в массиве.

char c = 'г';

int x[256];

...x[c]... /* индекс < 0 */...x['г']...

Поэтому байтовые индексы должны быть либо unsigned char, либо & 0xFF. Как в следующем примере:

/* Программа преобразования символов в файле: транслитерация tr abcd prst заменяет строки xxxxdbcaxxxx -> xxxxtrspxxxx По мотивам книги М.Дансмура и Г.Дейвиса.

*/ #include #define ASCII 256 /* число букв в алфавите ASCII */ /* BUFSIZ определено в stdio.h */ char mt[ ASCII ];

/* таблица перекодировки */ /* начальная разметка таблицы */ void mtinit(){ register int i;

for( i=0;

i < ASCII;

i++ ) mt[i] = (char) i;

} int main(int argc, char *argv[]) { register char *tin, *tout;

/* unsigned char */ char buffer[ BUFSIZ ];

if( argc != 3 ){ fprintf( stderr, "Вызов: %s что наЧто\n", argv[0] );

return(1);

} tin = argv[1];

tout = argv[2];

if( strlen(tin) != strlen(tout)){ fprintf( stderr, "строки разной длины\n" );

return(2);

} mtinit();

do{ mt[ (*tin++) & 0xFF ] = *tout++;

/* *tin - имеет тип char.

* & 0xFF подавляет расширение знака */ } while( *tin );

tout = mt;

while( fgets( buffer, BUFSIZ, stdin ) != NULL ){ for( tin = buffer;

*tin;

tin++ ) *tin = tout[ *tin & 0xFF ];

fputs( buffer, stdout );

} return(0);

} 3.13.

А. Богатырёв, 1992-96 - 113 - Си в UNIX™ int main(int ac, char *av[]){ char c = 'г';

if('a' <= c && c < 256) printf("Это одна буква.\n");

return 0;

} Увы, эта программа не печатает НИЧЕГО. Просто потому, что signed char в сравнении (в операторе if) при водится к типу int. А как целое число - русская буква отрицательна. Снова решением является либо использование везде (c & 0xFF), либо объявление unsigned char c. В частности, этот пример показывает, что НЕЛЬЗЯ просто так сравнивать две переменные типа char. Нужно принимать предохранительные меры по подавлению расширения знака:

if((ch1 & 0xFF) < (ch2 & 0xFF))...;

Для unsigned char такой проблемы не будет.

3.14. Почему неверно:

#include main(){ char c;

while((c = getchar()) != EOF) putchar(c);

} Потому что c описано как char, в то время как EOF - значение типа int равное (-1).

Русская буква "Большой твердый знак" в кодировке КОИ-8 имеет код '\377' (0xFF). Если мы подадим на вход этой программе эту букву, то в сравнении signed char со значением знакового целого EOF, c будет приведено тоже к знаковому целому - расширением знака. 0xFF превратится в (-1), что означает, что посту пил символ EOF. Сюрприз!!! Посему данная программа будет делать вид, что в любом файле с большим русским твердым знаком после этого знака (и включая его) дальше ничего нет. Что есть досадное заблу ждение.

Решением служит ПРАВИЛЬНОЕ объявление int c.

3.15. Изучите поведение программы #define TYPE char void f(TYPE c){ if(c == 'й') printf("Это буква й\n");

printf("c=%c c=\\%03o c=%03d c=0x%0X\n", c, c, c, c);

} int main(){ f('г');

f('й');

f('z');

f('Z');

return 0;

} когда TYPE определено как char, unsigned char, int. Объясните поведение. Выдачи в этих трех случаях таковы (int == 32 бита):

c=г c=\37777777707 c=-57 c=0xFFFFFFC Это буква й c=й c=\37777777712 c=-54 c=0xFFFFFFCA c=z c=\172 c=122 c=0x7A c=Z c=\132 c=090 c=0x5A c=г c=\307 c=199 c=0xC c=й c=\312 c=202 c=0xCA c=z c=\172 c=122 c=0x7A c=Z c=\132 c=090 c=0x5A и снова как 1 случай.

Рассмотрите альтернативу if(c == (unsigned char) 'й') printf("Это буква й\n");

А. Богатырёв, 1992-96 - 114 - Си в UNIX™ где предполагается, что знак у русских букв и у c НЕ расширяется. В данном случае фраза 'Это буква й' не печатается ни с типом char, ни с типом int, поскольку в сравнении c приводится к типу signed int расшире нием знакового бита (который равен 1). Слева получается отрицательное число!

В таких случаях вновь следует писать if((unsigned char)c == (unsigned char)'й') printf("Это буква й\n");

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

#include #include void trace(char *fmt,...) { va_list args;

static FILE *fp = NULL;

if(fp == NULL){ if((fp = fopen("TRACE", "w")) == NULL) return;

} va_start(args, fmt);

/* второй аргумент: арг-т после которого * в заголовке функции идет... */ vfprintf(fp, fmt, args);

/* библиотечная ф-ция */ fflush(fp);

/* вытолкнуть сообщение в файл */ va_end(args);

} main(){ trace( "%s\n", "Go home.");

trace( "%d %d\n", 12, 34);

} Символ `...' (троеточие) в заголовке функции обозначает переменный (возможно пустой) список аргументов.

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

Макрос va_arg(args,type), извлекающий из переменного списка аргументов `...' очередное значение типа type, одинаков в обоех моделях. Функция vfprintf может быть написана через функцию vsprintf (в действительности обе функции - стандартные):

int vfprintf(FILE *fp, const char *fmt, va_list args){ /*static*/ char buffer[1024];

int res;

res = vsprintf(buffer, fmt, args);

fputs(buffer, fp);

return res;

} Функция vsprintf(str,fmt,args);

аналогична функции sprintf(str,fmt,...) - записывает преобразованную по фор мату строку в байтовый массив str, но используется в контексте, подобном приведенному. В конец сформи рованной строки sprintf записывает '\0'.

3.17. Напишите функцию printf, понимающую форматы %c (буква), %d (целое), %o (восьмеричное), %x (шестнадцатеричное), %b (двоичное), %r (римское), %s (строка), %ld (длинное целое). Ответ смотри в при ложении.

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

#ifdef XX... вариант #else... вариант #endif Эта директива препроцессора ведет себя следующим образом: если макрос с именем XX был определен #define XX А. Богатырёв, 1992-96 - 115 - Си в UNIX™ то в программу подставляется вариант1, если же нет - вариант2. Оператор #else не обязателен - при его отсутствии вариант2 пуст. Существует также оператор #ifndef, который подставляет вариант1 если макрос XX не определен. Есть еще и оператор #elif - else if:

#ifdef макро...

#elif макро...

#else...

#endif Определить макрос можно не только при помощи #define, но и при помощи ключа компилятора, так cc -DXX file.c...

соответствует включению в начало файла file.c директивы #define XX А для программы main(){ #ifdef XX printf( "XX = %d\n", XX);

#else printf( "XX undefined\n");

#endif } ключ cc -D"XX=2" file.c...

эквивалентен заданию директивы #define XX Что будет, если совсем не задать ключ -D в данном примере?

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

cc -Dvoid=int...

cc -Dstrchr=index...

В некоторых системах компилятор автоматически определяет специальные макросы: так компиляторы в UNIX неявно подставляют один из ключей (или несколько сразу):

-DM_UNIX -DM_XENIX -Dunix -DM_SYSV -DSVR -DUSG... бывают и другие Это позволяет программе "узнать", что ее компилируют для системы UNIX. Более подробно про это напи сано в документации по команде cc.

3.19. Оператор #ifdef применяется в include-файлах, чтобы исключить повторное включение одного и того же файла. Пусть файлы aa.h и bb.h содержат aa.h bb.h #include "cc.h" #include "cc.h" typedef unsigned long ulong;

typedef int cnt_t;

А файлы cc.h и 00.c содержат cc.h 00.c... #include "aa.h" struct II { int x, y;

};

#include "bb.h"... main(){... } В этом случае текст файла cc.h будет вставлен в 00.c дважды: из aa.h и из bb.h. При компиляции 00.c ком пилятор сообщит "Переопределение структуры II". Чтобы include-файл не подставлялся еще раз, если он уже однажды был включен, придуман следующий прием - следует оформлять файлы включений так:

А. Богатырёв, 1992-96 - 116 - Си в UNIX™ /* файл cc.h */ #ifndef _CC_H # define _CC_H /* определяется при первом включении */...

struct II { int x, y;

};

...

#endif /* _CC_H */ Второе и последующие включения такого файла будут подставлять пустое место, что и требуется. Для файла было бы использовано макроопределение _SYS_TYPES_H.

3.20. Любой макрос можно отменить, написав директиву #undef имяМакро Пример:

#include #undef M_UNIX #undef M_SYSV main() { putchar('!');

#undef putchar #define putchar(c) printf( "Буква '%c'\n", c);

putchar('?');

#if defined(M_UNIX) || defined(M_SYSV) /* или просто #if M_UNIX */ printf("Это UNIX\n");

#else printf("Это не UNIX\n");

#endif /* UNIX */ } Обычно #undef используется именно для переопределения макроса, как putchar в этом примере (дело в том, что putchar - это макрос из ).

Директива #if, использованная нами, является расширением оператора #ifdef и подставляет текст если выполнено указанное условие:

#if defined(MACRO) /* равно #ifdef(MACRO) */ #if !defined(MACRO) /* равно #ifndef(MACRO) */ #if VALUE > 15 /* если целая константа #define VALUE больше 15 (==, !=, <=,...) */ #if COND1 || COND2 /* если верно любое из условий */ #if COND1 && COND2 /* если верны оба условия */ Директива #if допускает использование в качестве аргумента довольно сложных выражений, вроде #if !defined(M1) && (defined(M2) || defined(M3)) 3.21. Условная компиляция может использоваться для трассировки программ:

#ifdef DEBUG # define DEBUGF(body) \ { \ body;

\ } #else # define DEBUGF(body) #endif int f(int x){ return x*x;

} int main(int ac, char *av[]){ int x = 21;

DEBUGF(x = f(x);

printf("%s equals to %d\n", "x", x));

printf("x=%d\n", x);

} При компиляции А. Богатырёв, 1992-96 - 117 - Си в UNIX™ cc -DDEBUG file.c в выходном потоке программы будет присутствовать отладочная выдача. При компиляции без -DDEBUG этой выдачи не будет.

3.22. В языке C++ (развитие языка Си) слова class, delete, friend, new, operator, overload, template, public, private, protected, this, virtual являются зарезервированными (ключевыми). Это может вызвать небольшую проблему при переносе текста программы на Си в систему программирования C++, например:

#include ...

int fd_tty = 2;

/* stderr */ struct termio old, new;

ioctl (fd_tty, TCGETA, &old);

new = old;

new.c_lflag |= ECHO | ICANON;

ioctl (fd_tty, TCSETAW, &new);

...

Строки, содержащие имя переменной (или функции) new, окажутся неправильными в C++. Проще всего эта проблема решается переименованием переменной (или функции). Чтобы не производить правки во всем тексте, достаточно переопределить имя при помощи директивы define:

#define new new_modes... старый текст...

#undef new При переносе программы на Си в C++ следует также учесть, что в C++ для каждой функции должен быть задан прототип, прежде чем эта функция будет использована (Си позволяет опускать прототипы для многих функций, особенно возвращающих значения типов int или void).

А. Богатырёв, 1992-96 - 118 - Си в UNIX™ 4. Работа с файлами.

Файлы представляют собой области памяти на внешнем носителе (как правило магнитном диске), предназначенные для:

• хранения данных, превосходящих по объему память компьютера (меньше, разумеется, тоже можно);

• долговременного хранения информации (она сохраняется при выключении машины).

В UNIX и в MS DOS файлы не имеют предопределенной структуры и представляют собой просто линейные массивы байт. Если вы хотите задать некоторую структуру хранимой информации - вы должны позабо титься об этом в своей программе сами. Файлы отличаются от обычных массивов тем, что • они могут изменять свой размер;

• обращение к элементам этих массивов производится не при помощи операции индексации [], а при помощи специальных системных вызовов и функций;

• доступ к элементам файла происходит в так называемой "позиции чтения/записи", которая автоматиче ски продвигается при операциях чтения/записи, т.е. файл просматривается последовательно. Есть, правда, функции для произвольного изменения этой позиции.

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

4.1. Для работы с каким-либо файлом наша программа должна открыть этот файл - установить связь между именем файла и некоторой переменной в программе. При открытии файла в ядре операционной системы выделяется "связующая" структура file "открытый файл", содержащая:

f_offset:

указатель позиции чтения/записи, который в дальнейшем мы будем обозначать как RWptr. Это long число, равное расстоянию в байтах от начала файла до позиции чтения/записи;

f_flag: режимы открытия файла: чтение, запись, чтение и запись, некоторые дополнительные флаги;

f_inode:

расположение файла на диске (в UNIX - в виде ссылки на I-узел файла†);

и кое-что еще.

У каждого процесса имеется таблица открытых им файлов - это массив ссылок на упомянутые "связу ющие" структуры‡. При открытии файла в этой таблице ищется свободная ячейка, в нее заносится ссылка на структуру "открытый файл" в ядре, и ИНДЕКС этой ячейки выдается в вашу программу в виде целого числа - так называемого "дескриптора файла".

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

† I-узел (I-node, индексный узел) - своеобразный "паспорт", который есть у каждого файла (в том чи сле и каталога). В нем содержатся:

- длина файла long di_size;

- номер владельца файла int di_uid;

- коды доступа и тип файла ushort di_mode;

- время создания и последней модификации time_t di_ctime, di_mtime;

- начало таблицы блоков файла char di_addr[...];

- количество имен файла short di_nlink;

и.т.п.

Содержимое некоторых полей этого паспорта можно узнать вызовом stat(). Все I-узлы собраны в единую область в начале файловой системы - так называемый I-файл. Все I-узлы пронумерованы, начиная с номе ра 1. Корневой каталог (файл с именем "/") как правило имеет I-узел номер 2.

‡ У каждого процесса в UNIX также есть свой "паспорт". Часть этого паспорта находится в таблице процессов в ядре ОС, а часть - "приклеена" к самому процессу, однако не доступна из программы непо средственно. Эта вторая часть паспорта носит название "u-area" или структура user. В нее, в частности, входят таблица открытых процессом файлов struct file *u_ofile[NOFILE];

ссылка на I-узел текущего каталога struct inode *u_cdir;

а также ссылка на часть паспорта в таблице процессов struct proc *u_procp;

А. Богатырёв, 1992-96 - 119 - Си в UNIX™ Дескрипторы являются локальными для каждой программы. Т.е. если две программы открыли один и тот же файл - дескрипторы этого файла в каждой из них не обязательно совпадут (хотя и могут). Обратно:

одинаковые дескрипторы (номера) в разных программах не обязательно обозначают один и тот же файл.

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

каждая из них будет иметь СВОЙ указатель чтения/записи. Возможна и ситуация, когда несколько дескрипторов ссылаются к одной структуре - смотри ниже описание вызова dup2.

struct file fd u_ofile[] 0 ## ------------ 1---##---------------->| f_flag | 2 ## | f_count=3 | 3---##---------------->| f_inode---------*... ## *-------------->| f_offset | | процесс1 | ------!------ | | ! V 0 ## | struct file ! struct inode 1 ## | ------------- ! ------------ 2---##-* | f_flag | ! | i_count=2 | 3---##--->| f_count=1 | ! | i_addr[]----*... ## | f_inode----------!-->|... | | адреса процесс2 | f_offset | ! ------------- | блоков -------!----- *=========* | файла ! ! V 0 ! указатели R/W ! i_size- @@@@@@@@@@@!@@@@@@@@@@@@@@@@@@@@@!@@@@@@ файл на диске /* открыть файл */ int fd = open(char имя_файла[], int как_открыть);

... /* какие-то операции с файлом */ close(fd);

/* закрыть */ Параметр как_открыть:

#include O_RDONLY - только для чтения.

O_WRONLY - только для записи.

- для чтения и записи.

O_RDWR O_APPEND - иногда используется вместе с открытием для записи, "добавление" в файл:

O_WRONLY|O_APPEND, O_RDWR|O_APPEND Если файл еще не существовал, то его нельзя открыть: open вернет значение (-1), сигнализирующее об ошибке. В этом случае файл надо создать:

int fd = creat(char имя_файла[], int коды_доступа);

Дескриптор fd будет открыт для записи в этот новый пустой файл. Если же файл уже существовал, creat опустошает его, т.е. уничтожает его прежнее содержимое и делает его длину равной 0L байт.

Коды_доступа задают права пользователей на доступ к файлу. Это число задает битовую шкалу из 9и бит, соответствующих строке биты: 876 543 rwx rwx rwx r - можно читать файл w - можно записывать в файл x - можно выполнять программу из этого файла Первая группа - эта права владельца файла, вторая - членов его группы, третяя - всех прочих. Эти коды для владельца файла имеют еще и мнемонические имена (используемые в вызове stat):

#include /* Там определено: */ #define S_IREAD #define S_IWRITE #define S_IEXEC Подробности - в руководствах по системе UNIX. Отметим в частности, что open() может вернуть код ошибки fd < 0 не только в случае, когда файл не существует (errno==ENOENT), но и в случае, когда вам не разрешен соответствующий доступ к этому файлу (errno==EACCES;

про переменную кода ошибки errno см.

в главе "Взаимодействие с UNIX").

А. Богатырёв, 1992-96 - 120 - Си в UNIX™ Вызов creat - это просто разновидность вызова open в форме fd = open( имя_файла, O_WRONLY|O_TRUNC|O_CREAT, коды_доступа);

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

O_CREAT означает, что файл должен быть создан, если его не было (без этого флага файл не создастся, а open вернет fd < 0). Этот флаг требует задания третьего аргумента коды_доступа†. Если файл уже существует - этот флаг не имеет никакого эффекта, но зато вступает в действие O_TRUNC.

Существует также флаг O_EXCL который может использоваться совместно с O_CREAT. Он делает следующее: если файл уже суще ствует, open вернет код ошибки (errno==EEXIST). Если файл не существовал - срабатывает O_CREAT и файл создается. Это позволяет предохранить уже существующие файлы от уничтожения.

Файл удаляется при помощи int unlink(char имя_файла[]);

У каждой программы по умолчанию открыты три первых дескриптора, обычно связанные 0 - с клавиатурой (для чтения) 1 - с дисплеем (выдача результатов) 2 - с дисплеем (выдача сообщений об ошибках) Если при вызове close(fd) дескриптор fd не соответствует открытому файлу (не был открыт) - ничего не происходит.

Pages:     | 1 || 3 | 4 |   ...   | 6 |



© 2011 www.dissers.ru - «Бесплатная электронная библиотека»

Материалы этого сайта размещены для ознакомления, все права принадлежат их авторам.
Если Вы не согласны с тем, что Ваш материал размещён на этом сайте, пожалуйста, напишите нам, мы в течении 1-2 рабочих дней удалим его.