Составление алгоритма решения. Характерная особенность основного алгоритма при работе с подпрограммой с несколькими возвращаемыми результатами – организация каждого обращения к ней

Характерная особенность основного алгоритма при работе с подпрограммой с несколькими возвращаемыми результатами – организация каждого обращения к ней отдельным блоком «предопределённый процесс». Эта особенность учтена в схеме основного алгоритма. В дополнительном алгоритме локальная переменная i используется для организации цикла перебора текущих значений формального параметра Z. Схемы основного и дополнительного алгоритмов представлены на рис. 10.13.

Программирование задачи

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

Каждая из функций Си/Си++ представляется в этом случае одной из упрощенных структур

[тип] имя([тип b₁,...,тип b_i,...,тип b_n,тип *d₁,...,тип *d_j,..., тип *d_m])

{

тело

функции

[return РВ;]

}

где имя – идентификатор (название) функции;

тип – описатель типа функции (результата);

b_i – список входных формальных параметров с указанием типа каждого;

d_j – список выходных формальных параметров – указателей, определяющих возвращаемые результа-

Рис. 10.13. Схемы основного и дополнительного алгоритмов задачи о суммах и произведениях

ты, с указанием типа каждого и признака указателя при описании (*);

( ) – ограничители списка формальных параметров;

тело функции – основная часть (совокупность операторов), реализующая вынесенные в отдельный алгоритм вычисления (действия);

return РВ; – оператор возврата в вызывающую функцию результата вычислений РВ (выражения);

[ ] – признак необязательности содержимого;

{ } – ограничители тела функции.

Первая строка структуры – заголовок функции.

Структура вызова функции:

имя ([a₁, ..., a_i, ..., a_n,c₁, ..., c_j, ..., c_m])[;]

где имя – идентификатор функции;

a₁, …,a_i, …,a_n – список входных фактических параметров (аргументов), численные значения которых требуется передать в дополнительную функцию (подпрограмму);

c₁, …, c_j,…, c_m – список адресов выходных фактических параметров (аргументов), численные значения которых требуется получить из дополнительной функции (подпрограммы);

( ) – ограничители аргументов;

[ ] – признак необязательности содержимого.

Прототип функции аналогичен ее заголовку и имеет структуру:

[тип] имя([тип b₁,...,тип b_i,...,тип b_n,тип *d₁,...,тип *d_j,...,тип *d_m]);

где имя – идентификатор (название) функции;

тип – описатель типа функции (результата);

тип b_i – список входных формальных параметров с указанием типа каждого;

тип *d_j – список выходных формальных параметров – указателей, определяющих возвращаемые результаты, с записью типа и признака указателя каждого (*);

( ) – ограничители списка формальных параметров;

[ ] – признак необязательности содержимого;

; – признак оператора.

Правила записи и использования функций с несколькими возвращаемыми значениями совпадают с указанными ранее для функций с одним результатом со следующими дополнениями:

· количества и типы входных и выходных формальных параметров должны соответствовать аналогичным фактическим, т.е. каждый a_i имеет свой b_i, а каждый c_j – свой d_j, при этом тип и взаимное расположение их в списке определяется программистом;

· в качестве входных формальных параметров используются переменные;

· в качестве выходных формальных параметров используются указатели;

· в качестве входных фактических параметров используются константы, переменные, вызовы функций, выражения и адреса массивов;

· в качестве выходных фактических параметров используются адреса переменных и адреса массивов;

· каждое обращение к подпрограмме, как правило, оформляется как отдельный оператор, в соответствии с требованиями алгоритма;

· использование выходных параметров освобождает от ограничения на возвращение только одного результата оператором return, основной результат рекомендуется возвращать оператором return, все остальные в качестве выходных параметров.

· при использовании структуры с оператором return, вызов функции может служить операндом выражения в вызываемой функции;

· если логика задачи не позволяет выделить основной результат, то использование оператора return необязательно. В этом случае в заголовке дополнительной функции в качестве описателя типа необходимо указывать ключевое слово void;

· вызов функции, оформленный простым оператором, заканчивается символом «;», если же он является операндом выражения – признак оператора не указывается;

· формальные значения (кроме главного) возвращаются в ячейки вызывающей функции, адреса которых были переданы в вызываемую;

