Программирование Cи / Богатырев_Язык Си в системе Unix

/* поиск максимального числа в массиве */ for( maxim = target[0], i = 1 ; i < N ; i++ )

if( target[i] > maxim ) maxim = target[i];

demochanges();

qsort( target, 0, N-1 ); demochanges();

mvcur( -1, -1, LINES-1, 0);

/* курсор в левый нижний угол */

attron( A_REVERSE );

/* рисуем матрицу упорядоченности */ for( i=0 ; i < N ; i++ )

for( j = 0; j < N ; j++ ){

move( GAPY + i , GAPX + j * 2 );

addch( target[i] >= target[j] ? '*' : '.' ); addch( ' ' );

/* Рисовать '*' если элементы

*идут в неправильном порядке.

*Возможен вариант проверки target[i] > target[j]

*/

}

attroff( A_REVERSE );

/* массив */

for( i = 0 ; i < N ; i++ ){ move( GAPY + i , 5 );

printw( "%4d", target[i] );

height = (long) h * target[i] / maxim ; for( j = 2 * GAPY + N + (h - height) ;

j < LINES - GAPY; j++ ){ move( j, GAPX + i * 2 );

addch( '|' );

}

}

refresh(); /* проявить картинку */ sleep(1);

}

1.51. Реализуйте приведенный фрагмент программы без использования оператора goto и без меток.

if ( i > 10 ) goto M1; goto M2;

M1: j = j + i; flag = 2; goto M3; M2: j = j - i; flag = 1;

M3: ;

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

{..... Label: } а только { ..... Label: ; }

1.52.В каком случае оправдано использование оператора goto?

Ответ: при выходе из вложенных циклов, т.к. оператор break позволяет выйти только из самого внутреннего цикла (на один уровень).

1.53. К какому if-у относится else?

if(...) ... if(...) ... else ...

Ответ: ко второму (к ближайшему предшествующему, для которого нет другого else). Вообще же лучше явно расставлять скобки (для ясности):

if(...){ ... if(...) ... else ... }

if(...){ ... if(...) ... } else ...

1.54. Макроопределение, чье тело представляет собой последовательность операторов в {...} скобках (блок), может вызвать проблемы при использовании его в условном операторе if с else-частью:

Мы получим после макрорасширения

то есть синтаксически ошибочный фрагмент, так как должно быть либо

if(...) один_оператор;

else .....

либо

if(...){ последовательность; ...; операторов; }

else .....

где точка-с-запятой после } не нужна. С этим явлением борются, оформляя блок {...} в виде do{...}while(0)

#define MACRO do{ x=1; y=2; }while(0)

Тело такого "цикла" выполняется единственный раз, при этом мы получаем правильный текст:

1.55. В чем ошибка (для знающих язык "Паскаль")?

int x = 12;

if( x < 20 and x > 10 ) printf( "O'K\n"); else if( x > 100 or x < 0 ) printf( "Bad x\n");

1.56. Почему программа зацикливается? Мы хотим подсчитать число пробелов и табуляций в начале строки:

int i = 0;

char *s = " 3 spaces"; while(*s == ' ' || *s++ == '\t')

printf( "Пробел %d\n", ++i);

Ответ: логические операции || и && выполняются слева направо; как только какое-то условие в || оказывается истинным (а в && ложным) - дальнейшие условия просто не вычисляются. В нашем случае условие *s==' ' сразу же верно, и операция s++ из второго условия не выполняется! Мы должны были написать хотя бы так:

int a[5], i;

for(i=0; i < 5 && a[i] != 0; ++i) ...;

Если i выйдет за границу массива, то сравнение a[i] с нулем уже не будет вычисляться, т.е. попытки прочесть элемент не входящий в массив не произойдет.

Это свойство && позволяет писать довольно неочевидные конструкции, вроде

if((cond) && f());

что оказывается эквивалентным if( cond ) f();

Вообще же

