Основы программрования на языке С

=

+m*<количество байт базового типа указателя> Аналогичны правила вычитания целых констант от значения указателя. Кроме того, можно вычитать один указатель из другого. Так, если p1 и p2 – указатели на элементы одного и того же массива, то операция p1-p2 дает такой же результат, как вычитание индексов соответствующих элементов массива. Другие арифметические операции над указателями запрещены, т. е. нельзя складывать два указателя, умножать друг на друга и делить и т. д. 46

Указатели можно сравнивать. Применимы все 6 операций сравнения. Сравнение p # include < ctype.h > /* Пример 26 */ main() { char str[]=”String From Letters in Different Registers”; int i; printf(“Строка Будет Напечатана Заглавными Буквами”); while ( str[i] ) printf(“%c”, toupper(str[i++])); } # include < stdio.h > # include < ctype.h > main() { char str[]=”String From Letters in Different Registers”; 47

char *p; p=str; printf(“Строка будет напечатана строчными буквами”); while ( str[i] ) printf(“%c”, tolower(*p++)); } Если в этих примерах заменить строку на английском языке на строку, набранную русскими буквами, то никакого преобразования букв в строчные, или наоборот, в прописные не произойдет. Это связано с тем, что стандартные функции toupper() и tolower() анализируют значения аргумента и возвращают то же самое значение, если он не является соответственно строчной или прописной буквой латинского алфавита. Если же аргумент является строчной буквой латинского алфавита, то значением функции toupper() будет соответствующая прописная буква (точнее, код этой буквы). Функция tolower() изменяет код только прописных букв латинского алфавита. Прототипы этих функций находятся в файле ctype.h. 4.7. Массивы указателей Указатели, как и переменные любого другого типа, могут объединяться в массивы. Объявление массива указателей на 12 чисел имеет вид int *x[11]; . Каждому из элементов массива можно присвоить адрес; например, пятому элементу этого массива присвоим адрес целой и ранее объявленной переменной y: x[4]=&y;. Если затем необходимо найти значение переменной y, то это можно сделать, выполнив операцию *x[4]. Рассмотрим пример использования массива указателей: # include < stdio.h > # include < string.h > # include < stlib.h > # include < conio.h > /* Пример 27 */ main() { char *ext[]={“exe”,”com”,”dat”,”c”,”pas”,”cpp”}; char ch, sl[80]; for( ; ; ) { do 48

{ printf(“ Файлы с расширением:\n”); printf(“1. exe\n”); printf(“2. com\n”); printf(“3. dat\n”); printf(“4. c\n”); printf(“5. pas\n”); printf(“6. cpp\n”); printf(“7. Exit\n”); printf(“ Ваш выбор: \n”); ch=getche(); printf(“\n”); } while ((ch<’1’)||(ch>’7’)); if ( ch == 7 ) break; strcpy(sl,”dir *.”); strcat(sl,ext[ch-49]; system(sl); } } Данная программа формирует командную строку с учетом пожеланий пользователя и затем выполняет ее, используя библиотечную функцию system(). Данная функция выполняет указанную в командной строке команду (dir – вывод справочника файлов). Расширение для имен выводимых файлов задается пользователем. Константа 49 условно состоит из двух слагаемых – 48 и 1. 48- это символьный код нуля. Поэтому, если пользователь программы хочет вывести файлы с расширением pas , он указывает символьную пятерку, которой соответствует код – 53. Разность 53-49 определяет индекс пятого элемента в массиве ext (первый элемент массива в С имеет нулевой индекс). Часто массив указателей используется, если надо иметь ссылки на стандартный набор строк. Например, для хранения сообщений о возможных ошибках удобно сделать так: char *errors[]={“Cannot open file”, “Cannot close file”, “Allocation error”, “System error” }; 49

При таком объявлении строчные константы будут занесены в раздел констант в памяти, массив указателей будет состоять из четырех элементов, под которые будет выделена память, и эти элементы будут инициированы адресами, указывающими на начало строчных констант. Строчная константа в языке С ассоциируется с адресом начала строки в памяти, тип строки получает char*(указатель на тип char). Поэтому возможно и активно используется следующее присваивание: char *p; p=”Hello, World !”; В языке С возможна ситуация, когда указатель указывает на указатель. В этом случае описание имеет следующий вид: int **point; Здесь point имеет тип указатель на указатель int. Соответственно, чтобы получить целочисленное значение переменной, на которую указывает point, надо в выражении использовать **point. Рассмотрим пример: # include < stdio.h > /* Пример 28 */ main() { int i; int *pi; int **ppi; i=12; pi=&i; ppi=π printf(“i = %d pi = %p ppi = %p **ppi = %d\n”,i,pi,ppi,**ppi); } После того, как указатель был объявлен, но до того, как ему было присвоено значение, указатель содержит неопределенное значение. Попытка использовать такое значение может вызвать ошибку при выполнении программы, и даже, нарушить работу операционной системы. Принято считать, что указатель с неопределенным значением должен иметь значение null, но это не делает такой указатель “безопасным”. С другой стороны нулевой указатель иногда удобно использовать как признак окончания некоторого массива указателей или списка, поэтому он часто фигурирует в операциях сравнения. 50

