Имя функции max3– это идентификатор

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

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

Подпрограммы бывают двух типов: процедуры и функции. В С и С ++ есть только функции. Любая программа на C++ состоит из функций, одна из которых должна иметь имя main (с нее начинается выполнение программы). Описание функции имеет следующий вид: [модификаторы] тип_возвр_значения имя_фукции([формальн_параметры]) {тело_функции} Функцию можно рассматривать как операцию, определенную пользователем. Операнды функции, или формальные параметры, задаются в списке параметров через запятую. Список параметров заключается в круглые скобки. Через параметры в функцию можно передавать значения. Параметр описывает тип значения, которое будет передано в функцию при ее вызове.

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

Для явного преобразования типа выражения используется оператор преобразования типа: Синтаксис: (тип) выражение где в скобках – один из простых типов данных. (int)(1.5 / 0.3); // тип int (float)(1.5 / 0.3); // тип float В выражении приоритет преобразования типов данных приравнивается к приоритету унарных операторов.

Такое приведение типов называется неявным. Стиль приведения на С поощряет неявное преобразование типов данных. Любое арифметическое выражение, включающее операнды, типы которых не превышают int, перед вычислением всегда преобразовывается в тип int.

Составные операторы присваивания

Остальные операторы будут рассмотрены позднее.

В первом случае вычисляется размер для значения выражения, во втором – размер любой переменной заданного типа. Рассмотрим примеры (предполагается, что переменная t имеет тип int, а переменная f – тип float).

Что вычисляется в следующем операторе?

Lt; 2) // =0

X < y) || (x > =y) // =1

Примеры: (x < y) && (x > y) // =0

Сравнивать можно операнды любого типа, но либо они должны быть оба одного и того же встроенного типа, либо между ними должна быть определена соответствующая операция сравнения, сравнение на равенство и неравенство может быть для двух величин любого типа. Результат сравнения – логическое значение trueили false.

Операторы сравнения и логические операторы не изменяют значения своих операндов, а только вычисляют значение ложь или истина.
Любое значение, не равное нулю, счтается истиной, равное нулю – ложью.
Поэтому вместо сравнения величины с нулем
if (a!= 0)
можно использовать
if (a)

Пример:
int i=2, j=-3, k=5, l=1;
char c1='S', c2='U';
bool b;
b = i > 3; cout << b << endl; // 0
b = i >=3; cout << b << endl; // 0
b = i < 3; cout << b << endl; // 1
b = k!=2; cout << b << endl; // 1
b = j == i – k;
cout << b << endl; // 1
b = 'U' < 'S';
cout << b << endl; // 0
b = l == (k > i);
cout << b << endl; // 1

Логические операторы

&& логическое “и” (конъюнкции)
|| логическое “или” (дизъюнкции)
! логическое “НЕ “(отрицание)
Операнды - логические значения, результат – тоже логическое значение.

Условный оператор
Имеет вид:
условие? выражение1: выражение2
Его результат равен значению выражения1, если условие истинно, и значению выражения2 в противном случае. Это тернарная операция: первый операнд должен быть логическим значением, второй и третий операнды могут быть любого, но одного и того же, типа, а результат будет того же типа, что и третий операнд.
Использование этого оператора позволяет изящно записать несложные сравнения, например: s = a>0? a: 0;
Переменная s получит значение переменной a, если a>0 и значение 0 в противном случае.
int a = 1, b = 0;
c = (a>b)? 2: 3; // c = 2

X = (X >= 0.0)? X: -X;

#include <iostream>

using namespace std;

int main()

{

setlocale(LC_ALL,".1251");

float balance, payment;

cout << "введите сумму заема: ";

cin >> balance;

cout << "\nвведите сумму погашения: ";

cin >> payment;

cout << "\nваш баланс: ";

cout << ((payment>balance)? "переплачено на $": "уплачено $");

cout << ((payment>balance)? payment - balance: payment);

cout << " по заему на сумму $" << balance << ".\n";

return 0;

}

Оператор последовательного вычисления (запятая)
Служит для перечисления нескольких выражений в одной инструкции. Выражения вычисляются слева направо. Значением всего выражения является значение последнего из выражений.
Синтаксис:
выражение, выражение [,…, выражение ];
Оператор запятая имеет самый низкий приоритет.
int i=0;
float x=0, y=0;
x=(y=3, y+1);
// переменная x получит значение 4
x=(y=3.5, i=2, x=y+i, i=x);
// переменная x получит значение 5

int n=2,m=3;
int z;
z=(m++,m+n); // z=6
или
m++,z=m+n; // z=6
но
z=m++,m+n; // z=3
Оператор запятая используется обычно там, где по синтаксису должно быть одно выражение
for (I=1,J=5; I<=10;I++,--J)

Оператор измерения размера

имеет две формы:

sizeof выражение и

