Пример1 #include <stdio.h> #include <math.h> main() { int n; /* количество чисел */ int a, /* очередное число */ s=0, /* сумма */ i; /* порядковый номер числа в последовательностити */ printf ("\nВведите количество чисел: "); scanf ("%d", &n); printf ("Введите числовую последовательность:\n"); for (i=1; i<=n; i++) { scanf ("%d", &a); if (abs(a) < i*i) s=s+a; } printf ("сумма=%d\n", s); return 0; }

Результаты тестирования программы в примере1:

Введите количество чисел: 6 Введите числовую последовательность: 1 -2 3 16 -5 40 сумма=-4 Введите количество чисел: 4 Введите числовую последовательность: -1 5 10 -20 сумма=0

Пример2#include <stdio.h>#define W 0 /* признак конца последовательности */main( ){ float a, /* текущее число

*/ s = 0; /* сумма чисел

*/int n = 0; /* количество чисел */printf("\n Введите последовательность чисел, заканчивающуюся нулем\n");scanf ("%f", &a);while (a != W){ s += a; n++; scanf("%f", &a);}if (n != 0){ printf ("Сумма = %.2f\n", s); printf ("Среднее арифметическое = %.2f\n ", s/n);}else printf ("Пустая последовательность"); return 0;}

Результаты тестирования программы в примере2:

Введите последовательность чисел, заканчивающуюся нулем

2 3.5 1.5 5 0

Сумма = 12.00

Среднее арифметическое = 3.00

Введите последовательность чисел, заканчивающуюся нулем

0

Пустая последовательность

Пример3

/* Определение максимального элемента *//* числовой последовательности */#include <stdio.h>main( ){ float a, max; /* Текущее число, текущий максимум */ int k; /* Количество введенных чисел

*/printf ("\nВведите последовательность чисел\n");k = scanf("%f", &max); /* ввод 1-го числа

*/if (k < 1) printf ("\nВходная последовательность пуста\n");else{ while (scanf("%f", &x) != EOF )

if (x > max) max = x; printf ("\nМаксимум= %f\n", max);} return 0;}

Пример4

#include <stdio.h>main( ){ float apred, a; /* предыдущее и текущее числа

*/ int flag = 1; /* признак знакочередования

*/ /* flag=1- знаки чередуются, 0 – нет */printf ("\nВведите последовательность чисел\n");scanf("%f", &apred);

while( scanf("%f", &a)>0) { if (apred * a >= 0) flag = 0; apred = a; } if (flag) printf ("Знаки чередуются."); else printf ("Знаки не чередуются."); return 0;}

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

Примеры символьных констант:‘*’ ‘a’ ‘5’ ‘n’Специальные (управляющие) символьные константы:'\n' новая строка (new line),'\t' '\v' табуляция горизонтальная, вертикальная,'\b' возврат на шаг (backspace),'\\' - \ (обратный слэш)'\'' - ' (апостроф)'\"' - " (кавычка),'\0' нуль-символ (байт с нулевым кодом). Кодировка цифровых символов (символ и его числовой код):'0' = 48'1' = '0' + 1 = 49'2' = '0' + 2 = 50. . .'9' = '0' + 9 = 57 Отсюда соотношения:Код цифры = '0' + Значение цифрыЗначение цифры = Код цифры - '0'

Последовательная обработка символовПример Вывести коды введенных с клавиатуры символов. Последовательность символов завершается нажатием клавиши Enter./* Коды символов */#include <stdio.h>#include <conio.h>main(){ char sim; /* очередной символ */ printf("\n Введите строку символов\n"); while((sim=getchar()) != '\n') printf("%c = %d, ", sim, sim); printf("\nНажмите любую клавишу");getch(); /* чтение кода нажатой клавиши без отображения символа на экране*/ return 0;Оператор while в программе можно записать иначе – с использованием функции putchar():while((sim=getchar()) != '\n') { putchar(sim); printf(" = %d, ", sim); }

Пример Дан текст произвольной длины, оканчивающийся точкой. Проверить, есть ли в

тексте сочетания "ВА".#include <stdio.h>main(){ char s; /* текущий символ текста */ char prs; /* предыдущий символ */ short net=1; /* признак, имеется ли "ВА" в тексте */ /* net=1, если "ВА" нет */ /* net=0, если "ВА" есть */ printf ("\nВведите текст.\n"); s=getchar(); /* чтение первого символа */ if (s!='.') { do { prs=s; s=getchar(); if (prs=='В' && s=='А') net=0; } while (s!='.'); } if (net) printf ("В тексте нет 'ВА'.\n"); else printf ("В тексте есть 'ВА'.\n"); return 0;}

Обработка массивовМассивы

Массив - упорядоченная последовательность пронумерованных элементов одинакового типа.

Индекс - номер элемента массива. Индексы элементов массива начинаются с нуля. Элемент массива может иметь несколько индексов. Размерность массива - количество индексов каждого элемента.

Вектор - одномерный массив (один индекс).

Матрица – двумерный массив (первый индекс - номер строки, второй - номер столбца).

Язык Си не имеет встроенных средств для ввода-вывода массива целиком, поэтому массив вводят и

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

