Лекция

ФУНКЦИЮ

функции
}
Если тип не указан, то по умолчанию предполагается, что

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

и возврат в вызывающую программу.
Во-вторых, этот оператор может использоваться для

возврата значения функции.

в теле функции может быть несколько операторов return, но может и не быть ни одного.

Когда функция не возвращает никакого значения, она должна быть описана как функция типа void (пустая).

max ( int a, int b) {
int m;
if (a>b) m=a;

else m=b;
return m;
}
Эта же функция без использования дополнительной переменной:
max(int a, int b) {
if (a>b) return a;
else return b;
}
Можно еще короче:
max ( int a, int b) {
if (a>b) return a;
return b;
}
А можно и так:
max ( int a, int b) {
return (a>b)? a: b;
}

float b, char* с);
или так:
int func ( int,

float, char*);

пример
# include

float sqr(float a); /* это прототип функции, объявление функции */
main() {
float b; b=5.2;
printf("квадрат числа %f равен %f', b, sqr(b));
} /************конец main*************
float sqr(float a) /* Это описание функции */ {
return a*a;
}

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

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

Пример.
Функция swap(), которая должна менять значения параметров местами, не будет фактически это делать

void swap(int a, int b) {
int tmp=a;
a=b;
b=tmp;
}

значение, а адрес переменной, которую нужно изменять,
т. е. передавать

указатель на переменную.
Такой прием в языке С будет называться передачей параметра по ссылке.

void swap 1(int *a, int *b) {
int tmp = *a;
*a=*b;
*b = tmp;
}

void swap(int a, int b);

void swap1 (int *a, int *b);
void main( void) {
int x=5, y=10;
рrintf ("Сначала x = %d у = %d\n", x, y);
swap (x, y);
printf ( "Teперь x= %d y=%d\n", x, y);
printf("Ничего не изменилось ");
swap1(&x, &y); /* Мы должны передать адреса переменных */
printf ( "Teпepь x = %d y=%d\n", x, у);
printf("Значения поменялись ");
return 0;
}

Результатом работы этой программы будет следующее: вначале х=5, у=10, после х=5, у=10.

int MONTHS = 3;
void display ( double [ DISTRICTS ][

MONTHS ] );
///////////////////////////////////////////////////////////
int main ( ) {
double sales [ DISTRICTS ][ MONTHS ] = {
{ 1432.07, 234.50, 654.01 },
{ 322.00, 13838.32, 17589.88 },
{ 9328.34, 934.00, 4492.30 },
{ 12838.29, 2332.63, 32.93 } };

display ( sales );
cout << endl;
return 0;
}

funsales [ DISTRICTS ][ MONTHS ] ) {
int d,

m;
cout << "\n\n";
cout << " Месяц\n";
cout << " 1 2 3";

for ( d = 0; d < DISTRICTS; d++ ) {
cout << "\nОтдел " << d + 1;
for ( m = 0; m < MONTHS; m++ ) {
cout << setiosflags ( ios::fixed )
<< setw ( 10 )
<< setiosflags ( ios::showpoint )
<< setprecision ( 2 )
<< funsales [ d ] [ m ];
}
}
}

int temp=0;

for (int i=0; i for (int j=0; j if (array [j]>array [j+1]){
temp=array[j];
array [j]=array [j+1];
array [j+1]=temp;
}
}
}
}

const int m, const int n)

{
long double** AA =

new long double* [m];
for (int i=0; i
for (i=0; i for (int j=0; j return AA;

};

int n, const long double** B, const int mm, const

int nn) {
if (n != mm) {
cout << "\nERROR: MULTIPLICATION OF MATRIXES IS IMPOSSIBLE!";
getch();
return 0;
}
long double** D = new long double* [m];
for (int i=0; i for (i=0; i for (int j=0; j long double sum = 0;
for (int k=0; k D[i][j] = sum;
}
return D;
};

const int m, const int n)

{
long double** C =

new long double* [m];
for (int i=0; i
for (i=0; i for (int j=0; j return C;

};

main(): argc и argv:

main( int argc, char *argv[] )

{...}

В системе Borland C++ предусмотрен еще и третий аргумент, который, так же как и второй, является указателем на массив строк:

main( int argc, char *argv[], char *env[] ) {...}

Два первых аргумента используются для передачи аргументов командной строки.
Третий аргумент используется для доступа к параметрам среды операционной системы.
Эти три аргумента доступны только функции main().

вызов этой же функции.
Классический пример рекурсивной функции - это

вычисление факториала числа N! = 1*2*3*...*N.

Назовем эту функцию factorial().
Int factorial ( int n ) {
int a;
if (n=l) return 1;
a = factorial(n-l)*n;
return a;
}

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

и имеющую параметры типа type1, type2, объявляется следующим образом:

type

(*pfunc)(type1 t1, type2 t2);

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

x);
double f 1 (double x);
double f2(double x);
double ff(double (* pf)(double

x)); /* Указатель на фукцию в качестве аргумента функции */

main() {
double z=1.1, у;
double (*ptrf)(double x); /* Указатель на функцию */
ptrf=f; /* Инициализация указателя */
y=(*ptrf)(z); /* Вызов функции через указатель - первый способ */

указатель - второй способ */
printf("z=%f y=%f\n", z, у);
ptrf=sin;

/* В качестве функции можно использовать стандартные
библиотечные функции */
y=ptrf(z);
printf(" z=%f sin(z)=%f\n", z, у);
y=(*ptrf)(2.5); /* Можно вызвать функцию и так */
pnntf("z=%f y=%f\n", z, у);
y=ff(fl); /* Вызов функции ff сп параметром f1 */
printf("z=%f y=%f\n", z, у);
y=ff(cos); /* Другой вызов с другой функцией */
printf("z=%f y=%f\n", z, у);
y=ff(ptrf); /* То же через указатель на функцию */
printf("z=%f y=%f\n", z, у);
return 0;
}

x;
}

double f1 (double x) {
puts("In f1()");
return x*x;
}

double f2(double

x) {
puts("In f20");
return x*x*x;
}

double ff(double (* pf)(double x)) /* Функция с указателем
на функцию в качестве параметра */ {
printf(" In ff() %f\n", pf(3));
return pf(3);
}