5. ФУНКЦИИ 5.1. Объявление функций. Оператор return Функция – это некоторая логически законченная совокупность операторов языка, которая выполняет определенную конкретную задачу, и может быть вызвана для своего выполнения необходимое количество раз. Основная форма описания функции имеет вид: Тип < имя функции > ( список параметров ) { тело функции } Тип определяет тип значения, которое возвращает функция с помощью оператора return. Если тип не указан, то по умолчанию предполагается, что функция возвращает целое значение ( типа int ). Список параметров состоит из перечня типов и имен параметров, разделенных запятыми. Функция может не иметь параметров, но круглые скобки в ее описании необходимы в любом случае. В списке параметров для каждого параметра должен быть указан тип. Оператор return имеет два варианта использования. Во-первых, этот оператор вызывает немедленный выход из текущей функции и возврат в вызывающую программу. Вовторых, этот оператор может использоваться для возврата значения функции. В теле функции может быть несколько операторов return, но может быть ни одного. В этом случае возврат в вызывающую программу происходит после выполнения последнего оператора в теле функции. Приведем пример функции, реализующей возведение числа a в натуральную степень b : /* Пример 29 */ float step(float a, int b) { float i; 51

if ( a < 0 ) return (-1); for ( i=1; i<=b; i++) a*=a; return a; } Эта функция возвращает значение –1, если основание отрицательное, и a в степени b , если основание неотрицательное. Другой пример – функция для нахождения наибольшего из двух целых чисел: /* Пример 30 */ int max( int a, int b) { int m; if ( a > b ) m=a; else m=b; return m; } Можно написать эту функцию, не используя дополнительную переменную: /* Пример 31 */ int max( int a, int b) { if ( a > b ) return a; else return b; } Еще короче: int max( int a, int b) { if ( a > b ) return a; return b; } В случае, когда оператор return отсутствует в теле функции, или за ним нет значения, то возвращаемое значение не определено. Если функция должна возвращать значение в соответствии со своим описанием, но не делает этого, компилятор выдаст предупреждение. Все функции, возвращающие значения, могут использоваться в выражениях языка С, но они не могут использоваться в левой части оператора присваива52

ния, за исключением тех случаев, когда возвращаемым значением является указатель. Использование функций, возвращающих указатели, имеет некоторые особенности, так как их значениями являются адреса памяти данных определенного типа. Рассмотрим пример функции, возвращающей указатель на тип char. Эта функция находит в строке первый пробел и возвращает его адрес: /* Пример 32 */ char* find( char* string ) { int i=0; while (( string[i] != ‘ ‘) && (string[i] != ‘\0’)) i++; if ( string[i] == ‘ ‘ ) return &string[i]; else return NULL } Когда функция не должна возвращать никакого значения, она имеет тип void. Например, для вывода на экран горизонтальной строчки, состоящей из заданного символа, начиная с текущего положения курсора, можно использовать следующую функцию: /* Пример 33 */ void gorisont_line( char ch ) { int i; for ( i=0; i<80; i++ ) printf(“%c”,ch); } Если для функции, которая не возвращает значение, не объявить тип void, то она по умолчанию будет иметь тип int, что вызовет предупреждающее сообщение компилятора. Объявление типа возвращаемого значения функции, даже если в этом нет необходимости, является хорошим неформальным правилом при программировании. 5.2. Прототипы функций Особенностью стандарта ANSI языка С является то, что для создания правильного машинного кода функции ему необходимо сообщить до ее первого вызова тип возвращаемого результата, а также количество и 53

типы аргументов. Для этого в языке С используется понятие прототипа функции. Прототип функции задается следующим образом: Тип < имя функции> ( список параметров ); Использование прототипа функцией является ее объявлением. Чаще всего прототип функции полностью совпадает с заголовком в описании функции, хотя это и не всегда так. При объявлении функции компилятору важно знать имя функции, количество и тип параметров и тип возвращаемого значения. При этом имена формальных параметров не играют никакого значения и игнорируются компилятором. Поэтому прототип функции может выглядить как: /* Пример 34 */ int func( int a, float b, char* c); или так int func( int , float , char* ); Рассмотрим пример: # include < stdio.h > float sqr( float a ); main() { float b=7.8; printf(“ Квадрат числа %f равен %f”,b,sqr(b)); } float sqr(float a) { return a*a } Если функция не имеет аргументов, то при объявлении прототипа такой функции следует вместо аргументов писать ключевое слово void. Использование данного ключевого слова необходимо и при объявлении функции main(). Такое объявление может иметь вид void main(void) или main(void). 5.3. Область действия и область видимости Область действия переменной – это правила, которые устанавливают, какие данные доступны из данного места программы. В языке С каждая функция – это отдельный блок программы. Попасть в тело функции нельзя иначе, как через вызов данной функции. 54

В частности, нельзя оператором локального перехода goto перейти в середину другой функции. С точки зрения области действия переменных различают три типа переменных: глобальные, локальные и формальные параметры. Правила области действия определяют, где каждая из них может применяться. Локальные переменные – это переменные, объявленные внутри блока, в частности внутри функции. Язык С поддерживает простое правило: переменная может быть объявлена внутри любого блока программы. Локальная переменная доступна внутри блока, в котором она объявлена. Вспомним, что блок открывается фигурной скобкой и закрывается фигурной скобкой. Область действия локальной переменной – блок. Локальная переменная существует пока выполняется блок, в котором эта переменная объявлена. При выходе из блока эта переменная (и ее значение) теряется # include < stdio.h > void ff( void ); /* Пример 35 */ main ( void ) { int i=1; ff(); printf(“ В функции main значение i равно %c\n”,i); } void ff(void) { int i=12; printf(“ В функции ff значение i равно %c\n”,i); } Пример показывает, что при вызове функции значение переменной i, объявленной в main(), не изменилось. Формальные параметры – это переменные, объявленные при описании функции как ее аргументы. Функции могут иметь некоторое количество параметров, которые используются при вызове функций для передачи значений в тело функции. Формальные параметры могут использоваться в теле функции так же, как локальные переменные, которыми они по сути дела и являются. Область действия формальных параметров – блок, являющийся телом функции. 55

Глобальные переменные – это переменные, объявленные вне какойлибо функции. В отличие от локальных переменных глобальные переменные могут быть использованы в любом месте программы, но перед их первым использованием они должны быть объявлены. Область действия глобальной переменной – вся программа. Использование глобальных переменных имеет свои недостатки: – они занимают память в течение всего времени работы программы; – использование глобальных переменных делает функции менее общими и затрудняет их использование в других программах; – использование внешних переменных делает возможным появление ошибок из-за побочных явлений. Эти ошибки, как правило, трудно отыскать. 5.4. Классы памяти В языке С имеется инструмент, позволяющий управлять использованием памяти и , тем самым, создавать гибкие программы. Этот инструмент – классы памяти. Каждая объявленная переменная принадлежит к одному из четырех классов памяти, которые описываются следующими ключевыми словами: auto – автоматическая; extern – внешняя; static – статическая; register – регистровая. Тип памяти указывается модификатором – ключевым словом, стоящим перед указанием типа переменной. Например, static int sum; register int plus. Если ключевое слово перед спецификацией типа локальной переменной при ее объявлении нет, то по умолчанию она принадлежит классу auto. Поэтому практически это слово не используется. Автоматические переменные (auto) имеют локальную область действия. Они известны только внутри блока, в котором определены. Другие функции могут использовать то же имя, но это должны быть переменные, относящиеся к разным блокам. Автоматическая переменная создается (под нее отводится память) при входе в блок функции. При выходе из блока автоматическая переменная пропадает, а область памя56