#include <stdio.h>void main(void){ double a[100]; int n, i; printf("Введите количество чисел n = "); scanf("%d", &n); if( n>(sizeof a)/sizeof(double) ) { printf("Слишком много элементов\n"); return; } for(i=0; i<n; i++) { printf("a[%d] = ", i); scanf("%lf", &a[i]); } /* Операторы, обрабатывающие массив */}

Подсчет числа элементов, вводимого массива, при этом ввод завершается при появлении во входном потоке признака конца данных. Таким признаком в следующей программе

служит число большее 1.0e300#include <stdio.h>void main(void){ double a[100], temp; int n, end; for(end=n=0; n<(sizeof a)/sizeof(double); n++) { printf("a[%d] = ", n); scanf("%lf", &temp); if( temp>=1.0e300 ) { end=1; break; } a[n] = temp; } if( end ) { /* Операторы, обрабатывающие массив */ } else printf("Переполнение массива\n");}

Использование и обработка массивов

Примеры: int a[2][3]; /* представлено в виде матрицы a[0][0] a[0][1] a[0][2] a[1][0] a[1][1] a[1][2] */ double b[10]; /* вектор из 10 элементов имеющих тип double */ int w[3][3] = { { 2, 3, 4 }, { 3, 4, 8 }, { 1, 0, 9 } };В последнем примере объявлен массив w[3][3]. Списки, выделенные в фигурные скобки, соответствуют строкам массива, в случае отсутствия скобок инициализация будет выполнена неправильно.

Примеры:

int s[2][3];

Если при обращении к некоторой функции написать s[0], то будет передаваться нулевая строка массива s.

int b[2][3][4];

Пример объявления символьного массива. char str[] = "объявление символьного массива";

Пример1/*обращение массива*/#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++]);}

Пример2

/*в массиве найти разность    мин. и макс. элементов */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);}

Пример2

#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

/*макс одинаковых подряд*/#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);}

Пример4

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

Пример5

/*обмен мин с диагональю*/#include <stdio.h>#define M 4main(){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;

Пример5

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++;}

Пример5

a[i][jmin]=a[i][i];a[i][i]=amin;i++;}i=0while(i<M){j=0;while(j<M)printf("%3d",a[i][j++]);    printf("\n");i++;}}

Указатели

Язык Си имеет средства работы непосредственно с областями оперативной памяти ЭВМ, задаваемыми их адресами (указателями). В языке C указатели строго типизированы, т. е. различают указатели (адреса) символьных, целых, вещественных величин, а также типов данных, создаваемых программистом.

Для указателей одного и того же типа допустимой является операция присваивания, кроме того

указателю типа void может быть присвоено значение

адреса данного любого типа, но не наоборот, например int *a, *b;

double *d;

void *v;

...

a = b; /* Правильно */

v = a; /* Правильно */

v = d; /* Правильно */

b = v; /* Неправильно */

d = a; /* Неправильно */

Для поддержки адресной арифметики в языке Си имеются две специальные операции - операция взятия адреса & и операция получения значения по заданному

адресу * (операция разадресации).Рассмотрим работу вышеописанных операций на следующем примере

int *p, a, b; double d; void *pd;p = &a;*p = 12;p = &b;*p = 20;/* Здесь a содержит число 12, b - число 20 */pd = &d;*( (double *) pd ) = a;/* Здесь d содержит число 12.0 */

Состояние ячеек до первого присваивания

P, адрес 1000

a, адрес 2000

b, адрес 4000

мусор мусор мусор

Состояние ячеек после присваивания p = &a

p, адрес 1000 a, адрес 2000 b, адрес 4000

2000 мусор мусор

Состояние ячеек после присваивания *p = 12

p, адрес 1000

a, адрес 2000

b, адрес 4000

2000 12 мусор

Состояние ячеек после присваивания p = &b

p, адрес 1000 a, адрес 2000 b, адрес 4000

4000 12 мусор

Состояние ячеек после присваивания *p = 20

p, адрес 1000 a, адрес 2000 b, адрес 4000

4000 12 20

Следует также опасаться случая, когда указатель содержит адрес объекта программы, завершившего свое существование. Например,

результат работы следующей программы неверен и непредсказуем: #include <stdio.h>#include <math.h> double * Cube(double x){ double cube_val; cube_val = x*x*x; return &cube_val;} void main(void){ double *py; py = Cube(5); printf("y1 = %lf\n", *py); sin(0.7); printf("y1 = %lf\n", *py);}

Динамическое выделение памяти

Данные, которые создаются, инициализируются и уничтожаются по требованию программиста называются динамическими. Для управления такими данными используются специальные стандартные функции, прототипы которых описаны в заголовочном файле <malloc.h> (для некоторых компиляторов <alloc.h>).Для запроса динамической памяти служит функция malloc(), которая имеет следующий прототип: void * malloc(size_t size);

Статические и динамические массивы

int n;int *m; /* указатель (ссылка) */scanf(“%d”, &n);m = (int *) malloc ( n * sizeof(int));/* выделение памяти */if (m == NULL) { printf( “No memory”); return 1;}/* ошибка */for (int i = 0; i < n; i++) scanf(“%d”, &m[i]);…free (m); /* освобождение памяти */return 0; /* успешное завершение */

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

double *A; int n; ... n = 200; ... A = (double *) malloc( n * sizeof(double) ); ... /* Работа с массивом A */ ... free(A);