· в списке формальных параметров прототипа допускается опускать их имена, оставляя для входных их типы, а для выходных типы с последующими символами «*».

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

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

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

Принципиальные различия в обработке формальных параметров, заданных переменными или указателями, иллюстрируются схемами рис. 10.14, 10.15.

Рис. 10.14. Схема 1 – передача параметра по значению

Схема 1 (передача по значению) показывает параллельное существование отдельных ячеек хранения формального и фактического параметра (переменной).

Рис. 10.15. Схема 2 – передача параметра по адресу

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

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

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

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

Достоинство передачи по адресу – возможность возвращения в вызывающую функцию значения выходного формального параметра.

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

. . . main( ) { int j = 1, i = 1; . . . printf("j=%d i=%d", j, i ); func(j, &i); printf("j=%d i=%d", j, i ); . . . } void func(int j, int *pi) { . . . *pi = 0.5 * j + 1.; j = 2; . . . }

Так, фрагмент программы в качестве фактических параметров использует входной – переменную j и выходной – адрес переменной i. Этим параметрам в вызываемой подпрограмме соответствуют одноименный входной формальный параметр – переменная j и выходной – указатель pi. В теле подпрограммы численные значения обрабатываемых переменных i и j изменены (i – с помощью разадресации указателя pi, j – напрямую). Выполнение программы приведет к выводу исходных значений j и i (j=1 i=1), а затем их же значений после обращения к дополнительной функции (j=1 i=1.5). Значение входного фактического параметра j не изменилось, а выходного (i) – приняло новое значение. Это произошло потому, что обработка параметра j велась по схеме 1 (разные ячейки), а обработка параметра i – по схеме 2.

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

Идентификация переменных представлена в табл. 10.3.

Таблица 10.3

Имя в алгоритме

n

m

i

j

xi

yj

SX

PX

SY

PY

d

k

z i

SZ

PZ

Имя в программе

n

m

i

j

x[i]

y[j]

sx

px

sy

py

d

k

z[i]

sz

pz

Предусмотренная алгоритмом обработка двух массивов (на 30 и 50 элементов) позволяет в программе первый из них использовать как фактический под именем x и формальный под именем z, второй, аналогично, под именами y и z.

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

sp(x, n, &sx, &px); и sp(y, m, &sy, &py);

Заголовок дополнительной функции преобразуется к виду:

void sp(float *z, int k, float *sz, *pz)

т. е. входные параметры передаются по значению, а выходные через адреса. Равнозначность возвращаемых значений определяет отсутствие оператора return.

Классический вариант программирования задачи

#include<stdio.h>/*файл с прототипами функций ввода-вывода*/

#include<conio.h>/*файл с прототипом функции getch(), clrscr()*/

#include<math.h> /*файл с прототипами математич. функций*/

#include <windows.h> /*файл с прототипом функции CharToOem*/

void sp(float *z, int k, float *sz, float *pz);/*прототип функции sp*/

main( ) /* заголовок головной функции */

{

float d, sx, px, sy, py, x[30], y[50]; /*описатели локальных */

int i, j, n, m; /* переменных и массивов */

char buf[30];

clrscr( );

CharToOem(" Введите значения n, m: ",buf);

printf("\n %s ",buf);

scanf("%d%d", &n, &m);

printf("\n n=%d m=%d\n", n, m);

for( i = 0 ; i < n ; i++ )/* заголовок цикла ввода x[ i ] */

{

CharToOem(" Введите значение x ",buf);

printf("\n %s (%d): ",buf,i+1);

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

}

for( i = 0 ; i < n ; i++ ) /* заголовок цикла вывода x[ i ] */

printf(" %.2f",x[i]);

printf("\n"); /* перевод курсора в начало следующей строки */

for( j = 0 ; j < m ; j++ ) /* заголовок цикла ввода y[ j ] */

{

CharToOem(" Введите значение y ",buf);

printf("\n %s (%d): ",buf,j+1);

scanf("%f", &y[j]);

}

for( j = 0 ; j < m ; j++ ) /* заголовок цикла вывода y[ j ] */

printf(" %.2f", y[j]);

sp(x, n, &sx, &px); /* вызовы дополнительной функции */

sp(y, m, &sy, &py); /* оформленные простыми операторами */

d = (sx + sqrt( fabs( py ) ) ) / ( log( px ) - sy ); /* вычисление d*/

printf("\n sx=%.2f px=%.2f sy=%.2f py=%.2f d=%.2f \n",

sx ,px, sy, py, d);

getch( );

}