ти, в которой находилась эта переменная, считается свободной и может использоваться для других целей. Автоматические переменные хранятся в оперативной памяти, точнее в той области памяти, которая отводится под стек. Регистровые (registr) переменные хранятся в регистрах процессора, доступ к которым значительно быстрее, чем к автоматическим переменным. В остальном регистровые переменные аналогичны автоматическим переменным. Регистровая память процессора невелика, и если доступных регистров нет, то переменная становится простой автоматической переменной. Описание регистровой переменной имеет вид: registr int q; Внешняя переменная (extern) относится к глобальным переменным. Она может быть объявлена как вне , так и внутри тела функции: void ff(void) { …………… extern int x; /* объявление переменной внутри функции*/ …………… } Появление ключевого слова extern связано с модульностью языка С, т. е. возможностью составлять многофайловую программу, где каждый файл компилируется отдельно. Когда мы в одном из файлов опишем вне тела функции глобальную переменную, например так – float global; , то для нее выделится место в памяти в разделе глобальных переменных и констант. Если мы используем эту глобальную переменную в другом файле, то при раздельной компиляции компилятор не будет знать, что это за переменная. Использование объявления extern float global; не приводит к выделению памяти, а сообщает компилятору, что такая переменная будет описана в другом файле. И тогда при компоновке программы, состоящей из нескольких файлов, компоновщик будет искать описание этой переменной и связывать ее с использованием в других файлах. Объявление внешней переменной может быть как вне функции, так и внутри функции. Если это же имя без ключевого слова extern будет объявлено внутри функции, то под этим именем будет создана уже другая автоматическая переменная. Можно к объявлению этой переменной добавить ключевое слово auto, чтобы показать, что вы не ошиблись, а намеренно продублировали имя. Объявлений переменной как внешней может быть несколько, в том числе и в одной функции 57

или в одном файле. Описание же переменной должно быть только одно. Следующие примеры демонстрируют разные способы описания внешних переменных: /* Пример 36 */ int var; /* описана внешняя переменная var */ main(void) { extern int var; /* объявлена та же внешняя переменная */ ………… } func1() { extern int var1; /* объявлена внешняя переменная var1 */ ………… /* переменная var также внешняя*/ } func2() /* переменная var внешняя */ { /* переменная var1 невидима для этой функции */ ………… } int var1; /* описание внешней переменной */ func3() /* для этой функции var1 - внешняя */ { int var; /* здесь var – локальная и не связана*/ ………… /* с соответствующей глобальной */ } func4() /* здесь var является внешней и глобальной */ { auto int var1; /* var1- локальная и автоматическая */ ………… } При описании статических переменных перед указанием типа ставится ключевое слово static. Область действия локальной статической переменной является вся программа. Место в памяти под локальные статические переменные выделяется в начале работы программы в разделе глобальных и статических переменных. Однако область видимости локальных статических переменных такая же, как и 58

у автоматических. Значение статических переменных сохраняется от одного вызова функции до другого. Локальные статические переменные инициализируются нулем, если не указан другой инициализатор. При этом описание с инициализацией static int count=12; вызывает однократную инициализацию переменной count при выделении для нее места. При последующих вызовах функции, в которой описана эта переменная, инициализации не происходит. Это позволяет использовать такую переменную для организации счетчика количества вызовов функции. # include < stdio.h > void trystat(void); /* Пример 37 */ main(void) { int i; for ( i=1; i<=3; i++) { printf(“ вызов - %d\n”,i); trystat(); printf(“ вызов - %d\n”,i); trystat(); } } void trystat(void) { int aut_l=1; static int stat_l=1; printf(“aut_l = %d stat_l = %d\n”,aut_l++,stat_l++); } Можно описать также глобальную статическую переменную, т. е. описать переменную типа static вне любой функции. Отличие внешней переменной от внешней статической переменной состоит в том, что внешняя переменная может использоваться функциями в любом файле, а внешняя статическая переменная может использоваться только функциями того файла, где она описана, причем только после ее определения. Все глобальные переменные, как статические так и нестатические, инициализируются нулем, если в программе не предусмотрено другой 59

инициализации. В табл. 5.1 приведены область действия и продолжительность существования переменных разных классов памяти: Таблица 5.1 Область действия и продолжительность существования переменных разных классов памяти Ключевое слово

Время существования

Область действия

Автоматический Регистровый Статический локальный Статический глобальный

auto registr static static

Временно Временно Постоянно Постоянно

Блок Блок Блок Ф ай л

Внешний

extern

Постоянно

Программа

Класс памяти

В программе может быть описано несколько переменных с одним и тем же именем, но в разных блоках. В нижеприведенном примере объявлена одна глобальная и три локальных переменных с одним и тем же именем var: # include < stdio.h > void ff( void ); void fl( void ); /* Пример 38 */ int var=5; main( void ) { int var=10; printf(“ var = %d\n”,var); /* var = 10 */ { int var=100; printf(“ var = %d\n”,var); /* var = 100 */ } printf(“ var = %d\n”,++var); /* var = 11 */ ff(); printf(“ var = %d\n”,++var); /* var = 12*/ fl(); printf(“ var = %d\n”,++var); /* var = 13 */ fl(); 60