Подпрограммы

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

Вызов подпрограммы (команда «выполнить подпрограмму») записывается аналогично использованию математической функции: f(a1, a2, ... , an)где f - имя подпрограммы (аналогично имени функции P), a1, a2, ... , an - аргументы вызова (фактические параметры), конкретные величины, подставляемые вместо формальных параметров при выполнении подпрограммы (как аргумент 10 при вычислении значения функции P). Формальный параметр – это входная или выходная переменная подпрограммы, указанная в заголовке ее определения (как x в левой части определения функции P(x)).

Определение функции имеет вид:<Заголовок_ функции>{ <Объявление переменных функции>

// тело <Операторы функции> // функции}Заголовок функции имеет вид: <тип значения> <имя функции> ([<тип> <имя>[,<тип> <имя>] …])Если функция не обладает значением, в качестве типа значения пишется ключевое слово void. Тип значения функции разрешается не указывать. В этом случае (по умолчанию) подразумевается тип int.

Выполнение подпрограммы завершается при выполнении оператора возврата или достижении конца тела функции. Оператор возврата имеет вид:return [<выражение>];В теле функции, обладающей значением, обязательно должен быть оператор возврата, где тип вычисленного выражения должен соответствовать типу значения функции. Значение выражения становится значением функции: оно передается в вызывающую программу и подставляется вместо вызова функции. Оператор возврата вида return; (без выражения) осуществляет возврат в вызывающую программу в точку, следующую за вызовом подпрограммы. Если функция не возвращает значение, оператор возврата может отсутствовать.

Вызов подпрограммы, т.е. команда для выполнения подпрограммы имеет вид:<имя функции> ([<имя> [,<имя>] …])

При вызове подпрограммы (в скобках) определяются имена фактических параметров (аргументы вызова). Фактические параметры подставляются вместо формальных параметров при выполнении подпрограммы.

Вызов функции, обладающей значением (возвращающей значение), в операторе присваивания:<имя переменной> = <имя функции> ([<имя> [, <имя>] …]);

Пример описания функции:/* функция определения наибольшего из двух чисел */float max ( float x, float y ){ if (x>y) return x; else return y;}Пример вызова функции:f = max(a,b) - max(a+b,c);содержит два вызова приведенной выше функции max. При первом обращении функции max передаются значения переменных a и b, она возвращает наибольшее из этих чисел, которое подставляется вместо указателя функции max(a,b). При втором вызове функции max формальным параметрам x и y присваиваются соответственно значения фактических параметров a+b и c. Оператор return возвращает наибольшее из этих значений в точку вызова функции.

Параметры подпрограмм

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

Передача параметров по значению

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

Передача параметров по ссылке.

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

Область действия переменных

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

Пример/* Вариант Б. Вычисление c=n!/(m!*(m-n)!) *//* с помощью функции, возвращающей значение */#include <stdio.h>long fakt (int k); /* прототип функции

*//* Вычисление c = n! / (m! * (n-m)!) */void main(void){ int n, m, c; /* исходные данные и результат */printf("\nВведите два исходных целых числа ");scanf("%d %d", &n, &m);c = fakt(n) / (fakt (m) * fakt (n-m));printf ("\n c = %d", c); }/* Функция k! */long fakt (int k){ long f; /* k!

*/int j; /* текущий множитель */f=1;for (j=2; j<=k; j++)f = f * j;return f; /* значение функции

*/}

Пример#include <stdio.h>int KolLatBukv (char s[]){ int i, /* индекс очередного символа строки s */ k=0; /* количество лат. букв */ for ( i = 0; s[i] != '\0'; i++ ) if(s[i]>='a'&&s[i]<='z'||s[i]>='A'&&s[i]<='Z') k++; return k;}void main(){ char s1[81], s2[81]; /* заданные строки */ printf ("\nВведите две строки символов\n"); gets (s1); gets (s2); printf ("В 1-й строке %d лат. букв\n", KolLatBukv (s1)); printf ("Во 2-й строке %d лат. букв\n", KolLatBukv (s2));}

Пример результата выполнения программы:

Введите две строки символов

AaBbcd 123 Zz

t = x + y * z / 10 ;

В 1-й строке 8 лат. букв

Во 2-й строке 4 лат. букв

Пример

#include <stdio.h>void SumPos (float m[], int n, float *s, int *k) /* Вх. параметры:

m – указатель на заданный массив,n – число элементов массива.

Вых. параметры: *s – сумма положительных элементов массива, *k – количество положительных элементов */{ int i; for (i=0, *s=0, *k=0; i<n; i++) if (m[i] > 0) (*s) += m[i], (*k)++;}

Пример

void main(){ float a[6], /* массив */ s; /* сумма положительных элементов */ int k, /* количество положительных эл-тов */ i; /* индекс элемента массива*/ printf ("\nВведите 6 чисел\n"); for ( i=0; i < 6; i++) scanf ("%d ", &a[i] ); SumPos (a, 6, &s, &k); /* вызов функции */ printf ("Сумма положительных чисел = %f\n", s); printf ("Количество положительных чисел: %d\n", k);}

Рекурсивные функции

