Хрестоматия по программированию на Си в Unix

       

Мобильность и машинная зависимость программ. Проблемы с русскими буквами.


Мобильность и машинная зависимость программ. Проблемы с русскими буквами.

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

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

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

  1. Наибольшее допустимое знаковое целое.
  2. Наибольшее беззнаковое целое.
  3. Наибольшее по абсолютной величине отрицательное целое.
  4. Точность значения |x|, отличающегося от 0, где x - вещественное число.
  5. Наименьшее значение e, такое что машина различает числа 1 и 1+e (для вещественных чисел).

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

Надо ли писать в своих программах определения

#define EOF (-1) #define NULL ((char *) 0) /* или ((void *)0) */

Ответ: НЕТ. Во-первых, эти константы уже определены в include-файле, подключаемом по директиве

#include <stdio.h>

поэтому правильнее написать именно эту директиву. Во-вторых, это было бы просто неправильно: конкретные значения этих констант на данной машине (в данной реализации системы) могут быть другими! Чтобы придерживаться тех соглашений, которых придерживаются все стандартные функции данной реализации, вы ДОЛЖНЫ брать эти константы из <stdio.h>.

По той же причине следует писать

#include <fcntl.h>

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


В современных UNIX-ах с поддержкой различных языков таблица ctype загружается из некоторых системных файлов - для каждого языка своя. Для какого языка - выбирается по содержимому переменной окружения LANG. Если переменная не задана - используется значение "C", английский язык. Загрузка таблиц должна происходить явно, вызовом



... #include <locale.h>

... main(){ setlocale(LC_ALL, ""); ... все остальное ... }

Вернемся к нашей любимой проблеме со знаковым битом у типа char.

#include <stdio.h>

#include <locale.h>

#include <ctype.h>

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, который останется положительным. Вероятно, второй путь предпочтительнее.

Итак, снова напомним, что русские буквы char, а не unsigned char дают отрицательные индексы в массиве.




int x = f((long) 666, "good bye" );

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

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

void *malloc(unsigned size); /* size байт */ char *s = (char *) malloc( strlen(buf)+1 ); struct ST *p = (struct ST *) malloc( sizeof(struct ST)); /* или sizeof(*p) */

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



Поговорим про оператор sizeof. Отметим распространенную ошибку, когда sizeof принимают за функцию. Это не так! sizeof вычисляется компилятором при трансляции

программы, а не программой во время выполнения. Пусть

char a[] = "abcdefg"; char *b = "hijklmn";

Тогда

sizeof(a) есть 8 (байт \0 на конце - считается) sizeof(b) есть 2 на PDP-11 (размер указателя) strlen(a) есть 7 strlen(b) есть 7

Если мы сделаем

b = "This ia a new line"; strcpy(a, "abc");

то все равно

sizeof(b) останется равно 2 sizeof(a) 8

Таким образом 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;

Напишите объединение, в котором может храниться либо указатель, либо целое, либо действительное число. Ответ:

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 { 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); }





Для выделения классов символов (например цифр), следует пользоваться макросами из include-файла <ctype.h> Так вместо

if( '0' <= c && c <= '9' ) ...

следует использовать

#include <ctype.h>

..... if(isdigit(c)) ...

и вместо

if((c >='a' && c <= 'z') (c >= 'A' && c <= 'Z')) ...

надо

if(isalpha(c)) ...

Дело в том, что сравнения < и > зависят от расположения букв в используемой кодировке. Но например, в кодировке КОИ-8 русские буквы расположены НЕ в алфавитном порядке. Вследствие этого, если для

char c1, c2; c1 < c2

то это еще не значит, что буква c1 предшествует букве c2 в алфавите! Лексикографическое сравнение требует специальной перекодировки букв к "упорядоченной" кодировке.

Аналогично, сравнение

if( c >= 'а' && c <= 'я' )

скорее всего не даст ожидаемого результата. Макроопределения же в <ctype.h> используют массив флагов для каждой буквы кодировки, и потому не зависят от порядка букв (и работают быстрее). Идея реализации такова:

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[] заполнен заранее (это проинициализированные статические данные) и хранится в стандартной библиотеке Си. Вот его фрагмент:

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.h>

(как определено выше) - мы используем только две операции: индексацию и проверку битовой маски &. Операции _ctype+1 и _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'.

Задание: исследуйте кодировку и <ctype.h> на вашей машине. Напишите функцию лексикографического сравнения букв и строк.

Указание: пусть буквы имеют такие коды (это не соответствует реальности!):

буква: а б в г д е код: 1 4 2 5 3 0 нужно: 0 1 2 3 4 5

Тогда идея функции 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); }

Разберитесь с принципом формирования массива UU.

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

** = "Куча" (heap, pool) - область статической памяти, увеличивающаяся по мере надобности, и предназначенная как раз для хранения динамически отведенных данных.

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

**** = ASCII - American Standard Code for Information Interchange - наиболее распространенная в мире кодировка (Американский стандарт).

© Copyright А. Богатырев, 1992-95
Си в UNIX

| |



char c = 'г'; int x[256]; ...x[c]... /* индекс < 0 */ ...x['г']...

Поэтому байтовые индексы должны быть либо unsigned char, либо & 0xFF. Как в следующем примере:

/* Программа преобразования символов в файле: транслитерация tr abcd prst заменяет строки xxxxdbcaxxxx -> xxxxtrspxxxx По мотивам книги М.Дансмура и Г.Дейвиса. */ #include <stdio.h>

#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); }



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 такой проблемы не будет.

Почему неверно:

#include <stdio.h>

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.

Изучите поведение программы

#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=0xFFFFFFC7 Это буква й 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=0xC7 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");

где предполагается, что знак у русских букв и у c НЕ расширяется. В данном случае фраза 'Это буква й' не печатается ни с типом char, ни с типом int, поскольку в сравнении c приводится к типу signed int расширением знакового бита (который равен 1).

Слева получается отрицательное число!

В таких случаях вновь следует писать

if((unsigned char)c == (unsigned char)'й') printf("Это буква й\n");



Обычно возникают проблемы при написании функций с переменным числом аргументов. В языке Си эта проблема решается использованием макросов va_args, не зависящих от соглашений о вызовах функций на данной машине, и использующих эти макросы специальных функций. Есть два стиля оформления таких программ: с использованием <varargs.h> и <stdarg.h>. Первый был продемонстрирован в первой главе на примере функции poly(). Для иллюстрации второго приведем пример функции трассировки, записывающей собщение в файл:



#include <stdio.h>

#include <stdarg.h>

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'.



Напишите функцию printf, понимающую форматы %c (буква), %d (целое), %o (восьмеричное), %x (шестнадцатеричное), %b (двоичное), %r (римское), %s (строка), %ld (длинное целое). Ответ смотри в приложении.



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

#ifdef XX

... вариант1 #else

... вариант2 #endif

Эта директива препроцессора ведет себя следующим образом: если макрос с именем XX был определен


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