printf(“ var = %d\n”,++var); /* var = 14 */ } void ff( void ) { int var=55; printf(“ var = %d\n”,var); /* var = 55 */ } void fl( void ) { printf(“ var = %d\n”,var); /* var = 5 */ } 5.5. Параметры и аргументы функций В языке С все аргументы функции передаются по значению. При вызове функции в стеке выделяется место для формальных параметров функции, и в это место заносится значение фактического параметра, т. е. значение параметра при вызове функции. Далее функция использует это значение, при этом она может изменить значение параметра. При выходе из функции измененные значения параметров теряются. Таким образом, в языке С вызванная функция не может изменить значения переменных, указанных в качестве фактических параметров при обращении к ней. Например, функция swap(), которая должна менять значение параметров местами, не будет этого делать: /* Пример 39 */ void swap(int a, int b) { int tmp=a; a=b; b=tmp; } Но тем не менее функцию можно приспособить для изменения аргументов. Для этого необходимо в качестве параметра передавать адрес переменной, которую надо изменять, т. е. передавать указатель на переменную. Такой прием в языке С называется передачей параметра по ссылке. Вызванная функция должна описывать аргумент как ссылку и обращаться к фактической переменной косвенно, через эту ссылку. Если 61

в качестве аргумента берется имя массива, то передаваемое функции значение фактически есть адрес первого элемента массива. Теперь функцию swap() можно описать следующим образом: /* Пример 40 */ void swap(int *a, int *b) { int tmp=*a; *a = *b; *b=tmp; } Для иллюстрации использования этих двух способов передачи параметров приводим текст следующей программы: # include < stdio.h > /* Пример 41 */ void swap( int a, int b); void swap1( int *a, int *b); void main( void ) { int x=10, y=20; printf(“ Сначала x = %d y = %d\n”,x,y); swap(x,y); printf(“ Теперь x = %d y = %d\n”,x,y); printf(“ Ничего не изменилось \n”); swap1(&x,&y); printf(“ Теперь x = %d y = %d\n”,x,y); printf(“ Значения поменялись \n“); } void swap(int a, int b) { int tmp=a; a=b; b=tmp; } void swap1(int *a, int *b) { int tmp=*a; 62

*a = *b; *b=tmp; } Результатом работы этой программы будет следующее: сначала x=10 y=20, потом x=20 y=10. Значения переменных x и y изменились, так как были переданы по ссылке. Еще одна особенность состоит в том, что при вызове функции swap() можно задать конкретные значения, например swap(10,20). Вызвать функцию swap1() в виде swap1(&10,&20) нельзя. Если в качестве аргумента функции используется массив, есть лишь один способ – передача параметра по ссылке. Сделать это можно тремя способами: func(int ar[10]); func(int ar[]); func(int *ar); Все три способа дадут один и тот же результат. Рассмотрим программу, где используется функция сортировки массива по возрастанию значений: # include < stdio.h > /* Пример 42 */ void sort(int arr[], int n); void main( void ) { int mass[10]={1,-6,21,3,-7,4,-12,9,5,17}; int i, size=10; printf(“ до сортировки: \n“); for ( i=0; i<10; i++) printf(“%d”,mass[i]); printf(“\n”); sort(mass,size); printf(“ после сортировки: \n“); for ( i=0; i<10; i++) printf(“%d”,mass[i]); } void sort(int arr[], int n); { 63

