5. Пример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Максимум= %fn", max);
}
return 0;
}
6. Пример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;
}
7. Последовательная обработка
символьных данных
Примеры символьных констант:
„*‟
„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'
вертикальная,
8. Последовательная обработка символов
Пример Вывести коды введенных с клавиатуры символов. Последовательность
символов завершается нажатием клавиши 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);
}
9. Пример Дан текст произвольной длины,
оканчивающийся точкой. Проверить, есть ли в
тексте сочетания "ВА".
#include
main()
{
char
char
short
<stdio.h>
/* текущий символ текста */
/* предыдущий символ
*/
/* признак, имеется ли "ВА" в тексте */
/* 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;
}
s;
prs;
net=1;
10. Обработка массивов
Массивы
Массив - упорядоченная последовательность
пронумерованных элементов одинакового типа.
Индекс - номер элемента массива. Индексы
элементов массива начинаются с нуля.
Элемент массива может иметь несколько
индексов. Размерность массива - количество
индексов каждого элемента.
Вектор - одномерный массив (один индекс).
Матрица – двумерный массив (первый индекс
- номер строки, второй - номер столбца).
11. Язык Си не имеет встроенных средств для вводавывода массива целиком, поэтому массив вводят и
выводят поэлементно с помощью циклов, как,
например, в следующей программе:
#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]);
}
/* Операторы, обрабатывающие массив */
}
12. Подсчет числа элементов, вводимого массива, при этом ввод
завершается при появлении во входном потоке признака
конца данных. Таким признаком в следующей программе
служит число большее 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");
}
13. Использование и обработка
массивов
Примеры:
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]. Списки,
выделенные в фигурные скобки, соответствуют строкам массива, в
случае отсутствия скобок инициализация будет выполнена
неправильно.
14. Примеры:
int s[2][3];
Если при обращении к некоторой
функции написать s[0], то будет
передаваться нулевая строка массива s.
int b[2][3][4];
Пример объявления символьного
массива.
char str[] = "объявление символьного массива";
16. Пример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);
}
23. Указатели
Язык Си имеет средства работы
непосредственно с областями
оперативной памяти ЭВМ, задаваемыми
их адресами (указателями). В языке C
указатели строго типизированы, т. е.
различают указатели (адреса)
символьных, целых, вещественных
величин, а также типов данных,
создаваемых программистом.
24. Для указателей одного и того же типа допустимой
является операция присваивания, кроме того
указателю типа void может быть присвоено значение
адреса данного любого типа, но не наоборот, например
int *a, *b;
double *d;
void *v;
...
a = b; /* Правильно */
v = a; /* Правильно */
v = d; /* Правильно */
b = v; /* Неправильно */
d = a; /* Неправильно */
25. Для поддержки адресной арифметики в языке Си
имеются две специальные операции - операция взятия
адреса & и операция получения значения по заданному
адресу * (операция разадресации).
Рассмотрим работу вышеописанных операций на следующем
примере
int *p, a,
double d;
void *pd;
p = &a;
*p = 12;
p = &b;
*p = 20;
/* Здесь a
pd = &d;
*( (double
/* Здесь d
b;
содержит число 12, b - число 20 */
*) pd ) = a;
содержит число 12.0 */
26. Состояние ячеек до первого присваивания
P, адрес
1000
a, адрес
2000
b, адрес 4000
мусор
мусор
мусор
Состояние ячеек после присваивания p = &a
p, адрес 1000 a, адрес 2000 b, адрес 4000
2000
мусор
мусор
27. Состояние ячеек после присваивания *p = 12
p, адрес
1000
a, адрес
2000
b, адрес 4000
2000
12
мусор
Состояние ячеек после присваивания p = &b
p, адрес 1000 a, адрес 2000 b, адрес 4000
4000
12
мусор
28. Состояние ячеек после присваивания *p = 20
p, адрес 1000
a, адрес 2000
b, адрес 4000
4000
12
20
29. Следует также опасаться случая, когда указатель содержит адрес
объекта программы, завершившего свое существование. Например,
результат работы следующей программы неверен и непредсказуем:
#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 = %lfn", *py);
sin(0.7);
printf("y1 = %lfn", *py);
}
30. Динамическое выделение памяти
Данные, которые создаются,
инициализируются и уничтожаются по
требованию программиста называются
динамическими. Для управления такими
данными используются специальные
стандартные функции, прототипы которых
описаны в заголовочном файле <malloc.h> (для
некоторых компиляторов <alloc.h>).
Для запроса динамической памяти служит
функция malloc(), которая имеет следующий
прототип:
void * malloc(size_t size);
31. Статические и динамические
массивы
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;
/* успешное завершение
*/
32. Типичная последовательность действий при
работе с динамической памятью:
double *A; int n;
...
n = 200;
...
A = (double *) malloc( n *
sizeof(double) );
...
/* Работа с массивом A */
...
free(A);
33. Подпрограммы
Подпрограмма - это программа, которая
выполняется в составе одной или
нескольких программ. В сложных
программах в виде подпрограммы чаще
всего определяют функционально
самостоятельный фрагмент алгоритма,
который возможно используется
неоднократно.
34. Вызов подпрограммы (команда «выполнить
подпрограмму») записывается аналогично
использованию математической функции:
f(a1, a2, ... , an)
где f - имя подпрограммы (аналогично имени функции
P), a1, a2, ... , an - аргументы вызова
(фактические параметры), конкретные величины,
подставляемые вместо формальных параметров при
выполнении подпрограммы (как аргумент 10 при
вычислении значения функции P).
Формальный параметр – это входная или выходная
переменная подпрограммы, указанная в заголовке ее
определения (как x в левой части определения
функции P(x)).
35. Определение функции имеет вид:
<Заголовок_ функции>
{
<Объявление переменных функции>
// тело
<Операторы функции>
//
функции
}
Заголовок функции имеет вид:
<тип значения> <имя функции> ([<тип>
<имя>[,<тип> <имя>] …])
Если функция не обладает значением, в
качестве типа значения пишется ключевое
слово void. Тип значения функции разрешается
не указывать. В этом случае (по умолчанию)
подразумевается тип int.
36. Выполнение подпрограммы завершается при
выполнении оператора возврата или достижении
конца тела функции.
Оператор возврата имеет вид:
return [<выражение>];
В теле функции, обладающей значением, обязательно
должен быть оператор возврата, где тип вычисленного
выражения должен соответствовать типу значения
функции. Значение выражения становится значением
функции: оно передается в вызывающую программу и
подставляется вместо вызова функции. Оператор
возврата вида return; (без выражения) осуществляет
возврат в вызывающую программу в точку, следующую
за вызовом подпрограммы. Если функция не
возвращает значение, оператор возврата может
отсутствовать.
37. Вызов подпрограммы, т.е. команда для
выполнения подпрограммы имеет вид:
<имя функции> ([<имя> [,<имя>] …])
При вызове подпрограммы (в скобках)
определяются имена фактических параметров
(аргументы вызова). Фактические параметры
подставляются вместо формальных параметров
при выполнении подпрограммы.
Вызов функции, обладающей значением
(возвращающей значение), в операторе
присваивания:
<имя переменной> =
<имя функции> ([<имя> [, <имя>] …]);
38. Пример описания функции:
/* функция определения наибольшего из двух чисел */
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 возвращает
наибольшее из этих значений в точку вызова функции.
39. Параметры подпрограмм
При вызове подпрограммы происходит согласование
параметров:
- порядок и типы формальных параметров в
объявлении и определении подпрограммы должны
совпадать с порядком и типами фактических
параметров при вызове подпрограммы.
После вызова подпрограммы выполняются ее
операторы, где фактические параметры подставляются
вместо формальных параметров.
Передача параметров и согласование формальных и
фактических параметров может осуществляться
по значению;
по ссылке (по адресу).
40. Передача параметров по
значению
При передаче параметра по значению фактический
параметр может быть выражением, в частном случае
переменной или константой. Формальному параметру
присваивается значение выражения, тип которого
должен совпадать с типом формального параметра. В
подпрограмме используется только значение
фактического параметра, любые изменения параметра
в подпрограмме не влияют на его значение в
вызывающей программе. Таким способом можно
передавать только входные параметры, т.е. можно
передать данные от вызывающей программы к
подпрограмме.
41. Передача параметров по
ссылке.
При передаче параметра по ссылке фактический
параметр может быть только переменной, тип которой
должен совпадать с типом формального параметра.
Передается не значение фактического параметра, а его
адрес. При выполнении подпрограммы фактический
параметр заменяет формальный параметр, действия
выполняются над фактическим параметром. Изменения
параметра в подпрограмме меняют его значение в
вызывающей программе. Таким способом можно
передавать и входные, и выходные параметры, т.е.
можно передать данные от вызывающей программы к
подпрограмме и в обратном направлении.
42. Область действия переменных
Локальные переменные. Переменные,
объявленные в теле функции, являются
локальными переменными этой функции.
Формальные параметры подпрограммы, также
считаются локальными для этой
подпрограммы. Областью действия локальной
переменной является блок, в котором эта
переменная объявлена.
Глобальные переменные. Глобальные
переменные объявляются до всех функций или
между определениями функций. Областью
действия глобальной переменной является вся
программа.
43. Пример
/* Вариант Б. Вычисление 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;
/* значение функции
*/
}
*/
*/
44. Пример
#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));
}
46. Пример
#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)++;
}
47. Пример
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 ("Сумма положительных чисел = %fn", s);
printf ("Количество положительных чисел: %dn", k);
}
48. Рекурсивные функции
Рекурсивная функция – это функция, в
определении которой есть обращение к себе
самой.
Пример. Допустим, нужно вычислить n!
(факториал числа n). Значение n! можно
представить как произведение n на
факториал (n-1) :
n! = n*(n-1)!
(n-1)! = (n-1)*(n-2)!
…
49. Пример
/* Рекурсивная функция вычисления n! */
float fact (int n)
{ if (n<0)
{
puts (“Недопустимый аргумент
функции fact”);
exit (1); /* завершение выполнения
программы */
}
if (n==1 || n==0) return 1;
return
n*fact(n-1);
}
50. Пример вызова этой функции:
int k;
scanf (“%d”, &k);
printf (“%d! = %.0f”, k,
fact(k));
52. Символьные строки и функции
обработки строк
Символьная строка представляет собой
последовательность символов, заканчивающуюся нульсимволом („0‟ c кодом 0).
Строковые константы заключаются в кавычки. При
компиляции программы они автоматически
дополняются нуль-символом. Строковые переменные
объявляются как массивы символов, например:
char
str[81];
char
error[] = “Ошибка”;
/* массив из 7 символов, включая „0‟ */
53. Для ввода с клавиатуры строки символов
служит библиотечная функция gets(), а
для вывода – функция puts().
Пример:
char
char
puts
puts
gets
gets
s1[81], s2[81];
*s3 = “Привет!”;
(s3);
(“Введите две строки”);
(s1);
(s2);
54. В библиотеках Turbo C, Borland C++ имеется
ряд функций обработки строк:
- определения длины строки (strlen),
- сравнения строк (strcmp, strncmp),
- копирования строк (strcpy, strncpy),
- сцепления строк (strcat, strncat),
- поиска символа в строке (strchr, strrchr,
strpbrk),
- поиска подстроки в строке (strstr).
При их использовании в программу необходимо
включить заголовочный файл string.h,
содержащий объявления этих функций.
55. Рассмотрим одну из библиотечных функций - функцию сцепления
двух заданных строк 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;
}
56. А теперь посмотрите на более компактную (но
менее понятную) запись этой функции:
char *strcat (char *s1, char *s2)
{ char *rs;
rs=s1; /* запоминание адреса
начала строки s1 */
while (*s1!='0') s1++;
/*
поиск конца строки s1 */
while ((*s1++ = *s2++) !='0'); /*
копирование s2 в конец s1,
включая нуль-символ */
return rs;
}
57. С символьными строками можно работать как с
массивами: обращаться к отдельным символам строки
с помощью индекса. Ту же функцию сцепления строк
можно написать иначе:
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;
}
58. Пример драйвера для функции
сцепления строк 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%sn%sn",
str1,str2);
}
else puts ("Не хватает памяти для результирующей
строки");
getch();
}
59. Посимвольная обработка строк
Для представления строк могут использоваться
массивы символов. Примеры описания такого
массива:
char text[10];
/* массив из 10 символов
*/
Для ввода символьных строк можно использовать
библиотечную функцию gets():
char s[81];
gets(s);
Вывод символьных строк можно выполнить либо
с помощью библиотечной функции puts():
сhar str[]= “Привет”;
puts(str);
/* или
printf(“%sn”, str); */
60. Структуры
Структура – это структура данных,
состоящая из фиксированного числа
компонентов, называемых полями
структуры. В отличие от массива,
компоненты (поля) записи могут быт
различного типа. Чтобы можно было
ссылаться на тот или иной компонент
записи, поля именуются. Структура
является аналогом типа данных запись из
языка Паскаль.
61. Переменные типа структура
объявляются следующим образом:
struct <имя типа>
{
<список полей>
} <имя переменной>;
Здесь <имя типа>, <имя переменной> –
правильный идентификатор;
struct – зарезервированное слово;
<список полей> – список полей; представляет
собой последовательность разделов
структуры, между которыми ставится точка с
запятой.
62. Массив структур можно описать
следующим образом:
struct Stud
{
char fam[15], name [15];
int group;
Birthday bd;
float rating;
} PMI[100];
63. Например:
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;
64. Пример
/* ввод значения структурной переменной 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 с.
65. Если структурные переменные используются
только в одной функции программы, то можно
совместить описание переменных с описанием
типа. При этом имя типа можно не задавать,
например:
struct
{ char fio[20];
int
gr;
char adr[40];
} a1, a2, *p1;
66. Работа с файлами
Файл – это поименованная область на
диске, содержащая какую-либо
информацию, например, текст
программы, данные для программы,
документ.
Файлы бывают текстовые и двоичные
(бинарные).
67. Работа с файлами
Текстовые файлы – это файлы, которые
создаются или которые можно
просмотреть с помощью текстовых
редакторов. В операционной системе MS
DOS текстовые файлы представляют
собой последовательность символьных
строк. Каждый символ занимает один
байт. Строка заканчивается двумя
символами: «возврат каретки» (с кодом
13) и «перевод строки» (с кодом 10).
68. Работа с файлами
Двоичные файлы содержат информацию
во внутреннем представлении. Примером
двоичного файла является exe-файл,
содержащий программу в машинных
командах. Прикладная программа тоже
может создать двоичный файл, записав в
него данные в том виде, в каком они
хранятся в памяти (к примеру, типа int).
69. Для чтения информации из
файла служат функции:
fscanf() – форматированный ввод,
fgets() – чтение одной строки,
fgetc() – чтение одного символа,
fread() – ввод заданного числа байтов (символов).
Для записи информации в файл используются
функции:
fprintf() – форматированный вывод,
fputs() – вывод строки,
fputc() – вывод одного символа,
fwrite() – вывод заданного числа байтов (символов).
70. Некоторые функции доступа к
файлам
fopen – открытие файла.
Прототип функции:
FILE * fopen (char * fname, char * mode);
Первый параметр fname задает имя открываемого
файла, второй – режим открытия файла или вид его
обработки. Параметр mode может задаваться в виде:
“r” – чтение файла,
“w” – запись в файл (если файл существует, он
стирается),
“a” – добавление информации в конец файла,
“r+” – чтение и запись.
71. Пример
FILE *fout, *fmod;
/* указатели на выходной и модифицируемый файлы */
char fname[13];
/* имя модифиц. файла */
fout = fopen (“f1.txt”, “w”);
puts(“Введите имя модифицируемого файла”);
gets (fname);
if ((fmod = fopen(fname, “r+”) ==NULL)
{ puts (“Файл в текущем каталоге не найден”);
exit (1);
}
72. Задача. Входной файл st.txt содержит
сведения о сдаче студентами группы
экзаменационной сессии. Каждая запись
файла содержит фамилию и инициалы
студента (15 символов) и пять оценок (5
символов) и завершается символом
”перевод строки”. Напечатать список
студентов с указанием среднего балла
каждого студента.
73. Программа:
/*-----------------------------------------*/
/* Печать среднего балла каждого студента */
/*-----------------------------------------*/
#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;
/* сумма оценок */
75. Массивы и функции как параметры
Указатели на функции
Функции, как и другие объекты программы,
располагаются в памяти ЭВМ. Любая область
памяти имеет адрес, в том числе и та, в
которой находится функция. Имя функции без
круглых скобок за ним представляет собой
константный адрес этой области памяти. Таким
образом, имея функции со следующими
прототипами:
double sin(double x);
double cos(double x);
double tan(double x);
76. Можно описать и указатель на функцию.
Например, для функции с аргументом
типа double, возвращающей значение
типа double, описание такого указателя
будет выглядеть следующим образом:
double (*fn)(double x);
77. После того, как описан указатель на функцию,
становятся возможными следующие операции:
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) = %lfn", fnArray[i](x) );
78. Можно описать функцию возвращающую значение
указателя на функцию:
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) = %lfn", fnFunc(i)(x) );
79. Массивы и указатели
В языке C понятие массива тесно связано с
понятием указателя. Действительно, как было
описано выше, имя массива представляет
собой адрес области памяти, распределенной
под этот массив, или иными словами адрес
первого элемента массива. Пусть описаны
следующие данные:
int a[100], *pa;
и осуществлено присваивание:
pa = a;
80. Два существенных отличия массива от
указателя:
массиву при описании выделяется
память для хранения всех его элементов,
а указателю только для хранения адреса;
адрес массива навсегда закреплен за
именем, то есть имя массива является
адресной константой и выражение вида a
= pa недопустимо.
81. Пример
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;
82. Указатели и двумерные массивы
Пусть имеются следующие определения
массивов и указателей:
int A[4][2], B[2];
int *p, (*pA)[4][2], (*pAstr)[2];
Здесь A представляет собой двумерный массив
из четырех строк и двух столбцов, B одномерный массив из двух элементов. Для
каждого из этих массивов будет выделено
соответствующее количество памяти,
достаточное для хранения всех их элементов.
Указатель p представляет собой указатель на
величину int, указатель pA - указатель на
двумерный массив из четырех строк и двух
столбцов, pAstr - указатель на одномерный
массив из двух элементов.
83. Для вышеописанных указателей допустимы следующие
операции присваивания, поскольку слева и справа от
операции присваивания находятся указатели на один и
тот же тип данных:
p = B;
p = &B[1];
p = &A[0][0];
p = A[2];
Следующее присваивание:
p = A; /* неверно */
является неверным, так как слева от операции
присваивания находится указатель на тип int, а справа указатель на первый элемент массива A, который
(элемент) представляет собой массив из двух
элементов типа int. В таких случаях компиляторы
выдают предупреждающее сообщение о
подозрительном преобразовании указателя.
84. Следующие присваивания корректны
pA = &A; /* Указатель на двумерный массив
*/
pAstr = &B; /* Указатель на одномерный
массив */
и устанавливают следующее соответствие элементов:
(*pA)[i][j] эквивалентно A[i][j]
(*pAstr)[i] эквивалентно B[i]
Массивы указателей удобны для хранения символьных
строк:
char *str[] = {
"Строка 1",
"Строка 2",
"Длинная строка 3"
};
85. Пример
#include <stdio.h>
#define N 3
void 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");
}
86. Пример
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);
}
87. Технологии программирования
В проектировании и
программировании активно
применяются следующие технологии:
Структурное программирование.
Модульное программирование.
Объектно-ориентированное
программирование.
Компонентное программирование.
88. Структурное
программирование…
Э. Дэйкстра (60-е годы):
Для любой простой программы можно
построить функционально эквивалентную ей
структурную программу, т.е. программу,
сформированную на основе фиксированного базисного
множества, включающего:
структуру последовательного действия,
структуру выбора одного из двух действий
структуру
цикла,
то
есть
многократного
повторения некоторого действия с проверкой условия
остановки повторения.
90. Структурное программирование
Стандартизация и линейность программы –
снижение сложности.
Некоторые соображения:
Алгоритм должен иметь 1 вход и 1 выход.
Никаких goto.
Нет зависимости от языка программирования.
Ясен набор операторов, который необходим в языках
программирования.
91. Модульное программирование...
Основная идея: разбиваем сложную
задачу на подзадачи, каждую из них при
необходимости разбиваем снова и т.д.
Получаем простые задачи, их решаем,
объединяем.
92. Модульное программирование
Структурное программирование – универсальный
базис алгоритмических конструкций.
Модульное программирование – специфичный для
задачи базис из модулей.
Более высокий уровень абстракции.
Настройка на конкретную задачу.
Возможности повторного использования.
Возможности коллективной разработки – разделение
труда.
94. Объектно-ориентированное
программирование
Основные принципы объектной модели:
абстракция;
инкапсуляция;
иерархия (наследование, агрегация);
полиморфизм;
модульность.
Объектная декомпозиция (в отличие от
алгоритмической): элементы проекта –
классы и объекты (а не алгоритмы).
И только потом данные и алгоритмы.
95. Компонентное
программирование...
Компонентное программирование –
развитие объектно-ориентированной
идеологии.
Введен следующий уровень абстракции –
классы объединяются в компоненты.
Основной принцип компонентного
программирования: сборка приложения из
готовых компонент, в общем случае
написанных на разных языках.
96. Компонентное программирование
Компонент:
программный код в виде самостоятельного модуля
м.б. использован в неизменном виде
может допускать настройку
обладает поведением (функциональностью).
Компонент изолирован от внешнего мира своим
интерфейсом – набором методов (их сигнатурами).
Компонентная программа – набор независимых
компонент, связанных друг с другом посредством
интерфейсов.
97. Структурная декомпозиция и
нисходящее программирование
Задача
Дано целое n и вещественные x1,
x2, ..., xn. Составить программу печати
заданных вещественных чисел в порядке
возрастания (не убывания).
101. Алгоритм :
1. n = Vvod(x); /* Ввод n и массива
x */
2. Sort (x,n); /* Сортировка массива x
по
возрастанию*/
3. Вывод сортированного по
возрастанию массива x
103. Алгоритм функции ввода данных
int Vvod (float x[])
{
Ввод n;
for (i=0; i<n; i++)
Ввод x[i];
Возврат n;
}
104. Вывод массива x
Вывод заголовка "Упорядоченные
числа:";
for (i=0; i<n; i++)
Вывод x[i];
105. Метод последовательного
нахождения максимума
2.5 6 14 -3 10 // рассматривается n элементов
2.5 6 10 -3 14
2.5 6 10 -3
2.5 6 -3 10
// рассматривается n-1 элементов
2.5 6 -3
2.5 -3 6
// рассматривается n-2 элементов
2.5 - 6
-3 2.5
// рассматривается n-3 элементов
106. Алгоритм функции сортировки
массива x по возрастанию
void Sort (float x[], int n)
{ for (k=n-1; k>0; k--)
{ Определение максимума среди
элементов x[0], ... , x[k] и его
индекса
imax.
Обмен: x[imax] <--> x[k];
}
109. Программа:
#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;
}
*/
*/
*/
110. /*Функция сортировки массива по возрастанию*/
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;
}
111. /* Главная функция */
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]);
}
112. Модульное программирование
Технология модульного программирования
предполагает разбиение программы на
отдельные части – модули. Модуль может
содержать одну или несколько
взаимосвязанных функций и общие для
функций данные. Каждый модуль помещается в
отдельный файл (с расширением .c или .cpp) и
компилируется автономно. Получившиеся в
результате компиляции объектные модули
объединяются в единый исполняемый модуль
(exe-файл) с помощью компоновщика (Linker).
113. При разработке многомодульных программ
нужно создавать проект (файл с расширением
.prj). В проекте указывают, из каких файлов
состоит программа. Это могут быть исходные
файлы с расширением .c или .cpp, или
объектные файлы с расширением .obj
(полученные в результате компиляции
исходных модулей), или библиотеки объектных
модулей (файлы с расширением .lib).
Заголовочные файлы (с расширением .h) в
проекте не указывают, они должны быть в том
же каталоге, в котором содержатся модули
программы.
120. Файл “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();
}
121. Работа с графикой на языке C и
модуль graphics.h
Монитор ПК может работать в двух
режимах текстовый и графический. В этих
режимах по разному представляется
видео память. Переход из режима в
режим очищает экран. В графическом
режиме необходимо пользоваться
функциями из графической библиотеки
graphics.h.
122. Типы видео мониторов и их
режимы
Существует много типов мониторов, на каждом из которых
доступны кроме своего режима, и все более низкие режимы. Под
режимом понимается разрешающая способность количество
цветов. Кроме того мониторы делятся по аппаратной реализации:
ЦИФРОВЫЕ и АНАЛОГОВЫЕ.
123. Инициализация графики
Функции:
initgraph(int *GrDr,int *GrMod,char *Path)
;
i=graphresult() ;
closegraph() ;
Функция initgraph(...) инициализирует
графический режим. В параметрах ей передается:
GrDr - Тип графического монитора, или DETECT Определить максимально возможный. Тип
установленного оборудования возвращается в этих же
переменных (поэтому они и передаются указателем).
GrMod - Режим.
Path - Путь до файлов *.bgi - драйверов графических
режимов. Если указанно " " - то в текущем каталоге.
125. Система координат
Основные графические функции
Ниже используются обозначения:
x,y,x1,y1,x2,y2 – координаты;
*St – строка символов;
rx,ry,r – радиусы;
h – толщина изображения;
Alfa1,Alfa2 – углы в градусах;
DX,DY – размеры символа;
Color – цвета.
127. Функции рисования
Функция
Описание
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-вывод за пред. окна
до
границы
указанного
128. Функции изменения параметров
рисования
Функция
Описание
setcolor(char Color)
Установить цвет рисования
setbkcolor(char Color)
Установить цвет фона
setfillstyle(<Шаблон>,cahr Color)
Установить цвет и стиль закраски
фигур
setlinestyle(<Шаблон>,int Bit,char h) Установить
линий.
стиль
и
толщину
