Стандарные подпрограммы (функции Printf, Scanf)

Книга по С

1. Основные понятия и особенности языка
   1.1 Стандарные подпрограммы (функции Printf, Scanf)
   1.2 Пример простой программы на языке Си
   1.3 Основные типы данных, операции и выражения
   2. Основные управляющие структуры
   2.1 Операторы IF - ELSE
   2.2 Опрератор WHILE
   3. Определения функций
   4. Классы памяти
   5. Обработка символьных данных
   5.1 Функция Getchar, Putchar
   6. Дополнительные операции языка
   7. Массивы
   7.1 Массивы
   7.2 Массивы символов
   8. Дополнительные управляющие структуры
   8.1 Организация символов с помощью опрератора FOR
   8.2 Организация символов с помощью опрератора DO - WHILE
   8.3 Операторы break и continue
   8.4 Переключатель
   9. Указатели
   11. Структуры
   11.1 Структуры
   11.2 Структуры и указатели
   12. Препроцессор языка C
   12.1 Замена лексических единиц
   12.2 Включение файлов
   12.3 Условная компиляция
   13. Работа с файлами
   13.1 Функции Fopen, fclose, getc, putc

Стандарные подпрограммы (функции Printf, Scanf)

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

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

printf ("Интересное сообщение \n");

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

printf ("Интересное сообщение "); printf(" \n ");

- результат будет точно таким же, как и в первом случае!

Первым аргументом служит строка форматов, а вторым, если они есть, - выводимые объекты. Строка форматов может включать обычные символы, которые начинаются со знака %, за ним следует символ преобразования. Каждая спецификация преобразования соответствует одному из аргументов, которые следуют за форматной строкой.Буква d в спецификации преобразования указывает, что значение аргумента должно быть напечатано как десятичное целое число. Из других символов отметим: c - для вывода отдельного символа; s - для печати символьной строки; x и o -для вывода шестнадцатиричных и восьмиричных чисел соответственно; f - для вывода чисел с плавающей точкой. В следующем примере

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

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

printf(" %c = %5d \n",g,g);

Пример простой программы на языке Си

Следующий простой пример, но вполне законченной программы поможет понять многие из расмотренных ранее принципов построения программ на языке Си. Наша первая программа вводит два числа, вычисляет их сумму и печатает результат с поясняющим текстом " Cумма "
(пример 1.1)

#include <stdio.h> { int a,b,c; a=5; b=7; c=a+b; printf("Cумма= %d \n",c) }

Дадим некоторые пояснения. В языке Си любая пограмма, состоит из нескольких программных едениц и каждая из них - функция. Функции в Си подобны функциям или подпрограммам в Фортране или процедурам в Паскале, Имена функций выбираются произвольно (только латинскими буквами), но одно из них main, именно с нее начинается выполнение программы. Такая главная функция обычно обращается к другим функциям, которые находятся в одном файле с головной программой или извлекают из библиотеки предварительно подготовленных функций.Функция main не имеет аргументов, поэтому список ее выглядит так: (). Скобки { } обрамляют операоры, которые реализуют собственно алгоритм. Эти скобки аналогичны BEGIN - END в Паскале.
Строка int a,b,c; объявляет a,b,c переменными целого типа. Все используемые в программе переменные должны быть объявлены. Далее идут опрераторы присваивания к a значение 5, а к b - 7, с - значение их суммы. Значения переменных типа int лежат в диапазоне [-32768; 32767]. Функция printf выводит на экран: СУММА = 12.

Рассмотрим теперь функцию scanf предназначенную для форматного ввода данных. Функция scanf в качестве фактических параметров использует адреса переменных, а не их значения. Для этого перед соответствующим параметром ставят знак & - символ взятия адресса. Например, &XL означает "адрес перменной XL ", а не значение, которое переменная имеет в данный момент.

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

Предыдущяя программа страдает одним недостатком: программа вычисления суммы годится только для одного конкретного случая, когда a=5, b=7. Улучшим ее, заменив соответствующие операторы присваивания вызовом функции scanf (пример 1.2):

/* Ввод двух чисел, вычисление суммы и печать результата*/ #include <stdio.h> { int a,b,c; scanf(" %d %d",&a,&b); c=a+b; printf("Cумма= %d \n",c) }