int i,j,tmp; for ( i=0; i
5.7. Указатель на функцию На функцию, как и на другие объекты языка С можно создать указатель. Указатель pfunc на функцию, на функцию возвращающую значение типа type и имеющую параметры типа type1, type2, объявляется следующим образом: type (*pfunc)(type1 t1,type2 t2); По определению указатель на функцию содержит адрес первого байта или слова выполняемого кода функции. Над указателями на функцию запрещены арифметические операции. Использование указателя на функцию имеет несколько применений, в частности он используется, если необходимо передать функцию как параметр другой функции. Рассмотрим пример использования указателя на функцию: # include < stdio.h > # include < math.h > /* Пример 44 */ double f(double x); double f1(double x); double f2(double x); double ff(double (*pf)(double x), double x); /* указатель на функцию в качестве аргумента*/ void main(void) { double z=2.3, y; double (*ptrf)(double x); /* указатель на функцию */ ptrf=f; /* инициализация указателя */ y=(*ptrf)(z); /* вызов функции через указатель – 1-й способ*/ printf(“z=%f y=%f\n”,z,y); y=ptrf(z); /* вызов функции через указатель – 2-й способ*/ printf(“z=%f y=%f\n”,z,y); ptrf=sin; /* использование стандартной функции*/ y=ptrf(z); printf(“z=%f sin(z)=%f\n”,z,y); y=(*ptrf)(4.6) /* можно таким образом */ printf(“z=%f y=%f\n”,z,y); y=ff(f1,z); /* вызов ff с параметром f1*/ printf(“z=%f y=%f\n”,z,y); 65

y=ff(cos,z); /* другой вызов с использованием стандартной функции*/ printf(“z=%f y=%f\n”,z,y); y=ff(ptrf,z); /* то же через указатель на функцию*/ printf(“z=%f y=%f\n”,z,y); } double f(double x) { puts(“ In f()”); return x; } double f1(double x) { puts(“ In f1()”); return x*x; } double f2(double x) { puts(“ In f2()”); return x*x*x; } double ff(double (*pf)(double x), double x) /* Функция с указателем на функцию в качестве параметра*/ { puts(“ In ff() %f\n”,pf(x)); return pf(x); } При использовании указателей на функции можно образовывать массивы указателей. Такая структура данных называется jump table. Если определены объявления int f0(void); int f1(void); int f2(void); int f3(void); int(*jtable[](void)=(f0,f1,f2,f4); Соответствующую функцию можно вызвать val = (*jtable[i])(); или val = jtable[i](); 66

6. ТИПЫ ДАННЫХ, ОПРЕДЕЛЯЕМЫЕ ПОЛЬЗОВАТЕЛЕМ 6.1. Структура Пользователь при написании программы на языке С может создать пять типов данных: – структуры (structure), – объединения (union), – перечисляемый тип (enumeration), – поля битов (bit fields), – с помощью оператора typedef создать новое имя (псевдоним) для уже существующего типа. Структура объединяет несколько переменных, возможно разного типа. Переменные, которые объединены структурой, называются членами, элементами или полями структуры. Пример определения структуры: /* Пример 45 */ struct student{ char name[30]; int kurs; char group[3]; int stip; }; Объявление структуры является оператором, и поэтому после такого объявления должна состоять точка с запятой. При этом надо понимать, что пока никакая переменная не объявлена, так как выделения памяти под переменную не произошло. Здесь под именем student задан вид структуры, иначе говоря, ее шаблон, и определен новый тип struct student. Для того чтобы объявить конкретные переменные типа struct student, можно записать struct student stud1, stud2; Теперь объявлены две переменные – stud1 и stud2. Компилятор автоматически выделит под них место в памяти компьютора. Под каждую 67

из переменных типа структуры выделяется непрерывный участок памяти. Задание шаблона структуры и объявление переменных может производится и в одном операторе /* Пример 46 */ struct student{ char name[30]; int kurs; char group[3]; int stip; } stud1, stud2; Здесь одновременно задается структура с именем student и объявляются переменные stud1 и stud2. Доступ к конкретному элементу(полю) структуры осуществляется с помощью операции ‘точка’(dot). Например: strcpy(stud1.name, “Петров И.И”); Если необходимо содержимое третьего поля переменной stud2 структуры student напечатать, то надо записать: printf(“%s”,stud2.group); Структуры, как и переменные других типов, могут объединяться в массивы структур. Чтобы объявить массив структур, надо сначала задать шаблон структуры( используем имеющийся шаблон student), а затем объявить массив: Struct student stud1kurs[200]; Этот оператор создаст в памяти 200 переменных типа структуры с шаблоном student и именами stud1kurs[0], stud1kurs[1] и т.д. Для доступа к полю kurs 35-го элемента массива используем stud1kurs[34].kurs Если объявлены две переменные типа структуры с одним шаблоном, можно сделать присваивание stud1 = stud2; При этом произойдет побитовое копирование каждого поля одной переменной в соответствующее поле другой переменной. В то же время нельзя использовать операцию присваивания переменных типа структуры, шаблоны которых описаны под разными именами, пусть даже совсем идентично. Тем не менее в этом случае присваивание возможно для отдельных полей, имеющих один и тот же тип данных. 68

Переменная типа структуры может быть глобальной, локальной переменной и формальным параметром. Можно, естественно, использовать структуру или ее поле как любую другую переменную в качестве параметра функции. Например: func1(right.a); или func2(&left.b); Заметим, что & ставится перед именем структуры, а не перед именем поля. Можно в качестве формального параметра передать по значению всю структуру #include <stdio.h> /* Пример 47 */ struct stru{ int x; char y; }; void ff( struct stru param); main(void) { struct stru arg; arg.x=3; arg.y=’a’; ff(arg); } void ff(struct stru param) { printf(“%d %c\n”,param.x,param.y); } Можно также создать указатель на структуру и передавать аргумент типа структуры по ссылке. Объявить указатель на структуру можно следующим образом: struct stru *adr_pointer; Здесь adr_pointer – переменная указатель на структуру struct stru. Если структура передается по значению, то все поля структуры заносятся в стек. Если структура простая и содержит мало элементов, то это не так страшно. Если же структура в качестве своего поля содержит массив, то 69

стек может переполниться. При передаче по ссылке в стек заносится только адрес структуры. При этом копирования структуры не происходит, а также появляется возможность изменять содержимое полей структуры /* Пример 48 */ struct complex{ float x; float y; } c1,c2; struct complex *a; a = &c1; указателю а присваивается адрес переменной с1. Получить значение поля х переменной с1 можно так: (*a).x; Использование указателей на структуру встречается достаточно часто, например, при программировании задач по созданию и обработке динамических связанных структур данных( очереди, стеки, деревья). Поэтому, кроме способа получить значение поля структуры, используя (*a).x можно использовать другой. В языке С вводится специальная операция -> ( стрелка, arrow). Операция стрелка употребляется вместо операции точка, когда мы хотим использовать значение поля структуры с применением переменной указателя. Вместо (*a).x можно использовать a-> x. Этот способ чаще всего и применяется. Завершая разговор о структурах необходимо сказать, что в качестве полей структуры можно использовать массивы, структуры и массивы структур. Пусть объявления переменных имеют вид Struct addr{ Char city[34]; Char street[76]; Int house; }; struct fulladdr{ struct addr addres; int room; char name[48]; } a,b; 70

Здесь addr – шаблон структуры, определенный перед объявлением структуры fulladdr и объявлением переменной а типа структуры fulladdr. Для присвоения значения полю house структуры addres переменной а используем a.adress.house = 234; 6.2. Доступ к отдельным битам В отличие от многих других языков программирования язык С обеспечивает доступ к одному или нескольким битам в байте или слове. В конкретных задачах часто бывает необходимо, чтобы некоторая переменная принимала только два значения. Для этого достаточно использовать только один бит памяти. Такая переменная, по своему содержательному смыслу, является некоторым признаком или флагом. Один из методов, встроенных в язык С и позволяющий иметь доступ к биту, – это поля битов (bit-fields). В действительности поля битов – это специальный тип членов структуры, в котором определено, из скольких бит состоит каждое поле. Основная форма объявления такой структуры следующая: struct имя_структуры { тип имя1: длина в битах; тип имя2: длина в битах; тип имя3: длина в битах; ... тип имяN: длина в битах; }; В этом объявлении структуры тип может быть одним из следующих: int, unsigned, signed. Имя1 может быть пропущено, тогда соответствующее количество бит не используется (пропускается ). Длина структуры в целом всегда кратна восьми. Так, если указать Struct onebit{ Unsigned one_bit: 1; } obj; Здесь для переменной obj будет выделено 8 бит, но использоваться будет только первый. В структуре также могут быть смешаны обычные переменные и поля битов. 71

6.3. Объединения В языке С определен еще один тип для размещения в памяти нескольких переменных разного типа – объединение( union ). Объявляется объединение также как и структура, например /* Пример 49 */ union u{ int i; char ch; long int l }; Это объявление задает шаблон объединения. Можно объявить переменные union u alfa, beta; Можно было объявить переменные одновременно с заданием шаблона. В отличие от структуры для переменной типа union места в памяти выделяется ровно столько, сколько нужно полю объединения, имеющему наибольший размер в байтах. В приведенном выше примере под переменную alfa будет выделено 4 байта памяти. Действительно, поле i требует 2 байта, поле ch – 1 байт, и поле l – 4 байта. Остальные переменные будут располагаться в том же месте памяти. Синтаксис использования полей объединения такой же, как и для структуры: u.ch = ‘N’; Для объединения также разрешена операция ->, если идет обращение к объединению с помощью указателя. Программа, приведенная ниже, выдает на экран двоичный код символа, вводимого с клавиатуры: #include < stdio.h > #include < conio > /* Пример 50 */ struct byte{ int b1: 1; int b2: 1; int b3: 1; int b4: 1; int b5: 1; 72

int b6: 1; int b7: 1; int b8: 1; }; union bits{ char ch; struct byte b; } u; void decode ( union bits b ); main ( void ) { do { b.ch:=getche(); printf(“;”); decode(u); } while ( u.ch != ‘q’); } void decode ( union bits b ) { if ( b.byte.b8 ) printf(“1”); else printf(“0”); if ( b.byte.b7 ) printf(“1”); else printf(“0”); if ( b.byte.b6 ) printf(“1”); else printf(“0”); if ( b.byte.b5 ) printf(“1”); else printf(“0”); if ( b.byte.b4 ) printf(“1”); else printf(“0”); if ( b.byte.b3 ) printf(“1”); else printf(“0”); if ( b.byte.b2 ) printf(“1”); else printf(“0”); if ( b.byte.b1 ) printf(“1”); else printf(“0”); printf(“\n”); } 73

