Технологии программирования

и операторов, выполняющая какое-либо законченное действие. Функция может принимать параметры

и возвращать значение.

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

Любая функция должна быть объявлена и определена.

Объявление функции (прототип,

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

[class:: (класс)] тип имя ([ список_параметров ]) [throw (исключения)]
{
тело функции
}

(исключения)]
{
тело функции
}

С помощью

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

])
[throw ( исключения )]
{

тело функции
}

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

(исключения)]
{
тело функции
}

Список параметров

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

помощью модификатора inline, который рекомендует компилятору вместо обращения к функции

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

Пример
inline int func(void) {
    return 5;
}
 int main(void) {
    int n = func();
 }

ее функцию реализуется оператором

return [ выражение ];

Функция может содержать несколько операторов return.

Если функция описана как void, выражение не указывается.

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

// правильно

void f2() { return 1; } //

неправильно, f2 не должна
// возвращать значение

double f3() { return 1; } // правильно,
// 1 преобразуется к типу double

Нельзя возвращать из функции указатель на локальную переменную.

Пример:
int* f() {
int a = 5;
return &a; // нельзя!
}

величин:

#include ;
#include ;
using namespace std;
int sum(int a, int b);

// объявление функции
 
void main() {
int a = 2, b = 3, c, d;
c = sum(a, b); // вызов функции
cin >> d;
cout << sum(c, d); // вызов функции
_getch();
}
int sum(int a, int b) { // определение функции
return (a + b);
}

величин:

#include ;
#include ;
using namespace std;
int sum(int a, int b) {

// объявление и
return (a + b); // определение функции
}

void main() {
int a = 2, b = 3, c, d;
c = sum(a, b); // вызов функции
cin >> d;
cout << sum(c, d); // вызов функции
_getch();
}
 

величин:

#include ;
#include ;
using namespace std;
int sum(int x, int y) {

// объявление и
return (x + y); // определение функции
}

void main() {
int a = 2, b = 3, c, d;
c = sum(a, b); // вызов функции
cin >> d;
cout << sum(c, d); // вызов функции
_getch();
}
 

a) {
cout

{
static int n = 0;
int m = 0;
cout << n++ << ' ' << m++ << '\n';
}
}
void main() {
f(3);
_getch();
}
Статическая переменная n размещается в сегменте данных и инициализируется один раз при первом выполнении оператора, содержащего ее определение.

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

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

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

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

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

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

#include ;
#include ;
using namespace std;
int sum(int a, int b); // объявление функции
void main() {
int a = 2, b=3, c, d;
c = sum(a,7); // вызов функции
cin >> d;
cout << sum(c, d); // вызов функции
_getch();
}
int sum(int k, int m) { // определение функции
return (m*k + b);
}

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

описания функции, называются формальными, а записанные в операторе вызова функции — фактическими (или аргументами).

Существует два вида передачи величин в функцию:
по значению и по адресу.

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

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

i, int* j, int& k);
void main() {
int

i = 1, j = 2, k = 3;
cout << "i j k\n";
cout << i << ' ' << j << ' ' << k << '\n';
f(i, &j, k);
cout << i << ' ' << j << ' ' << k;
_getch();
}
void f(int i, int* j, int& k) {
i++;
(*j)++;
k++;
}

модификатор const:


int f(const char*);

char* t(char* a, const int* b);

передается по адресу.

При этом информация о количестве элементов массива

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

int* mas, const int n);
int const n = 10;
void main()

{
int marks[n] = {3, 4, 5, 4, 4};
cout << "Сумма элементов массива: " << sum(marks, n);
} 
int sum(const int* mas, const int n) {
/* варианты:
int sum(int mas[], int n) или
int sum(int mas[n], int n)
*/
int s = 0;
for (int i = 0 ; i < n; i++)
s += mas[i];
return s;
}

;
using namespace std;
struct Worker {
char fio[30];
int

date, code; float salary;
};
void input_worker(Worker& w); // объявление функции
void print_worker(Worker w); // объявление функции

void main() {
Worker stuff[3];
for (int i = 0; i < 3; i++)
input_worker(stuff[i]); // вызов функции
for (int i = 0; i < 3; i++)
print_worker(stuff[i]); // вызов функции
_getch();
}

= 0; i < 3; i++)
input_worker(stuff[i]);

// вызов функции
for (int i = 0; i < 3; i++)
print_worker(stuff[i]); // вызов функции
_getch();
}


void input_worker(Worker& w) { // определение функции
cout << "Vvedite famil, datu, code, salary " << endl ;
cin >> w.fio >> w.date >> w.code >> w.salary ;
}

void print_worker(Worker w) { // определение функции
cout << w.fio << ' ' << w.date << ' ' << w.code << ' ' << w.salary << endl ;
}

input_worker(&stuff[i]); // вызов функции

for (int i = 0; i < 3; i++)
print_worker(stuff[i]); // вызов функции
_getch();
}


void input_worker(Worker* w) { // определение функции
cout << "Введите фамилию, 2 целых и одно вещ число" << endl ;
cin >> w->fio >> w->date >> w->cd >> w->var;
}
void print_worker(Worker w) { // определение функции
cout << w.fio << ' ' << w.date << ' ' << w.cd << ' ' << w.var<< endl ;
}

{
char fio[30];
int date, code;
float

salary;
};
void print_worker(Worker); // объявление функции
void main() {
Worker stuff[100];
for (int i = 0; i < 100; i++)
print_worker(stuff[i]); // вызов функции
_getch();
}
void print_worker(Worker w) { // определение функции
cout << w.fio << ' ' << w.date << ' ' << w.code << ' ' << w.salary;
}

применить альтернативный способ выделения памяти:

#include ;
using namespace std; 
int sum(const int

**a, const int nstr, const int nstb); 
void main() {
int nstr, nstb;
cin >> nstr >> nstb;
  int **a;
a = new int* [nstr];
for (int i = 0; i < nstr; i++)
a[i] = new int[nstb];  /* ... формирование матрицы a */
  cout << sum(a, nstr, nstb);
}
int sum(const int **a, const int nstr, const int nstb) {
int i, j, s = 0;
for (i = 0; i < nstr; i++)
for (j = 0; j < nstb; j++)
s += a[i][j];
return s;
}

заголовке можно указать значения параметров по умолчанию.
Эти параметры должны

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

int f(int a, int b = 0);
void f1(int, int = 100, char* = 0);
void err(int errValue = errno); //errno — глобальная переменная

f(100); f(a,1); // варианты вызова функции f
f1(a); f1(a,10); f1(a,10,"Vasia"); // варианты вызова функции f1
// f1(a,,"Vasia") неверно!

можно вызвать через указатель на нее. Для этого объявляется указатель

соответствующего типа и ему с помощью операции взятия адреса присваивается адрес функции:

void f(int a) { /* ... */ }// определение функции
void (*pf)(int); // указатель на функцию // ... 
pf = &f; // указателю присваивается адрес функции
// (можно написать pf = f;)
pf(10); // функция f вызывается через указатель pf
//(можно написать (*pf)(10);)

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

содержащую функцию вычисления xn
Составьте программу, содержащую функцию вычисления n!

содержит следующие функции:
Меню, содержащее пункты, соответствующие функции
Ввод элементов массива
Нахождение суммы

элементов массива
Нахождения максимального элемента массива
Вывод массива
Сортировку элементов массива  
Выход из меню