Повторяемость

Модульность – это возможность разбивать программу на небольшие логически законченные фрагменты.

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

Повторяемость – это возможность в различных местах пользоваться одним и тем же нужным фрагментом без его повторного написания.

В таких случаях каждый раз вызывается одна и та же подпрограмма.

Рассмотрим простейшие подпрограммы.

Заданы 2 целых числа, используя подпрограмму, определить максимальное из них.

#include<stdio.h>

int max(int a, int b)

{

if(a>b) return a;

else return b;

}

main()

{

int m, n, maxim;

scanf (“%d”, &m);

scanf (“%d”, &n);

maxim=max(m, n); // вызов функции max

printf (“максимальное число = %d “, maxim);

}

Заданы два целых числа, поменять местами их значения.

#include<stdio.h>

void change (int a, int b)

{

int x;

x=a; a=b; b=x; // обмен значениями а и b через промежуточную переменную – х.

}

main ()

int a=5, b=10;

printf (“%d %d”, a, b);

change (a, b);

printf (“\n%d %d”, a, b);

}

На экране вы увидите неожиданную вещь:

5 10

Значения переменных не переставляются! Где же ошибка? Если вставить печать в функцию change, то увидим, что там все в порядке и значения a и b переставляются. Почему же в main не изменилось ни чего? Для того чтобы это понять, нужно знать, как осуществляется движение информации в подпрограмму и обратно. Разберемся в этом..

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

Исправим эту ошибку. В главной функции main изменится только вызов функции:

change (&a, &b);

что означает передать в подпрограмму не значения переменных –а и b, а их адреса.

Функция будет выглядеть по другому:

void change (int *a, int *b)

{

int x;

x=*a; *a=*b; *b=x; // перестановка значений в главной программе через их адреса.

}

В этом случае работа в подпрограмме change производится не с формальными параметрами, а с фактическими через их адреса, т.е. из функции change мы ссылаемся на место в памяти отведенное на а и b в main.

Интересные примеры работы с подпрограммами при использовании векторов и матриц.

Обнулить вектор при помощи функции.

#include<stdio.h>

void arrz (int [], int); // декларация функции

void main (void)

{

int arr[10], i;

for (i=0: i<10; i++)

scanf (“%d”, &arr[i]);

arrz (arr,10); // вызов функции

for (i=0: i<10; i++)

printf (“%d”, &arr[i]);

}

void arrz (int array[], int num) // заголовок функции

{

int i;

for (i=0: i<num; i++)

array[i]=0;

}

В данном случае функция arrz тоже работает с адресом вектора arr[10], расположенного в main. И обнуляет она именно его, поэтому функция arrz не имеет результата, а имеет эффект.

При работе с матрицей в подпрограмме нужно соблюдать большую осторожность. Необходимо указывать структуру матрицы, хотя бы в одном индексе array[10][], или работать через адрес, для матрицы этот формальный параметр будет выглядеть так int **array. Подробнее об этом можно прочесть у Т.А. Павловской, С/С++ программирование на языке высокого уровни, С-П, 2001, стр.78.

Рассмотрим пример: каждую из произвольного количества матриц разной размерности транспонировать.

#include<stdio.h>

void mtran(int matr[10][], int n)

{

int i, j, k;

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

for (j=i+1; j<n; j++)

{

k=matr[i][j];

matr[i]j]=matr[j][i];

matr[j]i]=k;

}

void main (void)

{

int arr[10][10], i, j, k, n;

do // цикл для обработки произвольного количества матриц «пока не надоест»

{

printf(“ введите размерность матрицы “);

scanf(“%d”, &n);

printf(“ введите матрицу \n “);

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

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

scanf(“%d”, &arr[i][j]);

mtran(arr, n); // вызов функции, транспонирующей матрицу

printf(“ транспонированная матрица \n“);

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

{

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

printf(“%d”, arr[i][j]);

printf(“ \n“);

}

printf(“ повторить? 1-да, 0-нет “);

scanf(“%d”, &k);

while (k==1);

}

ДИРЕКТИВА ПРЕПРОЦЕССОРА #define.

Мы уже сталкивались с директивами препроцессору #include для включения информации из другого файла в программу. При помощи директивы препроцессора #define можно задавать константы.

#define PI 3.14

При компиляции программы каждый раз вместо PI будет подставлено ее значение. Знак; не ставится, т.к. это не оператор языка С. Использовать эту директиву можно для любых констант, даже для звукового сигнала ‘007’, и признака конца -‘\0’.

#define BEEP ‘007’

#define NULL ‘\0’

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

Могут быть и такие макроопределения:

#define FMT “ x %d \n”

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

printf (FMT, x);

Макроопределения еще их называют - макросами – это текстовые подстановки, происходящие до компиляции программы. Вы заметили, что все макросы пишутся с большой буквы – это договоренность между программистами. Если видишь, что-либо написанное с большой буквы, ищи определение объекта как макроса в директиве препроцессора #define.

Хотя это требование не правило, если вы напишите с маленькой буквы, все будет работать.

Могут быть макроопределения и с параметрами:

#define SQR (X) X*X

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

x=4; y=12;

z1= SQR(x);

z2= SQR(y);

Могут быть и более сложные условные макросы:

#define MAX(X, Y) ((X) > (Y)? (X): (Y))

#define ABS (X) (X < 0)? -(X): (X))

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

y=2*MAX(a+b, r+c);