6.4. Перечислимый тип Перечислимый тип ( enumeration ) – это множество поименованных целых констант. Перечислимый тип определяет все допустимые значения которые могут иметь переменные этого типа. Основная форма объявления такого типа следующая: enum имя_типа {список_названий} список переменных; Список переменных может быть пустым. Пример определения перечислимого типа и переменной данного типа enum season { win, spr, sum, aut }; enum season s; Ключом к пониманию сущности перечислимого типа является то, что каждое из имен win, spr, sum, aut представляют собой целую величину. Если эти величины не определены по другому, то по умолчанию они соответсвенно равны нулю, единице, двум и трем. Оператор printf(“%d %d”,win,aut); выдаст на экран числа 0 и 3. Во время объявления типа можно одному или нескольким символам присвоить другие значения, например enum value { one=1,two,three,ten=10,thousand=1000,next}; Если теперь напечатать значения printf(“%d %d %d %d %d\n”,one,two,ten,thousand,next); то на экране появятся числа 1 2 10 1000 1001, т.е. каждый следующий символ увеличивается на единицу по сравнению с предыдущим, если нет другого присваивания. С переменными перечислимого типа можно производить следующие операции: – присвоить переменную типа enum другой переменной того же типа; – провести сравнение с целью выяснения равенства или неравенства; – арифметические операции с константами типа enum (i=win+aut). Нельзя использовать арифметические операции и операции ++ и – для переменных типа enum. Основная причина использования перечислимого типа – улучшение читаемости программ. 74

6.5. Переименование типов Язык С позволяет дать новое название уже существующим типам данных. Для этого используется ключевое слово typedef. При этом создается новый тип данных. Например: typedef char SYMBOL; typedef unsigned UNSIGN; typedef float real; Достаточно часто используется оператор typedef с применением структур: /* Пример 51 */ typedef struct st_tag{ char name[40]; int kurs; char group[5]; int stip; } STUDENT; Теперь для определения переменной можно использовать struct st_tag avar; А можно использовать STUDENT avar;

75

7. ВВОД/ВЫВОД И РАБОТА С ФАЙЛАМИ 7.1. Организация ввода-вывода В языке С отсутствуют специальные операторы ввода-вывода. Все действия, связанные с вводом-выводом, выполняются с помощью функций библиотеки С. Программист может также создать свои собственные функции ввода-вывода на основе библиотечных. При вводе-выводе все данные рассматриваются как поток байтов, связанный либо с файлом на диске, либо с нефайловым физическим устройством (клавиатура, экран монитора, принтер и т. п.). Функции ввода-вывода позволяют выделять из потока и обрабатывать данные различных форматов и размеров, обеспечивая при этом буферизированный форматированный или неформатированный ввод или вывод. Для использования функций ввода-вывода необходимо директивой #include включить файл stdio.h, содержащий объявления функций ввода-вывода, а также определение констант, типов и структур, используемых этими функциями. Открытие потока осуществляется функцией fopen. При успешном открытии эта функция возвращает указатель структуры типа FILE, которая содержит информацию, необходимую для работы с потоком. При ошибке открытия возвращается значение NULL, которое определено как константа в stdio.h. Указатель потока используется в дальнейшем во всех функциях вашей программы, работающих с данным потоком. Количество одновременно открытых потоков ограничевается установками операционной системы. Параметрами функции fopen являются строка, указывающая путь к файлу и его имя, и строка, определяющая тип доступа к потоку. Литерал типа доступа может иметь значения: “r” – для чтения, “w” – для записи, “a” - для записи в конце потока, “r+” – для чтения и записи, “w+” – пустой поток для чтения и записи, “a+” – для чтения и записи в конце потока. Закрытие потока осуществляется функцией fclose. Указатель потока можно позиционировать на любое место в потоке. Для получения текущей позиции в потоке используются функции ftell и fgetpos, для изменения позиции указателя – fseek и fsetpos. В stdio.h определены стандартные указатели потоков: stdin – стандартный ввод(клавиатура), stdout – стандартный вывод(дисплей), stdprn – стандартная печать, stderr 76

– стандартный вывод сообщений об ошибках. Эти указатели можно использовать во всех функциях , требующих указатель файла, без предварительного открытия потока с помощью функции fopen. Кроме того, функции ввода-вывода на терминал (getc, putc и т.п.) не требуют указатель потока, так как используют stdin и stdout. Существуют также функции, реализующие ввод-вывод в текущее окно экрана монитора путем прямой записи в видеопамять ( getch, getche, putch, cprintf и т.д.). Эти функции требуют подключения директивой #include файла conio.h. 7.2. Классификация функций чтения и записи Классификация функций чтения и записи представлена в табл. 7.1. Таблица 7.1 Классификация функций чтения и записи Чтение Объект операции