Рекурсивная функция – это функция, в определении которой есть обращение к себе самой.Пример. Допустим, нужно вычислить n! (факториал числа n). Значение n! можно представить как произведение n на факториал (n-1) :n! = n*(n-1)!(n-1)! = (n-1)*(n-2)!…

Пример

/* Рекурсивная функция вычисления n! */float fact (int n){ if (n<0) { puts (“Недопустимый аргумент функции fact”);

exit (1); /* завершение выполнения программы */ } if (n==1 || n==0) return 1; return n*fact(n-1);}

Пример вызова этой функции:

int k;

scanf (“%d”, &k);

printf (“%d! = %.0f”, k, fact(k));

Выполнение функции при k=4.

Символьные строки и функции обработки строк

Символьная строка представляет собой последовательность символов, заканчивающуюся нуль-символом (‘\0’ c кодом 0). Строковые константы заключаются в кавычки. При компиляции программы они автоматически дополняются нуль-символом. Строковые переменные объявляются как массивы символов, например:char str[81];char error[] = “Ошибка”; /* массив из 7 символов, включая ‘\0’ */

Для ввода с клавиатуры строки символов служит библиотечная функция gets(), а для вывода – функция puts().

Пример:

char s1[81], s2[81];

char *s3 = “Привет!”;

puts (s3);

puts (“Введите две строки”);

gets (s1);

gets (s2);

В библиотеках Turbo C, Borland C++ имеется ряд функций обработки строк:

- определения длины строки (strlen),

- сравнения строк (strcmp, strncmp),

- копирования строк (strcpy, strncpy),

- сцепления строк (strcat, strncat),

- поиска символа в строке (strchr, strrchr, strpbrk),

- поиска подстроки в строке (strstr).

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

Рассмотрим одну из библиотечных функций - функцию сцепления двух заданных строк strcat(). Определение функции:char *strcat (char *s1, char *s2);Функция копирует строку s2 (на которую ссылается указатель s2) в конец строки s1 и возвращает значение s1 - ссылку на сцепленную строку.Работу функции можно описать так:char *strcat (char *s1, char *s2){ char *rs; /* ссылка на результирующую строку */ rs=s1; /* запоминание адреса начала строки s1 */ while (*s1!='\0') s1++; /* поиск конца строки s1 */ /* копирование строки s2 в конец s1 */ while (*s2!='\0') { *s1=*s2; s1++; s2++; } *s1='\0'; return rs;}

А теперь посмотрите на более компактную (но менее понятную) запись этой функции:char *strcat (char *s1, char *s2){ char *rs; rs=s1; /* запоминание адреса начала строки s1 */ while (*s1!='\0') s1++; /* поиск конца строки s1 */ while ((*s1++ = *s2++) !='\0'); /* копирование s2 в конец s1, включая нуль-символ */ return rs;}

С символьными строками можно работать как с массивами: обращаться к отдельным символам строки с помощью индекса. Ту же функцию сцепления строк можно написать иначе:char *strcat (char *s1, char *s2){ int i=0, j=0; /* индексы символов строк s1 * и s2 */ while (s1[i]) i++; /* поиск конца строки s1 */ while ((s1[i++] = s2[j++])); /* копирование строки s2 в конец s1, включая нуль-символ */ return s1;}

Пример драйвера для функции сцепления строк strcat():

#include <stdio.h>#include <conio.h>void main(){ char str1[81],str2[81]; puts ("Введите две строки"); gets (str1); gets (str2); if (strlen(str1)+strlen(str2) < 81) { puts ("Результат:"); puts (strcat(str1,str2)); printf ("Строки после вызова функции сцепления:\n%s\n%s\n", str1,str2); } else puts ("Не хватает памяти для результирующей строки"); getch();}

Посимвольная обработка строк

Для представления строк могут использоваться массивы символов. Примеры описания такого массива:char text[10]; /* массив из 10 символов */

Для ввода символьных строк можно использовать библиотечную функцию gets():char s[81]; gets(s);

Вывод символьных строк можно выполнить либо с помощью библиотечной функции puts(): сhar str[]= “Привет”;puts(str); /* или printf(“%s\n”, str); */

Структуры

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

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

struct <имя типа>{<список полей>} <имя переменной>;Здесь <имя типа>, <имя переменной> – правильный идентификатор;struct – зарезервированное слово;<список полей> – список полей; представляет собой последовательность разделов структуры, между которыми ставится точка с запятой.

Массив структур можно описать следующим образом:

struct Stud

{

char fam[15], name [15];

int group;

Birthday bd;

float rating;

} PMI[100];

Например:struct ANKETA a1;struct BOOK b1,b2;struct BOOK mb[100]; /* массив из 100 структур типа BOOK*/struct ANKETA *p1; /* указатель на структуру типа ANKETA */struct BOOK *p2 = &b2; /* указатель на структуру типа BOOK, ссылающийся на переменную b2 */При объявлении структурных переменных на языке C++ ключевое слово struct обычно опускается, например:ANKETA a1;BOOK b1,b2;

Пример/* ввод значения структурной переменной b2 типа BOOK*/gets(b2.author);gets (b2.name);scanf(“%d%d”, &b2.year, &b2.pages);Примерstruct ANKETA a2;strcpy(a2.fio, “Иванов А.В.”);а2.gr = 1980;strcpy(a2.adr, “ул.Пушкина, д.10, кв.5”);Примерstruct BOOK *p3 = &b3;printf (“%s, %s, %d г., %d с.\n”, p3->author, p3->name, p3->year, p3->pages); Результат на экране:Толстой Л.Н., Война и мир, 1995 г., 1650 с.