sizeof(тип)

int t;

float f;

t = sizeof(int);

//результат для Microsoft Visual C++: 4

t = sizeof(float); // результат: 4

t = sizeof f; // результат: 4

t = sizeof(f+0.1);

/* результат: 8, т.к. константа имеет тип double, скобки нужны для задания приоритета */

Выражения
В С++ выражением считается любая допустимая комбинация операторов, констант, функций и переменных.
Выражение, после которого стоит точка с запятой – это инструкция-выражение. Ее смысл состоит в том, что компьютер должен выполнить все действия, записанные в данном выражении, иначе говоря, вычислить выражение.

Примеры выражений:
(x + y) – 12*sin(с)
Sqrt(c*c – a*a)
Abs(s1–s2)/(3*x+7*y*z)–1/(sqr(a)+sqr(b))
Sin(x*x)+cos(2*pi–alpha)

Приоритет операций
Приоритетом операции называется очередность выполнения операции в выражении, в котором должно быть выполнено несколько операций. Так как в С++ операции задаются с помощью операторов, можно говорить о приоритете операторов. Далее приведены основные операторы С++, сгруппированные в порядке убывания приоритетов:

разрешение области действия ::
-----------------------------------------------
индексация [ ]
вызов функции и подвыражение ()
доступ к члену структуры.
доступ к члену структуры через указатель ->
префиксный инкремент ++
префиксный декремент --
------------------------------------------------
выделение памяти new
освобождение памяти delete
освобождение памяти из-под массива delete[ ]
разыменование *
взятие адреса &
унарный +
унарный -
логическое отрицание!
поразрядное логическое НЕ ~
получение размера sizeof
получение типа typeid
преобразование типа: (type), const_cast, dynamic_cast, reinterpret_cast, static_cast
-----------------------------------------------

умножение *
деление /
остаток от деления %
-----------------------------------------------
сложение +
вычитание –
-----------------------------------------------
поразрядный сдвиг влево <<
поразрядный сдвиг вправо >>

-----------------------------------------------

меньше <

больше >

меньше или равно <=

больше или равно >=

-----------------------------------------------

равно ==

не равно !=

-----------------------------------------------

поразрядное логическое И &

-----------------------------------------------

поразрядное исключающее ИЛИ ^

-----------------------------------------------

поразрядное логическое ИЛИ |

-----------------------------------------------

логическое И &&

-----------------------------------------------

логическое ИЛИ ||

-----------------------------------------------

тернарный условный оператор ?:

-----------------------------------------------

присваивание =

*= /= %= += -= <<= >>= &= ^=

-----------------------------------------------

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

постфиксный инкремент ++

постфиксный декремент --

-----------------------------------------------

Сокращенный вариант:
Приоритет операторов
1. Вычисления в круглых скобках
2. Вычисления значений функций
3. Унарные операторы:
! -(изменение знака) +
4. Операторы типа умножение: * / %
5. Операторы типа сложения: + -
6. Операторы сдвига: << >>
7. Операторы отношения:
< <= > >= = =!=
8. Оператор &
9. Оператор ^
10.Оператор |
11.Оператор &&
12.Оператор ||
13.Условный оператор?:
14. Оператор,

Порядок вычисления операторов
В С++ все операторы выполняются (имеют ассоциативность) слева направо, кроме операторов:
разрешения области действия ::
выделение памяти new
освобождение памяти delete
освобождение памяти из-под массива delete[ ]
разыменование *
взятие адреса &
унарный +
унарный –

логическое отрицание!
поразрядное логическое НЕ ~
получение размера sizeof
получение типа typeid
преобразование типа (type) const_cast dynamic_cast reinterpret_cast static_cast
Эти операторы имеют асссоциативность справа налево.
Приведение типов в выражениях

Если в выражение входят константы и перемненные различных типов, они последовательно, по ходу выполнения вычислений, преобразуются к одному, "покрывающему" типу (типу с наибольшим диапазоном значений.). Последовательность типов в С++ от "покрывающих" к "покрываемым":

Пример 7.1. Функция нахождения максимального числа среди трех целых чисел.

int max3(int a,int b,int c)//заголовок ф-ии

{ //начало тела функции

int max;

if (a > b)

max = a;

else

max = b;

if (c > max)

max = c;

return max;

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

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

int m, x=67, y=98, z=56;

cout << max3(x,y,z)<< endl; //98

cout << max3(9,7,111)<< endl; //111

Объявление и определение функций
Различают объявление и определение функции.
Объявление (прототип) функции совпадает с ее заголовком, отличие лишь в том, что оно заканчивается точкой с запятой:
int max3(int a,int b,int c);
В объявлении можно не указывать имена формальных параметров:
int max3(int,int,int);

int max3(int x,int n)

//это заголовок функции

Дата добавления: 2013-12-13