Форматная строка предписывает функции scanf ввести десятичное число, которое надо поместить в переменную a, затем через пробел ввести второе десятичное число, которое надо присвоить переменной b. Обратите внимание, что программа начинается со строки коминтарием: /*.. */, транслятор пропускает любые символы между /* и */ и их можно использовать для пояснений.

Операторы IF - ELSE

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

if (выражение) оператор_1; else оператор_2;

где часть else может и отсутствовать. Сначала вычисляется "выражение"в скобках; если оно истинно то выполняется оператор_1. Если " выражение" ложно (равно нулю - NULL), то оператор_1 пропускается, а выполняется оператор_2. Если на месте условно выполняемых операторов должна располагаться группа из нескольких операторов языка, то они заключаются в фигурные скобки - { }. Часто "выражение" в скобках представляет условие, заданное с помощью операций отношений и логических операций. Операции отношения обозначаются в Си следующим образом:

= = равно;! = не равно; < меньше; > больше;
< = меньше или равно; > = больше или равно.

Символ! в языке Си обозначает логическое отрицание. Есть еще две логические операции: || означает или, а && - логическое И. Операции отношения имеют приоретет ниже арифметических операций, так что выражение вида k > n%i вычисляется как k > (n%i). Приоритет && выше, чем у ||, но обе логические операции выполняются после операций отношения и арифметических. В сомнительных случаях лучше расставлять скобки.

Для иллюстрации применения условного оператора рассмотрим программу определения большего из трех чисел. Первый if оператор представляет полную условную конструкцию, во втором случае else отсутствует. Обратите внимание, что точка с запятой, завершая оператор присваивания max=x, не нарушает единство if - оператора. Если else - ветвь пропускается во вложенных условиях, возможна неоднозначность их толкования. Во избежание двусмысленностей решают так: else соответствует ближайшему if, не имеющего своего else.

Пример 1.3.

#include <stdio.h> main() /* главная функция*/ { int x, y, z, max; /* описание переменных*/ printf(" Введите три числа:\n "); scanf(" %d %d %d ", &x, &y, &z); /*ввод трех чисел*/ if(x > y) /*операции сравнивания*/ max=x; else max=y; if (z>max) max=z; printf(" Максимальное из (%d, %d, %d)= %d \n",x, y, z, max); }

Рассмотрим пример программы, в которой применяются несколько вложенных друг в друга условных операторов. В этой программе сторока float A, B, X объявляет эти три переменные как величины вещественного типа. Форматная строка функции scanf предписывает ввести два вещественные числа, которые станут значениями переменных A и B соответственно.

Пример 1.4

/*РЕШЕНИЕ УРАВНЕНИЯ AX=B*/ #include <stdio.h> main() { float A,B,X; printf("ВВЕДИ А, В\n"); scanf("%f %f",&A, &B); if(A!=0) printf("РЕШЕНИЕ:%f\n", B/A); else if(B==0) printf("X-ЛЮБОЕ ЧИСЛО\n"); else printf("РЕШЕНИЙ НЕТ\n"); }

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

if(a_0) { printf("..."); scanf("...") другие операторы... }

Пример 1.5

/* Програииа определяет поведение ракеты, стартующей на экваторе, в зависимости от ее начальной скорости*/ #include <stdio.h> main() { float V; printf("ВВЕДИ V\n"); scanf("%f",&V); if(V<7.9) printf("РАКЕТА УПАДЕТ НА ЗЕМЛЮ\n"); if(V<11.2) printf("РАКЕТА СТАНЕТ СПУТНИКОМ ЗЕМЛИ\n "); if(V<16.4) printf("РАКЕТА СТАНЕТ СПУТНИКОМ СОЛНЦА\n"); else printf("РАКЕТА ПОКИНЕТ СОЛНЕЧНУЮ СИСТЕМУ\n"); }

Оператор WHILE