Если структурные переменные используются только в одной функции программы, то можно совместить описание переменных с описанием типа. При этом имя типа можно не задавать, например:

struct

{ char fio[20];

int gr;

char adr[40];

} a1, a2, *p1;

Работа с файлами

Файл – это поименованная область на диске, содержащая какую-либо информацию, например, текст программы, данные для программы, документ.

Файлы бывают текстовые и двоичные (бинарные).

Работа с файлами

Текстовые файлы – это файлы, которые создаются или которые можно просмотреть с помощью текстовых редакторов. В операционной системе MS DOS текстовые файлы представляют собой последовательность символьных строк. Каждый символ занимает один байт. Строка заканчивается двумя символами: «возврат каретки» (с кодом 13) и «перевод строки» (с кодом 10).

Работа с файлами

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

Для чтения информации из файла служат функции:

fscanf() – форматированный ввод,fgets() – чтение одной строки,fgetc() – чтение одного символа,fread() – ввод заданного числа байтов (символов).Для записи информации в файл используются функции:fprintf() – форматированный вывод,fputs() – вывод строки,fputc() – вывод одного символа,fwrite() – вывод заданного числа байтов (символов).

Некоторые функции доступа к файлам

fopen – открытие файла.Прототип функции:FILE * fopen (char * fname, char * mode);Первый параметр fname задает имя открываемого файла, второй – режим открытия файла или вид его обработки. Параметр mode может задаваться в виде:“r” – чтение файла,“w” – запись в файл (если файл существует, он стирается),“a” – добавление информации в конец файла,“r+” – чтение и запись.

ПримерFILE *fout, *fmod; /* указатели на выходной и модифицируемый файлы */char fname[13]; /* имя модифиц. файла */fout = fopen (“f1.txt”, “w”);puts(“Введите имя модифицируемого файла”);gets (fname);if ((fmod = fopen(fname, “r+”) ==NULL){ puts (“Файл в текущем каталоге не найден”); exit (1);}

Задача. Входной файл st.txt содержит сведения о сдаче студентами группы экзаменационной сессии. Каждая запись файла содержит фамилию и инициалы студента (15 символов) и пять оценок (5 символов) и завершается символом ”перевод строки”. Напечатать список студентов с указанием среднего балла каждого студента.

Программа:/*-----------------------------------------*//* Печать среднего балла каждого студента *//*-----------------------------------------*/#include <stdio.h>#include <conio.h>struct STUDENT{ char fio[15]; /* фамилия и.о. */ char oc[7]; /* 5 оценок + '\n' + '\0' */};void main(){ FILE *f; /* указатель на входной файл */ struct STUDENT tz; /* текущая запись файла */ int i, s; /* сумма оценок */

if ((f= fopen("st.txt","r")) == NULL) { puts ("Файл st.txt не найден"); return; } puts ("\nФамилия и.о. Ср.балл"); puts ("------------------------------"); while (fgets((char *)&tz, sizeof(struct STUDENT), f) != NULL) { for (i=0,s=0; i<5; i++) s+=tz.oc[i]-'0'; tz.fio[14]='\0'; printf("%s %.1f\n", tz.fio, (float)s/5); } fclose(f); getch();}

Массивы и функции как параметры

Указатели на функцииФункции, как и другие объекты программы, располагаются в памяти ЭВМ. Любая область памяти имеет адрес, в том числе и та, в которой находится функция. Имя функции без круглых скобок за ним представляет собой константный адрес этой области памяти. Таким образом, имея функции со следующими прототипами: double sin(double x);double cos(double x);double tan(double x);

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

double (*fn)(double x);

После того, как описан указатель на функцию, становятся возможными следующие операции: fn = sin; /* Настройка указателя на функцию sin */a = fn(x); /* Вызов функции sin через указатель */fn = cos; /* Настройка указателя на функцию cos */b = fn(x); /* Вызов функции cos через указатель */

Можно описать массив указателей на функцию и проинициализировать его: double (*fnArray[3])(double x) = { sin, cos, tan }; Теперь становится возможным следующий цикл: for(i=0; i<3; i++)printf( "F(x) = %lf\n", fnArray[i](x) );

Можно описать функцию возвращающую значение указателя на функцию: double (*fnFunc(int i)) (double x){ switch(i) { case 0 : return sin; case 1 : return cos; case 2 : return tan; }}

После описания функции fnFunc становится возможным следующий цикл: for(i=0; i<3; i++)printf( "F(x) = %lf\n", fnFunc(i)(x) );

Массивы и указатели

В языке C понятие массива тесно связано с понятием указателя. Действительно, как было описано выше, имя массива представляет собой адрес области памяти, распределенной под этот массив, или иными словами адрес первого элемента массива. Пусть описаны следующие данные:

int a[100], *pa;

и осуществлено присваивание:

pa = a;

Два существенных отличия массива от указателя:

массиву при описании выделяется память для хранения всех его элементов, а указателю только для хранения адреса;

адрес массива навсегда закреплен за именем, то есть имя массива является адресной константой и выражение вида a = pa недопустимо.