void sp(float *z, int k, float *sz, float *pz)/*определение ф-ции sp*/

{

int i; /* описание локальной переменной i */

*sz = 0;

*pz = 1;

for( i = 0 ; i < k ; i++ ) /* заголовок цикла расчета SZ и PZ */

{

*sz = *sz + z[ i ];

*pz = *pz * z[ i ];

}

}

5 6 – реальные размеры массивов Х и У;

1 1.6 1.8 15 23 – значения элементов массива Х;

0.6 0.76 0.99 180 67.7 200 – значения элементов массива Y;

Под закрывающей скобкой приведены исходные данные для решения задачи.

Результаты решения представлены в приложении 10.5.

Программирование задачи с графическим интерфейсом

Программирование задачи при использовании графического интерфейса предварим его разработкой. Для ввода значений n, m планируем однострочные поля редактирования (EditN, EditM). Для ввода элементов массивов X и Y используем многострочные поля редактирования (EditХ, EditY).

Вывод расчетных значений sx, px, sy, py, d реализуем в однострочные поля редактирования (EditSx, EditPx, EditSy, EditPy, EditD).

Управление процессом решения реализуем двумя командными кнопками, расположенными в нижней части окна. Назначение каждой определяется ее названием.

С учетом планируемого интерфейса выполним программирование задачи.

#include<stdio.h>/*файл с прототипами функций ввода-вывода*/

#include<conio.h>/*файл с прототипом функции getch(), clrscr()*/

#include<math.h>/*файл с прототипами математич. функций*/

void sp(float *z, int k, float *sz, float *pz);/*прототип функции sp*/

…

void TSumprDlgClient::BNClickedOk()

{

// INSERT>> Your code here.

float d, sx, px, sy, py, x[30], y[50]; /*описатели локальных*/

int i, j, n, m; /* переменных и массивов */

char buf[30];

EditN->GetText(buf,10); /*ввод */

n=atoi(buf); /*значения n*/

EditM->GetText(buf,10); /*ввод */

m=atoi(buf); /*значения m*/

for( i = 0 ; i < n ; i++ ) /* заголовок цикла ввода x[ i ] */

{

EditX->GetLine(buf, sizeof(buf),i);

x[i]=atof(buf);

}

for( j = 0 ; j < m ; j++ ) /* заголовок цикла ввода y[ j ] */

{

EditY->GetLine(buf, sizeof(buf),j);

y[j]=atof(buf);

}

sp(x, n, &sx, &px); /* вызовы дополнительной функции */

sp(y, m, &sy, &py); /* оформленные простыми операторами */

d = (sx + sqrt( fabs( py ) ) ) / ( log( px ) - sy ); /* вычисление d*/

sprintf(buf,"%.2f ",sx); /* вывод */

EditSx->SetText(buf); /*значения sx*/

sprintf(buf,"%.2f ", px); /* вывод */

EditPx->SetText(buf); /*значения px*/

sprintf(buf,"%.2f ",sy); /* вывод */

EditSy->SetText(buf); /* значения sy*/

sprintf(buf,"%.2f ", py); /* вывод */

EditPy->SetText(buf); /* значения py*/

sprintf(buf,"%.2f",d); /* вывод */

EditD->SetText(buf); /* значения d*/

}

/* определение функции sp */

void sp(float *z, int k, float *sz, float *pz)

{

int i; /* описание локальной переменной i */

*sz = 0;

*pz = 1;

for( i = 0 ; i < k ; i++ ) /* заголовок цикла расчета SZ и PZ */

{

*sz = *sz + z[ i ];

*pz = *pz * z[ i ];

}

}

5 6 – реальные размеры массивов Х и У;

1 1.6 1.8 15 23 – значения элементов массива Х;

0.6 0.76 0.99 180 67.7 200 – значения элементов массива Y;

Под закрывающей скобкой приведены исходные данные для решения задачи.

Результаты решения представлены в приложении 10.6.

10.4. Подпроцесс с результатом – массивом

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

Постановка задачи

Вычислить суммы элементов каждой строки двумерных массивов A(m x n) и B(t x s). Положительные суммы каждой исходной матрицы сформировать в одномерные массивы.