В языке Си основной структурой, управляющей повторением, служит цикл с предусловием while(пока). Он имеет следующий формат while (условие) оператор; Условие всегда заключено в скобки, оно может быть произвольным выражением. Опрератор while повторяет выполнение оператора следующего условия, до тех пор, пока это условие истинно. Если это условие не истинно с самого начала или становится не истинным в процессе выполнения данного опрератора, то управление передается оператору, следующему за опрератором цикла. Если повторяемая часть оператора содержит более одного оператора, то повторяемая группа операторов должна быть заключена в фигурные скобки скобки, например: while(условие) { оператор_1; оператор_2;.... оператор } Для описания условий в операторе while используются операции условия такие же, как и в операторе if. Приведенная ниже программа подсчитывает сумму цифр введенного числа N. Цикл while последовательно выделяет и суммирует цифру исходного числа, начиная с последней; для для выделения применяется операция взятия остатка от деления - %. При делении целых чисел любая дробная чать отбрасывается, поэтому после операции N=N/10; исходное число уменьшается в 10 раз при каждом "обороте" цикла, пока, наконец, не станет равным нулю, после чего цикл завершается и на экран дисплея выдается значение переменной S, в котором содержится сумма цифр числа N. Пример 1.6 #include <stdio.h> main() { int N,S,Z; S=0; printf("ВВЕДИN\n"); scanf("%d",&N) while(N!=0) { Z=N%10 N=N/10 S=S+Z; } printf("СУММАЦИФР=%d\n",S); } Рассмотрим еще один пример. Здесь приведена программа, которая реализует лгоритм разложения числа на простые множители. Для сокращения времени счета отдельно рассматривается случай множителя, равного двум, чтобы в последующем рассматривать только нечетные множители. Пример 1.7 /*РАЗЛОЖИТЬ ЧИСЛО НА МНОЖИТЕЛИ */ #include <stdio.h> main() { int M,i=3; printf("ВВЕДИM\n"); scanf("%d",&M); printf("%d=1",M); while(M%2==0) { printf("*%d",2); M=M/2; } while(i <=M) { if(M%i==0) { printf("*%d",i); M=M/i; } else i=i+2 } } Иногда структуры со вложенными друг в друга операторами повторения называюися циклами. Следующяя программа простая, хотя и содержит вложенные циклы. Она выводит на экран заполненный символом * треугольник, высота которого равна N. Во внешнем цикле устанавливается очередная строка вывода (параметр i), а во внутреннем (параметр j) в очередную строку вводится ровно i символов " * " Вызов функции printf("\n") обеспечивает в нужный момент переход нат новую строку. Обратите внимание, что для вывода одного символа в форматной строке функции printf используется спецификация %c. Пример 1.8 #include <stdio.h> main() { int i,j,N; printf("ВВЕДИN \n"); scanf("%d",&N); i=1; while(i <=N) { j=1; while(j <=i) { printf("%c",'*'); j=j+1; } i=i+1; printf("\n"); } } Рассмотрим еще один пример, в котором используется сложный цикл. Программа позволяет найти в заданном интервале все совершенные числа. Напомним, что натуральное число называютя совершенным, если оно равно сумме всех своих делителей, считая его самого. Известно, что все совершенные числа - четные и что первое совершенное чсило из натурального ряда чисел равно 6. Этим объясняется начальное значение параметра внешнего цикла. Так как все натуральные числа имеют своим делителем единицу, полагаем начальное значение суммы делителей числа S=1. Во внутренннем цикле организуется перебор всех множителей текущего значения N. Из теории чисел известно, что такому испытанию имеет подвергать числа от 2 до N/2, либо даже до корень из N. Это очень несовершенный алгоритм и если вы захотите его выполнить на ЭВМ, имейте ввиду, что программа работает слишком долго. Более эффективно алгоритм будет реализован попозже. Пример 1.9 #include <stdio.h> main() { int j,N,M,S; printf("ВВЕДИ M\n"); scanf("%d",&M); N=4; while(N<=M) { S=1;j=2; while(j<=N/2) { if(N%j==0) S=S+j; j=j+1; } if(N==S) printf("%d- СОВЕРШЕННОЕ ЧИСЛО\n",N); N=N+2; } }

Определение функции

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

Определение функции состоит из двух частей: заголовка и тела. Заголовок определяет имя функции, ее тип и формальные параметры, тело определяет действия над данными, выполняемые функцией. Возращающее функцией значение передается в вызывающюю программу опрератором return (выражение). Значение "выражения" и есть результат функции (возращаемого значения). Если в нашей программе функция физически следует за вызывающей ее функцией main, то надо в последней объявить функцию внешней с помощью описателя extern: extern int fun(); или еще проще int fun();. В противном случае при компиляции будет выдана ошибка. Всякая функция имеет вид:

[тип] имя([список формальных параметров]) описания формальных параметров; { описания; операторы; }

Здесь квадратные скобки указываютя, что заключенная в них конструкция может отсутствовать. По умолчанию тип функции целый. Описание формальных параметров расположено между списком параметров и левой скобкой. Каждое описание заканчивается точкой с запятой. Формальные параметры функции полностью локализированы в ней и недоступны для других функций. Аргументы функции передаются по значению, а не их адреса.

Рассмотрим пример программы возведения числа в степень. Для этого составим функцию power(t,n); В нашей реализации функция power предшествует головной программе, поэтому она предварительно не объявлена. Описание формальных параметров функции происходит в заголовке (int t,n;) Оператор int p=1; в теле функции определяет переменную p целого типа и присваивает ей начальное значение равное 1. Выражение int p=1; в точности эквиалентно последовательности операторов int p; p=1; Обращение к функции задает один из аргументов стнадартной функции printf в программе main. Выражение power(t,n) предписывает вызов функции. Когда программа main достигает этой точки, то все управление передается функции power. Операторы, содержащиеся в теле функции power фактически оперируютя данными. Когда достигается оператор return, осуществляется переход в ту точку программы main, из которой мы пришли в power. Значение, вычисляемое функцией power, передается в головную программу с помощью оператора return(p). В скобках в общем случае может быть любое значение.

Прмер 2.0

/*Функция y=t**n*/ int power(t,n); int t,n; { int p=1; while(n!=0) { if(n%2!=0) p=p*t; n=n/2; t=t*t; } return(p); } /*Возведение в степень- головная программа*/ #include <stdio.h> main() { int a,n; printf("Введи a,n \n"); scanf("%d %d",&a,&n); printf("%d в степени %d = %d",a,n power(a,n)); }

Рекурсия.

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

Пример 2.1

#include <stdio.h> main() { printf("проверкарекурсии \n"); main(); }

Следущий пример 2.2 использует рекурсию для вычисления k!. При первом вызове fact(i), если не равно 1, функция порождает выражение i*fact(i-1); в свою очередь, вызов fact(i-1) производит (i-1)*fact(i-2), что вместе с ранее полученным результатом дает i*(i-1)*fact(i-2). Рекурсия закончистся, как только следующий вызов функции получит аргумент, равный еденице. Нетрудно сообразить, что в конечном счете мы получим требуемое произведение.

Прмер 2.2

#include <stdio.h> int fact(k); int k; { if(k==1) return(1); else return(k*fact(k-1)); } main() { int i=1; printf("проверка рекурсии\n"); while(i<8) { printf("%d!= %d\n",i, fact(i)); i=i+1; } }

Классы памяти

Все переменные в программе характеризуются не только типом, но и классом памяти. В языке Си существует четыре класса памяти: автоматический (automatic), регистровый (register), статический (static) и внешний (external).

Автоматические переменные в программе можно описать так:

auto A; auto char c1; auto int x= 125;

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

Пимер 2.3

#include <stdio.h> main() { int t; { int t=2; { int t=3; printf("%d\n",t); } printf("%d\n",t); } printf("%d\n",t); }

В этой программе перменная t описана в нескольких блоках, в каждом блоке она может принимать разные значения не зависимо от других. С ней могут выполнятся разные операции. В нашей програамме значение переменной t выводится на дисплей. В нашем случае выведятся числа 2, 3, 746. Число 746 - так называемое число "мусор" оно такое так как ей не присваивали значение в первом блоке.

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

Пример 2.4

#include <stdio.h> int x=145;/*Описание внешней переменной*/ main() { extern int x,y; printf("x=%d y=%d \n",x,y); } int y=541; /*Описание внешней переменной*/

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

Пример 2.5

int x=3; /*описание внешней переменной */ /* увелечение x */ int plus1() { x=x+1; printf("прибавляем единицу: x=%d\n",x); } /*уменьшение x */ int mainus1() { x=x-1; printf("вычитаем единицу: x=%d\n",x); } main() { printf("начальное значение x=%d\n",x); plus1(); minus1(); minus1(); printf("конечное значение x=%d \n", x); }

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