Пример

double A[100], *pA, *pA100; int i;/* Заполняем массив A. Работаем с массивом */for (i=0; i<100; i++) A[i]=0;/* Заполняем массив A. Работаем с указателями */for (pA=A, pA100=pA+100; pA<pA100; pA++) *pA=11.9;

Указатели и двумерные массивыПусть имеются следующие определения массивов и указателей: int A[4][2], B[2];int *p, (*pA)[4][2], (*pAstr)[2]; Здесь A представляет собой двумерный массив из четырех строк и двух столбцов, B - одномерный массив из двух элементов. Для каждого из этих массивов будет выделено соответствующее количество памяти, достаточное для хранения всех их элементов.Указатель p представляет собой указатель на величину int, указатель pA - указатель на двумерный массив из четырех строк и двух столбцов, pAstr - указатель на одномерный массив из двух элементов.

Для вышеописанных указателей допустимы следующие операции присваивания, поскольку слева и справа от операции присваивания находятся указатели на один и тот же тип данных: p = B;p = &B[1];p = &A[0][0];p = A[2]; Следующее присваивание: p = A; /* неверно */ является неверным, так как слева от операции присваивания находится указатель на тип int, а справа - указатель на первый элемент массива A, который (элемент) представляет собой массив из двух элементов типа int. В таких случаях компиляторы выдают предупреждающее сообщение о подозрительном преобразовании указателя.

Следующие присваивания корректны pA = &A; /* Указатель на двумерный массив */pAstr = &B; /* Указатель на одномерный массив */ и устанавливают следующее соответствие элементов: (*pA)[i][j] эквивалентно A[i][j](*pAstr)[i] эквивалентно B[i] Массивы указателей удобны для хранения символьных строк: char *str[] = {"Строка 1","Строка 2","Длинная строка 3"};

Пример#include <stdio.h>#define N 3void p1(int *m,int k){ int i; for(i=0;i<k;printf("%d",m[i++])); puts("\n");}void p3(int *m,int k){ int i; for(i=k-1;i>=0;printf("%d",m[i--])); puts("\n");}

Пример

void p2(void p(int *,int), int *mm,int nn){ p(mm,nn);}void main(){ int mas[N],i; for(i=0;i<N;mas[i++]=i); p2(p1,mas,N); p2(p3,mas,N);}

Технологии программирования

В проектировании и программировании активно применяются следующие технологии:

Структурное программирование.

Модульное программирование.

Объектно-ориентированное программирование.

Компонентное программирование.

Структурное программирование…

Э. Дэйкстра (60-е годы): Для любой простой программы можно

построить функционально эквивалентную ей структурную программу, т.е. программу, сформированную на основе фиксированного базисного множества, включающего:

структуру последовательного действия,структуру выбора одного из двух действийструктуру цикла, то есть многократного

повторения некоторого действия с проверкой условия остановки повторения.

Структурное программирование…

Простая программа – ровно один вход и один выход.

Базисные конструкции:

Структурное программирование

Стандартизация и линейность программы – снижение сложности.

Некоторые соображения:Алгоритм должен иметь 1 вход и 1 выход.Никаких goto.Нет зависимости от языка программирования.Ясен набор операторов, который необходим в языках программирования.

Модульное программирование...

Основная идея: разбиваем сложную задачу на подзадачи, каждую из них при необходимости разбиваем снова и т.д.

Получаем простые задачи, их решаем, объединяем.

Модульное программирование

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

Более высокий уровень абстракции.Настройка на конкретную задачу.Возможности повторного использования.Возможности коллективной разработки – разделение труда.

Объектно-ориентированное программирование...

Дальнейшая борьба со сложностью.

Технология работает с этапа анализа.

Анализ – Проектирование – Программирование.

В основе – объектная модель и объектная декомпозиция.

Объектно-ориентированное программирование

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

Объектная декомпозиция (в отличие от алгоритмической): элементы проекта – классы и объекты (а не алгоритмы). И только потом данные и алгоритмы.

Компонентное программирование...

Компонентное программирование – развитие объектно-ориентированной идеологии.

Введен следующий уровень абстракции – классы объединяются в компоненты.

Основной принцип компонентного программирования: сборка приложения из готовых компонент, в общем случае написанных на разных языках.

Компонентное программированиеКомпонент:

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

м.б. использован в неизменном виде

может допускать настройку

обладает поведением (функциональностью).

Компонент изолирован от внешнего мира своим интерфейсом – набором методов (их сигнатурами).

Компонентная программа – набор независимых компонент, связанных друг с другом посредством интерфейсов.

Структурная декомпозиция и нисходящее программирование

Задача

Дано целое n и вещественные x1, x2, ..., xn. Составить программу печати заданных вещественных чисел в порядке возрастания (не убывания).

Вход:

Введите количество чисел: 5

Введите числа: 12.5 6 14 -3 10

Выход:

Упорядоченные числа:-3.0 6.0 10.0 12.5 14.0

Функциональная структура программы

main

Vvod Sort

1 этап.

Разработка алгоритма функции main().

Алгоритм :

1. n = Vvod(x); /* Ввод n и массива x */

2. Sort (x,n); /* Сортировка массива x по возрастанию*/

3. Вывод сортированного по возрастанию массива x