Последовательность байт Отдельный символ

Форматированные данные

Количество элементов Введенный символ Введенное число Строка Количество введенных полей

fread fgetchar getchar

Данное типа int Строка

Возвращаемое значение

Из потока Из любого Из строки При успешном stdin потока С завершении

fgetc getc getw

gets

fgets

scanf

sscanf Запись

Объект операции

Отдельный символ Строка Форматированные данные

fputc putc putw

puts

fputs

printf

fprintf

0 EOF EOF NULL EOF

Возвращаемое значение

Из потока Из любого Из строки При успешном stdin потока С завершении

Последовательность fputchar байт putchar

При ошибке

sprintf

Выведенный символ Выведенное число Последний символ Количество выведенных байт

При ошибке

EOF EOF EOF EOF

77

Рассмотрим пример программы, которая выводит содержимое файла autoexec.bat в стандартный поток вывода, а также выводит на экран монитора последнии 15 байт этого файла. #include <stdio.h> #include /* Пример 52 */ main(void) { FILE *f; int a; long int n; if((f =fopen(“c:\\autoexec.bat”,”r”))==NULL) /*открываем поток f */ { prinf(“ Ошибка при открытии файла\n”); exit(1); } while((a=fgetc(f)) != EOF /* пока не конец файла читаем в память*/ fputc(a,stdout); /* и выводим в стандартный поток вывода*/ n=-15; fseek(f,n,SEEK_END); /* позиционирование за 15 байт до конца*/ while((a=fgetc(f)) != EOF) /* пока не конец файла читаем в память*/ putchar(a); /* и выводим на экран монитора*/ fclose(f); /* закрываем поток*/ getch(); } 7.3. Функции библиотеки ввода-вывода Библиотека функций ввода-вывода, которые можно использовать при программировании на языке С, весьма разнообразна, что определяет необходимость привести ее полностью. 7.4. Функции для работы с файлами fopen – открывает поток, связанный с файлом filename и типом доступа type. FILE *fopen(char *filename, char *type); fclose – закрывает поток stream. int fclose(FILE *stream); fcloseall – закрывает все открытые потоки. int fcloseall( void ); remove – удаляет файл с именем filename. int remove( char *filename ); rename – переименовывает файл oldname в файл newname. 78

int rename(char *oldname, char *newname); ftell – возвращает положение указателя текущей позиции файла, связанного с потоком stream. Значение возвращается в виде смещения в байтах относительно начала файла. Значение, возвращаемое функцией ftell, в дальнейшем можно использовать при вызове функции fseek. ftell возвращает положение указателя текущей позиции при успешном завершении.При ошибке возвращается значение – 1L. long int ftell( FILE *stream); fseek – устанавливает адресный указатель файла, соответствующий потоку stream, в новую позицию, которая расположена по смещению offset относительно места в файле, определенного параметром fromtwhere. Параметр fromtwhere может иметь одно из трех значений 0, 1 или 2, которые представлены тремя символическими константами, определенными в файле stdio.h, следующим образом: SEEK_SET(0) – начало файла, SEEK_CUR(1) – позиция текущего указателя файла, SEEK_END(2) – конец файла(EOF); Функция fseek возвращает значение 0, если указатель файла успешно перенесен, и ненулевое значение в случае неудачного завершения. int fseek(FILE *stream, long int offset, int fromwhere); fgetpos – сохраняет позицию указателя файла, связанного с потоком stream, в месте, указываемом параметром pos. При успешном завершении fgetpos возвращает 0. int fgetpos(FILE *stream, fpos_t *pos); Здесь и далее fpos_t - предварительно объявленный тип typedef long fpos_t. fsetpos - устанавливает указатель текущей позиции файла, связанного с потоком stream в новую позицию, которая определяется значением, получаемым предшествующим вызовом функции fgetpos. При успешном завершении fsetpos возвращает 0. Int fsetpos( FILE *stream, const fpos_t *pos); 7.5. Функции неформатированного ввода-вывода fgetc – получает символ из потока stream. int fgetc(FILE *stream); fgetchar – получает символ из потока stdin. int fgetchar( void ); 79

fgets – получает строку s длиной не более n символов из потока stream. char *fgets(char *s, int n, FILE *stream); fputc – выводит символ с в поток stream. int fput(int c, FILE *stream); fputchar- выводит символ c в поток stdout. int fputchar(int c); fputs – выводит строку символов string в поток stream. int fputs(char *string, FILE *stream); gets – получает строку символов s из потока stdin. char *gets(char *s); getc – выводит из потока stream символ этого потока. int getc(FILE *stream); getchar – выводит символ из потока stdin. int getchar( void ); putc – выводит символ c в поток stream. int putc(int c, FILE *stream); putchar – выводит символ с в поток stdout. int putchar(int c); puts – выводит строку s в поток stdout. int puts(const char *s); putw – помещает в поток stream целое значение w. int putw(int w, FILE *stream); getw – вводит из потока stream целое число. int getw(FILE *stream); 7.6. Функции блочного ввода-вывода fread – считывает n элементов данных длиной size из потока stream по адресу ptr. size_t fread(void *ptr, size_t size, size_t n, FILE *stream ); Здесь и далее size_t – предварительно объявленный в библиотеке тип typedef usigned size_t. fwrite – записывает n элементов данных длиной size из ptr и поток stream. Size_t fwrite( void *ptr, size_t size, size_t n, FILE *stream); 80

