Шпора по информатике / 003

1. Информатика  

8.1 Формальные и фактические параметры Каждая функция должна получать данные и возвращать результат, если он есть. Связь осуществляется через аргументы функций, обычно называемые параметрами. Ранее уже вызывали функции (стандартные), например, sin(x). Пусть F1, F2 - пара взаимодействующих функций (см. рис. 8.1 и 7.2) . Все параметры передаются из F1 в F2, а F2 получает результат и возвращает его в F1, если это предусмотрено, т.е. нет слова void в заголовке F2. Параметры и результат могут отсутствовать.

Рис. 8.1. Передача параметров в функцию

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

int p = f ( 1 ,     b ,     2. * b);         //    это вызов с фактическими параметрами

int     f    ( int x,  float y,   float z)

// (8.1)

        // это заголовок вызываемой функции с формальными параметрами

При вызове происходит копирование переменных, похожее на присваивание, например,

x   <===  1 , y  <===  b , z  <===  2.*b .

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

return    выражение;

Указанное выражение вычисляется и полученное значение присваивается имени функции в заголовке для возврата. В частном случае выражением является имя переменной. После return может стоять только одно выражение. Примеры:

return    x*x + y*y;

(8.2)

return    d;

Оператор return может стоять в любом месте функции. Если в функции нет возвращаемых значений, то она имеет тип void и в ней используется оператор return; т.е. без выражения после него, Если return; стоит перед фигурной скобкой, закрывающей тело функции , то его можно опустить. Последнее возможно также для функции main.

  ОСНОВНЫЕ ПРАВИЛA 1. Все функции имеют заголовки. В заголовке должны быть описаны тип функции и типы формальных параметров. По умолчанию функция имеет тип int. В заголовках нет точки с запятой.

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

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

4. Все переменные внутри функции являются локальными и должны быть описаны в ней. Локальные переменные неизвестны другим функциям.

5. При вызове тип функции можно не описывать.

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

7. Тип возвращаемого значения должен соответствовать типу функции в заголовке.

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

Фактические (при вызове)

Формальные ( в заголовке)

Переменные

Массивы

Элементы массивов

Выражения

Константы

Переменные

Массивы

Этот список не является полным, т.к. есть и другие возможности. Проиллюстрируем одну из этих других.

8.2 Вызов стандартной функции ctime Cтандартная функция ctime выводит системную дату и системное время в виде строки. При этом данные для нее определяет функция time, которая выдает количество секунд, прошедших с 1 января 1970. Перед вызовом нужно описать переменную типа long с любым именем, т.е. выделить память для неё, long tt; например. Тип long - это четырехбайтовые целые числа. Обе функции имеют только один аргумент - адрес переменной tt в ОП. Операция получения адреса в С++ обозначается как & (амперсанд). Следовательно, для получения даты и времени нужны три оператора:

long tt;

/ / (8.3)

tt = time (&tt);           cout << ctime ( &tt);

При выводе происходит автоматически перевод на новую строку. Для работы с функциями time и ctime необходим заголовочный файл

# include <time.h>   Проверьте, что получится, если опустить вызов time. Подробнее строки и адреса рассмотрим позже.

8.3 Прототипы функций Любая функция может вызывать другую функцию и затем использовать полученный от неё результат. Если в тексте программы текст функции стоит до обращения к ней, то программа записывается обычным образом. Например, сначала идут тексты функций, а затем main, где они используются. Если же обращение к функциям предшествует их текстам, то в начале программы после команд препроцессора должны быть записаны прототипы этих функций. Прототип функции - это её предварительное описание, т.е. её объявление. Он позволяет компилятору проверить правильность вызовов этой функции в тексте программы до появления текста самой функции, т.е. её определения. В прототипе указывается имя функции, ее тип, типы аргументов. Можно указывать и имена аргументов, но это не обязательно. Прототип должен быть согласован с заголовками функций и всеми вызовами. Например, для заголовка функции (8.1) прототип имеет следующий вид:

int f ( int, float , float );

или

int f ( int x, float y, float z );

(8.4)

Форма прототипа (8.4) отличается от заголовка функции только наличием точки с запятой в конце.

Следовательно, в программе имя любой функции, кроме main, появляется не менее двух раз - в заголовке и при вызове. Но если текст функции записан после вызывающей подпрограммы, то имя функции должно встречаться в программе не менее трех раз - в заголовке, при вызове и в прототипе. Например, для функции f(x,y,z) из ( 8.1 ) имеем

прототип      int f ( int x, float y, float z );

(8.5)

заголовок     int f ( int x, float y, float z )

и ее вызов         f (x, y, z );