static char c; static int a=1;

Рассмотрим пример 2.6, в котором переменная объявлена как статическая.

Пример 2.6

*статические переменные*/ #include <stdio.h> plus1() { static int x=0; x=x+1; printf("x=%d\n",x); } main() { plus1(); plus1(); plus1(); }

Начальное значение равное нулю присваивает переменной x только один раз. Затем в программе main, функция plus1() несколько раз запускается, так как при каждом запуске функции аргумент x не изменяется, а оставляет значение из предыдущей функции. Таким образом повторение функции plus1 обеспечивает увелечение переменной x на 1 при каждом запуске 1, 2, 3...

Регистровые переменные объявляются в программе с помощью ключевого слова register и по замыслу автора языка Си должны хранится в сверх быстрой памяти ЭВМ - регистрах. Используются аналогично автоматическим переменным. Целесообразность их применения для увелечения быстродействия программы представляется в большинстве случаев сомнительной.

Обработка символьных данных

Язык Си лучше всего подходит для системной работы: написания компиляторов, интерпретаторов, опрерационных систем, редакторов текста и.т.п. В стнадартной библиотеке Си предусмотренымногие полезные функции, выполняющие простые действия с символьными данными. Рассмотрим из них - putchar и getchar выполняющие ввод и вывод символа соответственно и создадим на их основе ряд своих полезных функций.

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

Int getchar()

видите, у нее совсем нет аргументов и она возращает значение типа - это значение символа во внутреннем представлении его для данной ЭВМ(напрмер в ACSII). Таким образом после обращения

c = getchar()

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

Функция putchar за одно обращение к ней выдает один символ в стандарный выходной поток. Вызов этой функции имеет вид:

putchar(c);

c - переменная символьного типа, котрой предварительно было присвоено некоторое значение. Рассмотрим примеры. Программа (пример 2.7) вывводит на экран все прописные латинские буквы. Мы уже напоминали что типы char и int взаимозаменяемы. Последовательное прибавление к очередному значению с обеспечивает выбор очередной буквы ввиду их лексической упорядоченности.

Пример 2.7

#include <stdio.h> main() { char c; c='A' while(c<='Z') { putchar(c); c=c+1; } }

Прежде, чем перейти к рассмотрению примеров, обсудим, как машина должна определять конец входного потока символов, вводимых с клавиатуры терминала. Можно, конечно, выбрать некоторый символ как признак конца потока, но нужна гарантия, что он нигде не повторится. В использованной нами операционной системе для получения такого символа надо нажать CTRL+Z. В программе значение этого символа мы будем использовать через символическое имя EOF (end of file). Теперь мы можем написать программы копирования файла(прмер 2.8). Пока не обнаружен конец входного потока, ЭВМ получает с клавиатуры символ (это делает функция getchar) и сразу же выодит его на экран дисплея с помощью функции putchar. Для завершения программы достаточно нажать CTRL+Z.

Пример 2.8

/*ЭХО ПРОГРАММА*/ #include <stdio.h> main() { char c; c=getchar(); while(c!=EOF) { putchar(c); c=getchar(); } }

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

Пример 2.9

*ЭХО ПРОГРАММА ВАР2.*/ #include stdio.h main() { char c; while((c=getchar())!=EOF)putchar(c); }

Отметим, что включение присваиваний в проверки - силбное единство языка, способствующее созданию программ. Учтите, что скобки вокруг присваивания внутри условия необходимы: приоритет операции != выше приоритета операции присваивания.
Следующяя программа (пример 3.0) подсчитывает количество строк, слов и символов во введенном с клавиатуры тексте. Слово - любая последовательность символов, не содержащяя знаков табуляции ("\t"), пробелов и символов "\n". Будем предполагать также, что любая строка, в том числе и последняя, завершается символом перехода на новую строку "\n". Обратите внимание на строку line= word=kc=0; в которой трем переменным приваивается значение нуля. Выражения, связанные логическими операциями &&(И) и || (ИЛИ) вычисляются слева на право. Как только истинность или ложность станет известной, дальнейшие вычисления прекращяются Таким образом в строке if(s==' ' || s=='\n' || s=='\t')
символ s содержит пробел, то остальные две проверки уже не делаются. Отсюда следует выжный для практики вывод: первыми надо проверять наиболее часто встречающиеся символы.