if(C1 && C2 && C3) DO; эквивалентно

if(C1) if(C2) if(C3) DO;

и для "или"

if(C1 || C2 || C3) DO; эквивалентно

if(C1) goto ok; else if(C2) goto ok; else if(C3){ ok: DO; }

Вот еще пример, пользующийся этим свойством ||

#include <stdio.h>

main(argc, argv) int argc; char *argv[];

{FILE *fp;

if(argc < 2 || (fp=fopen(argv[1], "r")) == NULL){

fprintf(stderr, "Плохое имя файла\n"); exit(1); /* завершить программу */

}

...

}

Если argc==1, то argv[1] не определено, однако в этом случае попытки открыть файл с именем argv[1] просто не будет предпринято!

Ниже приведен еще один содержательный пример, представляющий собой одну из возможных схем написания "двуязычных" программ, т.е. выдающих сообщения на одном из двух языков по вашему желанию. Проверяется переменная окружения MSG (или LANG):

Про окружение и функцию getenv() смотри в главе "Взаимодействие с UNIX", про strchr() - в главе "Массивы и строки".

#include <stdio.h>

int _ediag = 0; /* язык диагностик: 1-русский */ extern char *getenv(), *strchr();

#define ediag(e,r) (_ediag?(r):(e)) main(){ char *s;

_ediag = ((s=getenv("MSG")) != NULL && strchr("rRрР", *s) != NULL);

printf(ediag("%d:english\n", "%d:русский\n"), _ediag);

}

Если переменная MSG не определена, то s==NULL и функция strchr(s,...) не вызывается (ее первый фргумент не должен быть NULL-ом). Здесь ее можно было бы упрощенно заменить на *s=='r'; тогда если s равно NULL, то обращение *s было бы незаконно (обращение по указателю NULL дает непредсказуемые

результаты и, скорее всего, вызовет крах программы).

1.57. Иногда логическое условие можно сделать более понятным, используя правила де-Моргана:

Например:

if( c != 'a' && c != 'b' && c != 'c' )...; превращается в

if( !(c == 'a' || c == 'b' || c == 'c')) ...;

1.58. Пример, в котором используются побочные эффекты вычисления выражений. Обычно значение выражения присваивается некоторой переменной, но это не необходимо. Поэтому можно использовать свойства вычисления && и || в выражениях (хотя это не есть самый понятный способ написания программ, скорее некоторый род извращения). Ограничение тут таково: все части выражения должны возвращать значения.

int openFile(){ errno = 0;

fp = fopen("/etc/inittab", "r"); printf("fp=%x\n", fp); return(fp == NULL ? 0 : 1);

}

int closeFile(){ printf("closeFile\n"); if(fp) fclose(fp); return 0;

}

int die(int code){ printf("exit(%d)\n", code); exit(code);

return 0;

}

void main(){

char buf[2048];

if( !openFile()) die(errno); closeFile();

}

В последней строке использован оператор "запятая": (a,b,c) возвращает значение выражения c.

1.59.Напишите функцию, вычисляющую сумму массива заданных чисел.

1.60.Напишите функцию, вычисляющую среднее значение массива заданных чисел.

1.63.Напишите программу, которая распечатывает элементы массива. Напишите программу, которая распечатывает элементы массива по 5 чисел в строке.

1.64.Составьте программу считывания строк символов из стандартного ввода и печати номера введенной строки, адреса строки в памяти ЭВМ, значения строки, длины строки.

1.65.Стилистическое замечание: в операторе return возвращаемое выражение не обязательно должно быть в ()-скобках. Дело в том, что return - не функция, а оператор.

return выражение; return (выражение);

Однако если вы вызываете функцию (например, exit) - то аргументы должны быть в круглых скобках: exit(1); но не exit 1;

1.66. Избегайте ситуации, когда функция в разных ветвях вычисления то возвращает некоторое значение, то не возвращает ничего:

int func (int x) {

if( x > 10 ) return x*2; if( x == 10 ) return (10);

/* а здесь - неявный return; без значения */

}

при x < 10 функция вернет непредсказуемое значение! Многие компиляторы распознают такие ситуации и выдают предупреждение.

1.67. Напишите программу, запрашивающую ваше имя и "приветствующую" вас. Напишите функцию чтения строки. Используйте getchar() и printf().

Ответ:

#include <stdio.h> /* standard input/output */ main(){

char buffer[81]; int i; printf( "Введите ваше имя:" );

while((i = getstr( buffer, sizeof buffer )) != EOF){ printf( "Здравствуй, %s\n", buffer );

printf( "Введите ваше имя:" );

}

}

getstr( s, maxlen )

char *s; /* куда поместить строку */ int maxlen; /* длина буфера:

макс. длина строки = maxlen-1 */

{int c; /* не char! (почему ?) */ register int i = 0;

maxlen--; /* резервируем байт под конечный '\0' */ while(i < maxlen && (c = getchar()) != '\n'

&& c != EOF ) s[i++] = c;

/* обратите внимание, что сам символ '\n' * в строку не попадет */

s[i] = '\0'; /* признак конца строки */ return (i == 0 && c == EOF) ? EOF : i; /* вернем длину строки */

}

Вот еще один вариант функции чтения строки: в нашем примере ее следует вызывать как fgetstr(buffer,sizeof(buffer),stdin);

Это подправленный вариант стандартной функции fgets (в ней строки @1 и @2 обменяны местами).

char *fgetstr(char *s, int maxlen, register FILE *fp){ register c; register char *cs = s;

}

if(c == EOF && cs == s) return NULL;

/* Заметьте, что при EOF строка s не меняется! */ *cs = '\0'; return s;

}

Исследуйте поведение этих функций, когда входная строка слишком длинная (длиннее maxlen). Замечание: вместо нашей "рукописной" функции getstr() мы могли бы использовать стандартную библиотечную функцию gets(buffer).

1.68. Объясните, почему d стало отрицательным и почему %X печатает больше F, чем в исходном числе? Пример выполнялся на 32-х битной машине.

Ответ: при приведении char к int расширился знаковый бит (7-ой), заняв всю старшую часть слова. Знаковый бит int-а стал равен 1, что является признаком отрицательного числа. То же будет происходить со всеми значениями c из диапазона 128..255 (содержащими бит 0200). При приведении unsigned char к int знаковый бит не расширяется.

Можно было поступить еще и так:

printf( "%d\n", c & 0377 );

Здесь c приводится к типу int (потому что при использовании в аргументах функции тип char ВСЕГДА приводится к типу int), затем &0377 занулит старший байт полученного целого числа (состоящий из битов 1),

снова превратив число в положительное.

1.70. Почему

printf("%d\n", '\377' == 0377 ); printf("%d\n", '\xFF' == 0xFF );

печатает 0 (ложь)? Ответ: по той же причине, по которой

printf("%d %d\n", '\377', 0377);

печатает -1 255, а именно: char '\377' приводится в выражениях к целому расширением знакового бита (а 0377 - уже целое).

1.71. Рассмотрим программу

#include <stdio.h>

int main(int ac, char **av){ int c;

while((c = getchar()) != EOF) switch(c){

case 'ы': printf("Буква ы\n"); break; case 'й': printf("Буква й\n"); break;

default: printf("Буква с кодом %d\n", c); break;

}

return 0;

}

Она работает так:

% a.out йфыв

Буква с кодом 202 Буква с кодом 198 Буква с кодом 217 Буква с кодом 215 Буква с кодом 10 ^D

%

Выполняется всегда default, почему не выполняются case 'ы' и case 'й'?

Ответ: русские буквы имеют восьмой бит (левый) равный 1. В case такой байт приводится к типу int расширением знакового бита. В итоге получается отрицательное число. Пример:

void main(void){ int c = 'й';

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

}

печатает -54

Решением служит подавление расширения знакового бита:

}

return 0;

}

Она работает правильно:

А. Богатырёв, 1992-96 - 29 - Си в UNIX™

% a.out йфыв Буква й

Буква с кодом 198 Буква ы Буква с кодом 215

Буква с кодом 10 ^D

%

Возможно также использование кодов букв:

case 0312:

но это гораздо менее наглядно. Подавление знакового бита необходимо также и в операторах if:

int c;

...

if(c == 'й') ...

следует заменить на

if(c == UC('й')) ...

Слева здесь - signed int, правую часть компилятор тоже приводит к signed int. Приходится явно говорить, что справа - unsigned.

1.72. Рассмотрим программу, которая должна напечатать числа от 0 до 255. Для этих чисел в качестве счетчика достаточен один байт:

int main(int ac, char *av[]){ unsigned char ch;

for(ch=0; ch < 256; ch++) printf("%d\n", ch);

return 0;

}

Однако эта программа зацикливается, поскольку в момент, когда ch==255, это значение меньше 256. Следующим шагом выполняется ch++, и ch становится равно 0, ибо для char вычисления ведутся по модулю 256 (2 в 8 степени). То есть в данном случае 255+1=0

Решений существует два: первое - превратить unsigned char в int. Второе - вставить явную проверку на последнее значение диапазона.

int main(int ac, char *av[]){ unsigned char ch;

for(ch=0; ; ch++){ printf("%d\n", ch); if(ch == 255) break;

}

return 0;

}

1.73. Подумайте, почему для

unsigned a, b, c;

a < b + c не эквивалентно a - b < c

(первое - более корректно). Намек в виде примера (он выполнялся на 32-битной машине):

Могут ли unsigned числа быть отрицательными?

1.74. Дан текст:

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

Печатается -25536. Объясните эффект. Указание: каково наибольшее представимое короткое целое (16 битное)? Что на самом деле оказалось в x? (лишние слева биты - обрубаются).

1.75. Почему в примере

double x = 5 / 2; printf( "%g\n", x );

значение x равно 2 а не 2.5 ?

Ответ: производится целочисленное деление, затем в присваивании целое число 2 приводится к типу double. Чтобы получился ответ 2.5, надо писать одним из следующих способов:

double x = 5.0 / 2; x = 5 / 2.0;

x = (double) 5 / 2; x = 5 / (double) 2; x = 5.0 / 2.0;

то есть в выражении должен быть хоть один операнд типа double.

Объясните, почему следующие три оператора выдают такие значения:

В каких случаях деление целочисленное, в каких - вещественное? Почему?

1.76. Странслируйте пример на машине с длиной слова int равной 16 бит:

long n = 1024 * 1024; long nn = 512 * 512;

printf( "%ld %ld\n", n, nn );

Почему печатается 0 0 а не 1048576 262144?

Ответ: результат умножения (2**20 и 2**18) - это целое число; однако оно слишком велико для сохранения в 16 битах, поэтому старшие биты обрубаются. Получается 0. Затем в присваивании это уже обрубленное значение приводится к типу long (32 бита) - это все равно будет 0.

Чтобы получить корректный результат, надо чтобы выражение справа от = уже имело тип long и сразу сохранялось в 32 битах. Для этого оно должно иметь хоть один операнд типа long:

1.77.Найдите ошибку в операторе:

x - = 4; /* вычесть из x число 4 */

Ответ: между `-' и `=' не должно быть пробела. Операция вида

x @= expr;

означает

x = x @ expr;

(где @ - одна из операций + - * / % ^ >> << & |), причем x здесь вычисляется единственный раз (т.е. такая форма не только короче и понятнее, но и экономичнее).

Однако имеется тонкое отличие a=a+n от a+=n; оно заключается в том, сколько раз вычисляется a. В случае a+=n единожды; в случае a=a+n два раза.