7.7. Функции форматированного ввода-вывода printf – производит форматированный вывод в stdout. int printf(const char *format [,argument,…]); scanf – выполняет форматированный вывод из потока stdin. int scanf(const char *format [,adress,…]); fprintf – посылает форматированный вывод в поток stream. int fprintf(FILE *stream, const char *format [,argument,…]); fscanf – выполняет форматированный ввод из потока stream. int fscanf(FILE *stream, const char *format [,adress,…]); sprintf – производит форматированный вывод в сстроку buffer. int sprintf(char *buffer, const char *format [,argument,…]); sscanf – выполняет форматированный ввод из строки buffer. Int sscanf(const char *buffer, const char *format [,adress,…]); 7.8. Функции ввода-вывода на экран(conio.h) cprintf – осуществляет форматированный вывод на экран. int cprintf(const char *format [,argument,…]); Таблица 7.2 Файлы и их назначение Заголовочный файл

assert.h ctype.h errno.h float.h limits.h locale.h match.h setjmp.h signal.h stdarg.h stddef.h stdio.h stdlib.h string.h time.h

Назначение

Диагностика программ Преобразование и проверка символов Проверка ошибок Работа с числами с плавающей точкой Определение размеров целочисленных типов Поддержка интернациональной среды Математическая библиотека Возможность нелокальных переходов Обработка сигналов Поддержка функций с неопределенным числом параметров Разное Библиотека стандартного ввода-вывода Функции общего назначения Функции работы со строками символов Функции работы с датами и временем

81

getch – читает один символ с консоли без вывода его на экран. int getch(void); getche – cчитывает один символ с консоли и отображает его в текущем текстовом окне экрана. int getche( void ); putch – выводит символ на экран. int putch(int c); Каждая библиотечная функция , определенная стандартом языка С, имеет прототип в соответствующем заголовочном файле. В соответствие со стандартом ANSI языка С должно быть 15 следующих заголовочных файлов (табл. 7.2). На самом деле каждый из компиляторов содержит , как правило больше заголовочных файлов, например – библиотеку функций работы с графическим экраном graphics.h и библиотеку функций для работы с текстовым экраном conio.h.

82

Библиографический список 1. Трой Д. А. Программирование на языке Си для персонального компьютера IBM PC/ Пер.с англ. В. А. Кузьмина; Под ред. И. В. Емелина. М.: Радио и связь, 1991. 429 с. 2. Уинер Р. Язык Турбо Си/ Пер. с англ. М. П. Матенина; Под ред. В. В. Мартынюка. М.: Мир 1991. 384 с. 3. Уэйт М. и др. Язык Си: Руководство для начинающих / М.Уэйт, С. Прата, Д. Мартин; Под ред. Э. А. Трахтенгерца. М.: Мир, 1988. 512 с. 4. Березин Б. И., Березин С. Б. Начальный курс С и С++. М.: ДиалогМИФИ, 1999. 288 с.

83

Оглавление Предисловие ............................................................................................. 1. Основные понятия языка С ................................................................ 1.1. Алфавит, идентификаторы, ключевые слова, комментарии .. 1.2. Примеры простых программ ...................................................... 1.3. Определение некоторых понятий .............................................. 2. Переменные, константы, операции и выражения ........................... 2.1. Базовые типы данных и объявление переменных ................... 2.2. Основная форма объявления переменных ................................ 2.3. Константы .................................................................................... 2.4. Символьные переменные и строки .......................................... 2.5. Инициализация переменных ..................................................... 2.6. Операции ..................................................................................... 2.7. Выражения .................................................................................. 3. Операторы ............................................................................................. 3.1. Условный оператор ..................................................................... 3.2. Оператор множественного выбора ............................................ 3.3. Операторы циклов ....................................................................... 3.4. Операторы break и continue ........................................................ 3.5. Оператор безусловного перехода ............................................... 4. Массивы и указатели ........................................................................... 4.1. Понятие массива, объявление массива ..................................... 4.2. Массивы символов, строки. Функции работы со строками .. 4.3. Двумерные массивы .................................................................... 4.4. Инициализация массивов ........................................................... 4.5. Указатели, объявление указателей, операции над указателями ........................................................................... 4.6. Связь указателей и массивов ..................................................... 4.7. Массивы указателей .................................................................... 5. Функции ................................................................................................ 5.1. Объявление функций. Оператор return .................................... 5.2. Прототипы функций ................................................................... 5.3. Область действия и область видимости ................................... 5.4. Классы памяти ............................................................................. 5.5. Параметры и аргументы функций ............................................. 5.6. Рекурсивные функции ................................................................ 5.7. Указатель на функцию ................................................................ 84

3 4 4 5 8 9 9 11 13 16 18 18 25 27 27 29 32 35 36 37 37 38 41 42 43 47 48 51 51 53 54 56 61 64 65

6. Типы данных, определяемые пользователем ................................... 6.1. Структура .................................................................................... 6.2. Доступ к отдельным битам ....................................................... 6.3. Объединения ............................................................................... 6.4. Перечислимый тип ..................................................................... 6.5. Переименование типов .............................................................. 7. Ввод/вывод и работа с файлами ......................................................... 7.1. Организация ввода-вывода ......................................................... 7.2. Классификация функций чтения и записи ............................. 7.3. Функции библиотеки ввода-вывода .......................................... 7.4. Функции для работы с файлами ................................................ 7.5. Функции неформатированного ввода-вывода ......................... 7.6. Функции блочного ввода-вывода .............................................. 7.7. Функции форматированного ввода-вывода ............................. 7.8. Функции ввода-вывода на экран(conio.h) ................................ Библиографический список ....................................................................

67 67 71 72 74 75 76 76 77 78 78 79 80 81 81 83

85

Учебное издание

Кучин Николай Валентинович Павлова Марина Михайловна

ОСНОВЫ ПРОГРАММИРОВАНИЯ НА ЯЗЫКЕ СИ Учебное пособие

Редактор А. В. Семенчук Компьютерная верстка А. Н. Колешко Лицензия ЛР №020341 от 07.05.97. Сдано в набор 11.09.01. Подписано к печати 04.10.01. Формат 60×84 1/16. Бумага тип. №3. Печать офсетная. Усл. печ. л. 4,65. Усл. кр.-отт. 4,77. Уч. -изд. л. 5,0. Тираж 100 экз. Заказ № Редакционно-издательский отдел Лаборатория компьютерно-издательских технологий Отдел оперативной полиграфии СПбГУАП 190000, Санкт-Петербург, ул. Б. Морская, 67