Пример 3.0

/*подсчет строк, символов, слов*/ #include <stdio.h> main() { int c,line,word,kx,inword=0; line=word=kc=0; while((c=getchar())!=EOF) { kc=kc+1; if(c=='\n') line=line+1; if(c=='' || c=='\n' || c=='\t') inword=0; else if(!inword) { inword=1; word=word+1; } } printf("\n"); printf("строк - %d\n",line); printf("символов - %d\n",kc); }

Массивы

Как известно, массив - это конечная совокупность данных одного типа. Можно говорить о массивах целых чисел, массивов символов и.т.д. Мы можем даже определить масссив, элементы которого - массивы(массив массивов), определяя, таким образм, многомерные массивы. Любой массив в программе должен быть описан: после имени массива добаляют квадратные скобки [], внутри которых обычно стоит число, показывающее количество элементов массива. Например, запись int x[10]; определяет x как массив из 10 целых чисел. В случае многомерных массивов показывают столько пар скобок, какова размерность массива, а число внутри скобок показывает размер массива по данному измерению. Например, описание двумерного массива выглядит так: int a[2][5];. Такое описание можно трактовать как матрицу из 2 строк и 5 столбцов. Для обрщения к некоторому элементу массива указывают его имя и индекс, заключенный в квадратные скобки(для многомерног массива - несколько индексов, заключенные в отдельные квадратные скобки): a[1][3], x[i] a[0][k+2]. Индексы массива в Си всегда начинаются с 0, а не с 1, т.е. описание int x[5]; порождает элементы x[0], x[1], x[2], x[3], x[4], x[5]. Индекс может быть не только целой константой или целой переменной, но и любым выражением целого типа. Переменная с индексами в программе используется наравне с простой переменной (например, в операторе присваивания, в функциях ввода- вывода). Начальные значения массивам в языке Си могут быть присвоены при компиляции только в том случае, если они объявлены с классом памяти extern или static, например:

static int a[6]={5,0,4,-17,49,1};
обеспечивает присвоения a[0]=5; a[1]=0; a[2]=4... a[5]=1. Как видите, для начального присвоения значений некоторому массиву надо в описании поместить справа от знака = список инициирующих значений, заключенные в фигурные скобки и разделенные запятыми. Двумерный массив можно инициировать так:

static int matr[2][5] = {{3,4,0,1,2},{6,5,1,4,9}};

Матрица хранится в памяти построчно, т.е. самый правый индекс в наборе индексов массива меняется наиболее быстро.
Пусть, например, в заданном массиве из 10 целых чисел надо изменить порядок следования его элементов на обратный без привлечения вспомагательного массива. Соответствующая прорамма приведена на примере 3.6.

Пример 3.6

/*обращение массива*/ #include <stdio.h> main() { int p,i=0; static a[10]={10,11,12,13,14, 15,16,17,18,19}; while(i<10/2) { p=a[i]; a[i]=a[9-i]; a[9-i]=p; i++; } i=0; while(i<10) printf(" %d",a[i++]); }

Следующяя программа (пример 3.7)позволяет в целочисленном массиве найти разность максимального и минимального элемента. Обратите внимание, что функция fmax при первом обращении к ней дает максимальный элемент массива, а при повторном вызове - минимальный, так как предварительно мы изменили знаки элементов на противоположные. Это изменение знаков учитывается при вызове функции printf. В языке Си отсутствует возможность динамически распределять память под массивы: надо при описании массива задать точно его размер. Но если тот же массив описывается еще раз в другой программе, размеры можно не указывать;достаточно после имени сохранить пару квадратных скобок, например int x[]. Если при вызове функции в качестве аргумента ей передается имя массива, то, в отличае от простых переменных, берется фактически адрес начала этого массива. Поэтому записи fmax(a, 10) и fmax(&a[0], 10) равносильны.

Пример 3.7

/*в массиве найти разность мин. и макс. элементов */ int fmax(x,n) int x[],n; { int max, i=0; max=x[0]; while(i<n) { if(x[i]> max) max=x[i]; i++; } return(max); } #include <stdio.h> main() { static int a[10]= {1,-2,3,-4,5,-6,7,-8,9,-13}; max=fmax(a,10); i=0; while(i<10) { a[i]=-a[i]; i++; } main=fmax(a,10); printf("макс-мин=%d\n",max+min); }