2 этап

Алгоритм функции ввода данных

Алгоритм функции ввода данных

int Vvod (float x[])

{

Ввод n;

for (i=0; i<n; i++)

Ввод x[i];

Возврат n;

}

Вывод массива x

Вывод заголовка "Упорядоченные числа:";

for (i=0; i<n; i++)

Вывод x[i];

Метод последовательного нахождения максимума

2.5 6 14 -3 10 // рассматривается n элементов2.5 6 10 -3 14

2.5 6 10 -3 // рассматривается n-1 элементов2.5 6 -3 10 2.5 6 -3 // рассматривается n-2 элементов2.5 -3 6

2.5 - 6 // рассматривается n-3 элементов-3 2.5

Алгоритм функции сортировки массива x по возрастанию

void Sort (float x[], int n)

{ for (k=n-1; k>0; k--)

{ Определение максимума среди

элементов x[0], ... , x[k] и его

индекса imax.

Обмен: x[imax] <--> x[k];

}

3 этап

Определение максимума среди элементов x[0], ... , x[k] и его индекса imax.

Фрагмент программы:

imax =0;

for (i =1; i <= k; i++)

if (x[i] > x[imax]) imax = i;

Программа:#include <stdio.h>#define NMAX 100 /* Макс-е количество входных чисел */ /* Функция ввода данных * /int Vvod (float x[]){int n; /* Количество чисел */int i; /* Индекс текущего числа */printf ("\nВведите количество чисел\n");scanf ("%d", &n);printf ("Введите числа\n");for (i=0; i<n; ++i)

scanf("%f", &x[i]);return n;}

/*Функция сортировки массива по возрастанию*/void Sort (float x[], int n) { int k; /* Максимальный индекс просмотра*/ float r; /* Для обмена */ int imax; /* Индекс максимального элемента */ int i; /* Индекс текущего числа */ for (k=n-1; k>0; k--) { imax =0; for (i =1; i <= k; i++) if (x[i] > x[imax]) imax = i; /* Обмен x[imax] и x[k] */ r = x[imax]; x[imax] = x[k]; x[k] = r; }}

/* Главная функция */void main (void){ float x[NMAX]; /* Обрабатываемые числа*/ int n; /* Количество чисел */ int i; /* Индекс текущего числа */ /* 1. Ввод массива x */ n = Vvod(x); /* 2. Сортировка массива x по возрастанию */ Sort(x,n); /* 3. Вывод массива x */ printf("Упорядоченные числа:\n"); for (i=0; i<n; ++i) printf (" %4.1f", x[i]);}

Модульное программирование

Технология модульного программирования предполагает разбиение программы на отдельные части – модули. Модуль может содержать одну или несколько взаимосвязанных функций и общие для функций данные. Каждый модуль помещается в отдельный файл (с расширением .c или .cpp) и компилируется автономно. Получившиеся в результате компиляции объектные модули объединяются в единый исполняемый модуль (exe-файл) с помощью компоновщика (Linker).

При разработке многомодульных программ нужно создавать проект (файл с расширением .prj). В проекте указывают, из каких файлов состоит программа. Это могут быть исходные файлы с расширением .c или .cpp, или объектные файлы с расширением .obj (полученные в результате компиляции исходных модулей), или библиотеки объектных модулей (файлы с расширением .lib). Заголовочные файлы (с расширением .h) в проекте не указывают, они должны быть в том же каталоге, в котором содержатся модули программы.

Окно диалога “Open Project File”

Окно диалога “Add to Project List”

Пример создания многомодульной программы

#include <stdio.h>#include <stdlib.h>#include <string.h>#include <conio.h>#define MAXDL 9 /* макс. длина идентификатора (с признаком конца '\0' ) */ struct EL_SP /* тип элемента списка */ { char id [MAXDL];/* идентификатор */ struct EL_SP *sled; /* ссылка на следующий элемент */ };void Vkl ( struct EL_SP **p, char t_id[] );void PechSp ( struct EL_SP *p );

Файл “Vkl.c”: #include "spisok.h"/*-------------------------------------------------*//* функция включения очередного идентиф. в список *//*-------------------------------------------------*/void Vkl ( struct EL_SP **p, char t_id[] ) /* Вх. данные: *p - указатель списка идентификаторов в лексикографическом порядке, t_id - включаемый в список (текущий) ид-р */ /* Вых. данные: *p */ { struct EL_SP *pt,/* указатель включаемого эл-та */ *k,*j; /* указатели очередного и предыдущего элементов списка */ /* выделение памяти для нового эл-та списка */ pt = (struct EL_SP *) malloc(sizeof(struct EL_SP)); strcpy(pt->id, t_id);

Файл “Vkl.c”:

if (*p==NULL || strcmp(pt->id,(*p)->id) < 0) { /* включение ид-ра в начало списка */ pt->sled=*p; *p=pt; } else { /* поиск элемента списка, после которого нужно включить идентификатор */ k=*p; while (k!=NULL && strcmp(pt->id,k->id)>=0) { j=k; k=k->sled; } /* включение эл-та *pt после элемента *j */ j->sled=pt; pt->sled=k; }}

Файл “PechSp.c”:

#include "spisok.h"/*--------------------------------------------------*//* функция печати списка *//*--------------------------------------------------*/void PechSp ( struct EL_SP *p )/* Вх. данные: p - указатель начала списка */{ struct EL_SP *i; /* указатель текущего элемента списка */ printf ("\nРезультат:\n"); for ( i=p; i!=NULL; i=i->sled ) puts (i->id);}

Файл “main.c”: #include "spisok.h"/*---------------------------------------------*//* О С Н О В Н А Я П Р О Г Р А М М А *//*---------------------------------------------*/main(){ struct EL_SP *p; /* указатель начала списка */ unsigned n ; /* количество идентификаторов */ unsigned i ; /* параметр цикла */ char t_id[MAXDL]; /* текущий идентификатор */ printf ("\nВведите число идентификаторов\n n="); scanf ("%u",&n); getchar(); /* пропуск символа "перевод строки" */ p=NULL; /* список пока пуст */ printf("Введите идентификаторы "); printf("после каждого нажимайте клавишу <Enter>\n"); for ( i=1; i<=n; i++ ) { gets (t_id); Vkl (&p,t_id); /* включение ид-ра в список */ } PechSp (p); /* печать списка */ printf ("\nДля завершения нажмите любую клавишу\n"); getch();}

Работа с графикой на языке C и модуль graphics.h

Монитор ПК может работать в двух режимах текстовый и графический. В этих режимах по разному представляется видео память. Переход из режима в режим очищает экран. В графическом режиме необходимо пользоваться функциями из графической библиотеки graphics.h.

Типы видео мониторов и их режимы

Существует много типов мониторов, на каждом из которых доступны кроме своего режима, и все более низкие режимы. Под режимом понимается разрешающая способность количество цветов. Кроме того мониторы делятся по аппаратной реализации: ЦИФРОВЫЕ и АНАЛОГОВЫЕ.

Инициализация графикиФункции:initgraph(int *GrDr,int *GrMod,char *Path) ;i=graphresult() ;closegraph() ;Функция initgraph(...) инициализирует графический режим. В параметрах ей передается:GrDr - Тип графического монитора, или DETECT - Определить максимально возможный. Тип установленного оборудования возвращается в этих же переменных (поэтому они и передаются указателем).GrMod - Режим.Path - Путь до файлов *.bgi - драйверов графических режимов. Если указанно " " - то в текущем каталоге.

Пример:#include <graphics.h>#include <conio.h>#include <stdio.h>int main(void){ int GrDr,GrMod,rez ; GrDr=DETECT ; initgraph(&GrDr,&GrMod," ") ; rez=graphresult() ; if(rez != grOk) { printf("\n Ошибка инициализации графики") ; return(1) ; } /* Кон. if */ line(0,0,100,100) ; getch() ; closegraph() ; return(0) ;} /* Кон. main() */

Система координат

Основные графические функцииНиже используются обозначения:

x,y,x1,y1,x2,y2 – координаты;*St – строка символов;

rx,ry,r – радиусы;h – толщина изображения;

Alfa1,Alfa2 – углы в градусах;DX,DY – размеры символа;

Color – цвета.

Функции рисованияФункция Описание

line(int x1,int y1,int x2,int y2) Линия

rectangle(int x1,int y1,int x2,int y2) Прямоугольник

bar(int x1,int y1,int x2,int y2) Закрашенный прямоугольник

bar3d(int x1,int y1,int x2,int y2,int h) Закр. прям. с оттененением

ellipse(int x,int y,int rx,int ry) Эллипс

fillellipse(int x,int y,int rx,int ry) Закрашенный эллипс

arc(int x,int y,int Alfa1,int Alf2,int r) Дуга (круг)

Функции рисованияФункция Описание

outtextxy(int x,int y,char *St) Вывод строки текста

putpixel(int x,int y,char Color) Поставить точку

Color=getpixel(int x,int y) Получить цвет точки

floodfill(int x,int y,char Color) Залить до границы указанного цвета

cleardevice() Очистить экран

clearviewport() Очистить порт вывода

setviewport(int x1,int int y1) Установить порт вывода

int x2,int y2,char flg) flg-вывод за пред. окна

Функции изменения параметров рисования

Функция Описание

setcolor(char Color) Установить цвет рисования

setbkcolor(char Color) Установить цвет фона

setfillstyle(<Шаблон>,cahr Color) Установить цвет и стиль закраски фигур

setlinestyle(<Шаблон>,int Bit,char h) Установить стиль и толщину линий.

Шаблоны линий

Шаблон Ном Изображение

SOLID_LINE 0 Сплошная линия

DOTTED_LINE 1 Линия из точек

CENTER_LINE 2 Centered line

DASHED_LINE 3 Dashed line

Шаблоны закраскиШаблон Ном. Изображение

EMPTY_FILL 0 Цветом фона

SOLID_FILL 1 Выбранным цветом

LINE_FILL 2 ---

LTSLASH_FILL 3 ///

SLASH_FILL 4 ///

BKSLASH_FILL 5 \\\

LTBKSLASH_FILL 6 \\\

HATCH_FILL 7 Light hatch

XHATCH_FILL 8 Heavy crosshatch

INTERLEAVE_FILL 9 Interleaving line

WIDE_DOT_FILL 10 Точками

CLOSE_DOT_FILL 11 Частыми точками