Чтобы не думать о порядке следования подпрограмм, прототипы в С++ рекомендуется писать для всех функций. В случае больших программ для прототипов обычно создают свой заголовочный файл в рабочей папке и подключают его командой препроцессора    #include " имя.h " .

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

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

                                        fmas( A ) ;

c массивом, объявленным до вызова как int A[50]; Для вызова этой функции записываем:

float   fmas (int A[ ] ) ;     - это прототип,

int  A[50];    - это описание массива в начале подпрограммы с вызовом,

fmas (A) ;    - это вызов функции,

float   fmas (int A[ ] )    - это заголовок функции.

(8.6)

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

Например, при вызове fmas(A) в функцию fmas будет передан адрес A[0], т.е.

   &A[0], где   & - операция получения адреса. Следовательно, при вызове полагается

                           A == &A[0],

тогда как A[0] - это значение первого элемента (его номер - ноль).

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

float    fmas (int n, int A[ ] ) / / (8.7)

Здесь n - длина массива A, т.е. имеем A[0], A[1], A[2] . . . A[n-1]. Это позволяет легко реализовать цикл по всем элементам или другую обработку массива.

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

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

              . . . .

              int fg ( ); / /     прототип          | |       int fg ( )   / /   заголовок

                     int g;                                  | |      { . . . .

              void main { . . .                         | |         cout<< g ; . . . }

                     g = 5;     fg( ); . . . }            | |

Здесь объявлена глобальная переменная g. При выполнении программы произойдет вывод значения g=5, хотя передаваемых параметров нет.

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

8.6 Пример использования подпрограммы Дано N и задан массив А длины N. Oпределить значение максимального элемента (x)

и его номер (kx). Использовать подпрограмму.

          #include <iostream.h>

          #include <conio.h>                                                             // for getch

        int maxA ( float A[ ], int N);                                     // прототип

void main( )   {

          float A[100], x; int k,N;

        cout<<" N<100=? N= ";                                             // запрос N

        cin >> N;

        cout <<" N= "<< N << " N values for A:"<<endl;         // запрос

     for ( k=0; k<N; k++) cin>>A[k];                  // Цикл для ввода массива

     int kx = maxA (N, A) ;                                   // Вызов функции

     x = A[kx];

     cout<<"N="<<N <<" kx="<<kx<<" x="<< x<<endl;

                      getch(); return;}

/ / - - - - - - - - - - - - - - - -

    int maxA ( int N, float A[ ] )    {        // заголовок функции;

      int kx=0;    циализация kx;

          for (int k=1; k<N; k++)

                if( A[k] > A[kx]) kx=k;  //сравнение A[k] c максимальным предид A[kx];

                     return kx ;               // kx - номер макс. элемента

}

Информатика

Лекция 9. Комплексные значения. Тестирование программ.

9.1 Комплексные переменные Комплекснaя величина - это пара вещественных чисел: Re, Im. Отметим, что в математике ударение в слове "комплексная" делается на второй слог. Для работы с комплексными переменными нужно подключить заголовочный файл:

# include <complex.h>

Его можно найти в папке INCLUDE. Это обычный текстовый файл размера ~50К. В этом файле содержатся все данные, а также новые определения всех операций и стандартных функций. Их можно читать, но это очень трудно. По аналогии с потоками в лекции 6 будем считать, что complex - это сложный тип, не вводя термин "класс" , необходимый в данном случае. Все переменные и массивы типа complex описываются в операторах вида

complex    имя;

причем для массива добавляется информация о длине его, как обычно. Например, при описании complex z ; создается комплексное число

z = x + i y = 0. + i 0. ,

т.е. пара чисел x=0, y=0. При объявлении можно в скобках задавать значения x, y для комплексного числа или только вещественную часть Примеры объявления комплексных чисел программистом:

complex z ;

complex z2 (5);

complex zz (1, 2);

complex i (0, 1);

complex zarr[9] ;

/ / z = 0 + i 0,

/ / z2 = 5. + i 0,

/ / zz = 1. + 2 i,

/ / i = 0 + i

/ / массив zarr из 9 комплексных чисел

(9.1)

Пример фрагмента программы:

complex z,   i (0,1) ; z = 1 + 2 * i ;    cout << z << "\t" << exp(z) << endl;

(9.2)

Для ввода комплексного числа нужна пара чисел в скобках, при выводе его также увидим пару чисел в скобках.

C объявленными комплексными переменными можно выполнять все арифметические операции, но они будут выполняться по правилам для комплексных величин. B операторах С++ и в функциях форма их записи не отличается от обычных переменных, т.к. изменяется только тип.

    Все стандартные функции имеют обычные имена, причем функция abs(z) дает модуль комплексного числа. Есть несколько функций, применяемых только для комплексных величин:

real(z),   imag(z),    arg(z),   conj(z),   polar(z).