В следующем пример 3.8 массив описан как внешний. Функция main подсчитывает наибольшее число одинаковых идущих подряд элементов массива, определенного вне функции main.

Пример 3.8

/*макс одинаковых подряд*/ #include <stdio.h> int a[]={5,6,6,6,4,3,3,3,3,3,8}; int n=10; main() { int i,k,max; i=k=max=1; while(i<n) { if(a[i]==a[i-1]) k++; else { if(k>max)max=k; k=1; } i++; } printf("kmax=%d\n",(k>max)?k:max); }

Если, как в данном примере, размер массива пропущен, то транслятор определит его дляну, считая присваиваемые значения во время начальной инициализации. Условная операция (k>max) ?k:max в операторе printf предусмотрена для того частного случая, когда весь массив состоит из одинаковых элементов. Приведем несколько примеров, в которых ведется обработка двумерных массивов. Но прежде одну полезную возможносить языка Си. Речь идет о препроцессорном утверждении #difine, позволяющем присваивать символические имена константам. В общем случае это утверждение записывают так: #define строка1 строка2 (точка с запятой не ставится).
Прежде чем исходный текст программы будет передан компилятору, он обрабатывается препроцессором, котоый всюду в исходном текстезаменит вхождение "строка1" на "строка2". Например, строка #difine max 80, записанная в начале программы, обеспечит всюду замену указанного имени max на соответствующую константу. Замена имени связана не только числами, но и текстами. А теперь вернемся к примерам. В следующей программе (пример 3.9) строится единичная матрица a[m][m], размер которой определяется с помощью конструкции #difine m 5. Сам алгоритм вычисления элементов матрицы основан на возведении (i/j)*(j/i) равно единице тогда и только тогда. когда i равно j. В остальных случаях оно равно нулю.

Пример 3.9

#define M 5 #include <stdio.h> main() { int a[M][M]; int j,i=0; while(i<M) { j=1; while(j<M) { a[i][j]=(i/j)*(j/i); printf("%d",a[i][j]); j++; } i++;printf("\n"); } }

В программе (пример 4.0) определяется минимальный элемент кажой строки матрицы и выполняется обмен местами найденого и диагональю этой же строки.
Обращаем внимание на следующее обстоятельство. Если двумерный массив надо передать ыункции, то описание параметра в ней должно обязательно включать в себя размер строки массива, а размер столбцов несущественен. Так, массив из трех строк и пяти столбцов можно описать как int a[3][5]; либо int a[][5];

Пример 4.0

/*обмен мин с диагональю*/ #include <stdio.h> #define M 4 main() { static a[M][M]={ { 3,4,1,5), {-1,6,7,0}, { 1,8,7,-1}, { 4,9,7,-1}}; int i, j, jmin, amin; i=0; while(i<M) { amin=a[i][0]; jmin=0;j=1; while(j<m) { if(a[i][j]<amin) { amin=a[i][j]; jmin=j; } j++; } a[i][jmin]=a[i][i]; a[i][i]=amin; i++; } i=0 while(i<M) { j=0; while(j<M) printf("%3d",a[i][j++]); printf("\n"); i++; } }

Массивы символов

Любая символьная константа, например "ОЙ У ПОЛИ КРИНИЧКА", представляет собой массив символов. Во внутреннем представлении компилятор завершает такой массив символом "\0", так что любая программа может по нему легко обнаружить конец строки. Поэтому строка занимает в паямяти на один символ больше, чем записано между двойными кавычками. Нумерация элементов массива начинается с нуля. Надо помнить, что, например 'T' - это символ(буква), а ' T ' - это строка, состоящая из двух символов: 'T' и '\0'. Отсюда следует, что пустых строк не бывает.
Строка в языке Си - это разновидность константы и ее можно присваивать некоторой переменной, представляющей массив символов:

char str[]="ТЕКСТ";

Такая запись и короче и понятнее, чем общепринятая для начальной инициализации массивов:

char str[]={'Т','Е','К','С','Т',};

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

Пример 4.1

/*длина сторки*/ length(s); char s[]; { int l=0; while(s[l]!='\0') i++; return(i); } #include <stdio.h> main() { static c