Определение объекта типа функции.
Напомним, что
объект – это область памяти, которая имеет имя.
Каждый объект характеризуется своим типом. Когда задается тип объекта, системе сообщается:
Размер объекта (система знает, сколько байт выделить под этот объект);
Способ кодировки информации в этой области памяти;
Какие действия можно делать над информацией, записанной в этой области памяти и как их делать.
Объект типа функция относится к группе производных типов. Правила работы с этими объектами (размер, способ кодировки, действия) определил разработчик языка, они заложены в компилятор языка и система их «знает». Эти правила необходимо изучить для того, чтобы уметь работать с этими объектами.
Функция – это имя типа объекта. Но объекты типа функция обычно называют просто функциями.
|
Для того, чтобы в программе можно было работать с объектом, его надо физически создать, т.е. программист на языке С++ должен дать указание на его создание – на выделение памяти требуемого размера и нужной кодировки. Выделенной памяти должно быть присвоено имя. В этом случае говорят, надо определить (defined) объект. Определить объект можно только один раз!!!!!!!!
Объект, который определен, одновременно и описан (declared).
|
Итак, определение объекта типа функция состоит из заголовка функции и тела функции.
Вот как синтаксически выглядит определение функции:
тип_возвращаемого_значения имя_объекта_функции (список_формальных_параметров )
{
/* Это тело функции. Здесь пишутся инструкции, которые определяют объекты, создаваемые внутри функции – локальные объекты.
Здесь пишутся инструкции, задающие действия над этими объектами - алгоритм работы функции
*/
}
Заголовок функции это:
тип_возвращаемого_значения имя_объекта_функции (список_формальных_параметров )
Заголовок функции задает, каким образом организован обмен данными между ней и вызвавшей ее объектом–функцией.То есть заголовок определяет, какие данные и как функция получает от функции, вызвавшей ее, а также какие результаты своей работы функция возвращает и как она их возвращает в точку ее вызова.
Тело функции, заключено в фигурные скобкиис помощью инструкций описывает алгоритм обработки тех данных, которые функция получила либо через параметры от вызвавшей ее другой функции, либо каким-нибудь другим способом ( например, с клавиатуры или прочитала эти данные из файла):
{
/* Это тело функции. Здесь пишутся инструкции, которые определяют объекты, создаваемые внутри функции – локальные объекты.
Здесь пишутся инструкции, задающие действия над этими объектами -алгоритм работы функции
*/
}
Как известно, определить объект типа функция, как и любой другой объект, можно только один раз. И как любой другой объект функцию порой приходится описывать. Зачем? Для того, чтобы уметь правильно с этим объектом работать, когда его по каким либо причинам «не видно» (например тело функции определено не в том файле из которого его вызывают).
Как выглядит инструкция описания функции?
Описание функции– это точная копия заголовка функции,после которого стоит точка с запятой(ведь это инструкция!):
тип_возвращаемого_значения имя_объекта_функции (список_формальных_параметров ) ;
Для инструкции описания функции есть специальное название – прототип(prototype).
По инструкции описания объект не создается, а только объявляется, что такой объект должен быть создан и его характеристики – имя и список параметров будет таким, каким он описан.
В примере тела функции показано, как записать в программе на языке С++ много строковый комментарий. В комментарии можно дать нужные пояснения к всей программе, ее частям – функциям или к отдельным инструкциям. Комментарии системой не воспринимается как распознаваемый текст. Этот текст только для чтения программистом:
/* это много
строковый
комментарий */
Комментарий, который занимает одну строку, можно создать так:
// это комментарий в одну строку
В комментарии можно использовать любые символы.
Главная функция в СИ++ как точка входа в программу.
Так как программа может состоять из одной или нескольких объектов-функций, то система должна знать, с какой функции следует начинать выполнять программу.
Такой функцией всегда будет функция, которая имеет имя main:
// тип_возвращаемого_значения имя_объекта_функции(список_формальных_параметров )
void main ( void )
{
// инструкции тела функции main
}
Слово voidявляется зарезервированным словом иименем никакого типа (пустого типа). В заголовке этой функции имя типа voidиспользуется в списке ее формальных параметров чтобы указать, что функция не имеет параметров (список ее формальных параметров пустой) – она не получает информации от других объектов – функций, так как ее никто не вызывает, она первая исполняемая функция в программе. Тип возвращаемого значения этой функции указан как тип void, то есть эта функция не передает информацию никакому другому объекту-функции через возвращаемое значение.
Операторы языка С++. Инструкция выражения.
Тело функции состоит из инструкций (statement). Часть инструкцийопределяет объекты, которые должны хранить обрабатываемые этой функцией данные, часть инструкцийзадает последовательность действия над этими объектами.
Действия над объектами (операции) в С++ осуществляются операторами (operator), которые задаются одним или более символов. ( Обратите внимание, что в других языках и часто и в учебникахC++инструкции (statement)называютсяоператорами, аоператоры-операциями).
Все операторы представляют собой отдельные лексемы, например + - / sizeof ::.
По количеству операндов, участвующих в действии, определяемой оператором, операторы делятся на унарные(действие осуществляется над одним объектом) ибинарные(действие осуществляется над двумя объектами).
Понятие выражения.
Выражение (выр expression) –это последовательность имен объектов, соединенных операторами. Выражение задает выполнение некоторых действий над объектами в виде математической формулы и/или отношения.
Например, если определены следующие объекты:
int nA1, nA2 ;
float fltB ;
то выражения могут выглядеть так:
nA1 +fltB– 2. /nA2
или так
fltB= 2.8
или так
nA1 = (nA2 +fltB) /nA2 -fltB*nA1
Порядок выполнения операторов в выражении.
Последовательность действий в выражениях определяется приоритетом операторов. Для изменения порядка выполнения операторов используются скобки.
В таблице приведены операторы языка, сгруппированные в порядке их приоритетов.
СВОДКА ОПЕРАТОРОВ (операций ) С++ В каждой очерченной части находятся операторы с одинаковым приоритетом
|
Приоритет |
Оператор |
Назначение оператора |
Синтаксис оператора |
|
1 |
:: |
разрешение области видимости |
имя_класса :: член |
|
:: |
глобальное |
:: имя | |
|
2 |
-> |
выбор члена |
указатель -> член |
|
[ ] |
индексация |
указатель [выр] | |
|
( ) |
вызов функции |
выр ( список_выр ) | |
|
sizeof |
определение размера типа |
sizeof ( тип ) | |
|
sizeof |
определение размера объекта |
sizeof выр | |
|
3 |
++ |
приращение после |
lvalue ++ |
|
++ |
приращение до |
++ lvalue | |
|
- - |
уменьшение после |
lvalue - - | |
|
- - |
уменьшение до |
- - lvalue | |
|
~ |
дополнение |
~ выр | |
|
! |
не |
! выр | |
|
- |
ударный минус |
- выр | |
|
+ |
ударный плюс |
+ выр | |
|
& |
адрес объекта |
& lvalue | |
|
* |
разыменование |
* выр | |
|
new |
создание (размещение) |
new mun | |
|
delete |
уничтожение (освобождение) |
delete указатель | |
|
delete [ ] |
уничтожение массива |
delete [] указатель | |
|
( ) |
преобразование типа |
( тип ) выр | |
|
4 |
* |
умножение |
выр * выр |
|
/ |
деление |
выр / выр | |
|
% |
взятие по модулю (остаток) |
выр % выр | |
|
5 |
+ |
сложение (плюс) |
выр + выр |
|
- |
вычитание (минус) |
выр - выр | |
|
6 |
<< |
сдвиг влево |
lvalue << выр |
|
>> |
сдвиг вправо |
lvalue >> выр | |
|
7 |
< |
меньше |
выр < выр |
|
<= |
меньше или равно |
выр <= выр | |
|
> |
больше |
выр > выр | |
|
>= |
больше или равно |
выр >= выр | |
|
8 |
= = |
равно |
выр == выр |
|
!= |
не равно |
выр != выр | |
|
9 |
& |
побитовое И |
выр & выр |
|
10 |
^ |
побитовое исключающее ИЛИ |
выр ^ выр |
|
11 |
| |
побитовое включающее ИЛИ |
выр | выр |
|
12 |
&& |
логическое И |
выр && выр |
|
13 |
|| |
логическое ИЛИ |
выр || выр |
|
14 |
?: |
арифметический if |
выр ? выр : выр |
|
15 |
= |
простое присваивание |
lvalue = выр |
|
* = |
умножить и присвоить |
lvalue * = выр | |
|
/ = |
разделить и присвоить |
lvalue / = выр | |
|
% = |
взять по модулю и присвоить |
lvalue % = выр | |
|
+ = |
сложить и присвоить |
lvalue + = выр | |
|
- = |
вычесть и присвоить |
lvalue - = выр | |
|
16 |
, |
запятая (последование) |
выр , выр |
I ++ равнозначно I = I + 1
++ I равнозначно I = I + 1
J = I ++ равнозначно двум действиям в таком порядке J = I I = I + 1
J = ++ I равнозначно двум действиям в таком порядке I = I + 1 J = I
|
Термин lvalue (left value) – леводопустимое выражение (происходит от объяснения оператора присваиванияLV=A, в котором левый операндLVможет быть только адресным объектом, в который копируется информация, т.е. изменяемым выражением).
|
Неявное преобразование типов в выражении.
Результат выполнения выражения это всегда одно значение, которое характеризуется своим типом.
Если в выражение входят операнды одного типа, то значение выражения будет того же типа. В выражении операнды могут быть различных типов. Тогда перед вычислением выражения будут выполняться преобразования типов по умолчаниютаким образом, чтобы осуществить преобразования более коротких типов в более длинные для сохранения значения и точности (это не относится! к оператору =)
Например, если определены следующие объекты:
int nA1 = 2,nA2 = 5.5;// значение объекта nA2 равно 5, так как произошло неявное
// преобразование константы 5.5 типа float к типу int при выполнении оператора =
float fltB= 3;
Выражение nA1 + 2 -nA2 будет иметь значение -1, тип которогоint (все операнды в выражении типа int).
Выражение fltB=nA1+ 2 -nA2 будет иметь то же значение -1., но тип его будетfloat, так как при выполнении оператора = произошло неявное преобразование внутреннего представления информации в объектеfltB.
Выражение nA1 + 2.2 -nA2 будет иметь значение0.8, тип которогоfloat (один из операндов константа 2.2 имеет тип float, следовательно все операнды в выражении преобразованы к более длинному типу float).
Выражение fltА2=nA1+ 2.2 -nA2 будет иметь то же значение0, тип его будетint, так как при выполнении оператора = произошло неявное преобразование значения0.8, вычисленного в выраженииnA1 + 2.2 -nA2 и имеющего значениеfloat к типуint .
Разберитесь каковы значения и тип у следующих выражений:
nA1 +fltB– 2. /nA2// значение 4.6 , тип float, т.к. значение 2. / nA2 равно 0.4
nA1 +fltB– 2 /nA2// значение 5., тип float, т.к. значение 2 / nA2 равно 0
или так
fltB= 2.8// значение 2.8 , тип float
или так
// 1.6 - 6
nA1 = (nA2 +fltB) /nA2 -fltB*nA1// при выполнении последнего оператора =
// nA1 = - 4.4 получили значение равное -4, тип int
Инструкция выражения.
Инструкция- выражение – это выражение, после которого стоит точка с запятой.
Например:
nB= 2.8;
nA1 = (nA2 +fB) /nA2 -fB*nA1;
Инструкция выражение делает то, что делают над объектами операторы, записанные в выражении. Это одна из самых мощных инструкций, так как количество сочетаний различных действий, записанных в выражениях бесконечно.
Пример первой программы, состоящей из одной функции main.
Далее следует пример программы, состоящей из одной функции. А раз функция одна, то такой функцией может быть только функция main.
Обратите внимание на цвет текста. Зарезервированные слова пишутся в редакторе синим цветом, комментарии зеленным, все остальные слова (слова, начертания которых определяет программист ) и символы–операторы черные.
/* файл first.cpp содержит программу, 1
состоящую из одной функции main 2
единственное действие этой программы - 3
ввести два числа, вычислить их сумму, 4
вывести на экран эту сумму и 5
приветствие "BYE !" 6
7 */
// ============================================= 8
#include <iostream> // 9
#include <conio.h> // 10
using namespace std; // 11
// 12
void main (void) // 13
{ // 14
int nA; // 15
float fltB; // 16
cout <<"Input numbers:\t" // 17
<<"\nfirst int\t"; // 18
cin>>nA; // 19
cout<<"second float\t"; // 20
cin>>fltB; // 21
float fltSumma; // 22
fltSumma = nA + fltB; // 23
cout<<"summa = " << fltSumma; // 24
cout<<endl<<"\tBYE !"; // ПОКА 25
getch(); // 26
} // 27
Рассмотрим приведенный текст.
Программа содержит функцию main.
Она состоит:
из заголовка ( строка 13 );
тела ( строки 14 – 27 ).
Тело функции состоит из инструкций. Каждая инструкция заканчивается точкой с запятой. Инструкций в теле функции всего 11, из них 3 – это инструкции определения объектов nA( строка 15), fltB ( строка 16), fltSumma ( строка 22). Эти инструкции создают объекты, выделяя под них память. Напоминаем, что любой объект, имя которого встречается в программе, должен быть определен и определен всего один раз. Инструкции определения объектов легко распознать, онивсегда начинаются с имен типов – здесь имена типов int и float (строки 15, 16, 22). Кроме этого в функции определены константные объекты-строки.Константные объекты-строки - это последовательности символов, взятые в двойные кавычки.
Вот эти пять объектов:
"Input numbers:\t"
"\nfirst int\t"
"second float\t"
"summa = "
"\tBYE !"
Обратите внимание, что почти в каждой из этих строк присутствуют escape-символы (здесь, для того чтобы их разглядеть, они выделены жирным курсивом).
Стандартные потоковые объекты С++ (cin, cout) и потоковые операторы >>, <<.
Кроме объектов na, fltb, fltSumma и константных строк в тексте появились именаcout иcin. Объектыcout иcin – это имена стандартных абстрактных объектов, тип их называется«поток», с их помощью организуется ввод и вывод в С++. Объектcoutсовместно с оператором>>организует вывод информации из памяти на экран. Объектcin совместно с оператором<< организует ввод информации с клавиатуры в память.
сout и cin - это имена объектов, но если мы пытаемся воспользоваться этими объектами, где их определения, где и когда они создаются?
Описание объектов в хэдерных файлах .h. Область видимости имен – оператор using namespace std;
Определение стандартных объектов cout иcin присоединяется в строке 9. В этой строке записана директива#includeспециальной программы – препроцессора.
|
Препроцессор (preprocessor) - это программа, выполняющая предварительную обработку входных данных (исходного файла с расширением .срр) для другой программы (компилятора). Препроцессор до начала работы программы-компилятора:
|
Директива препроцессора содержит указания препроцессору о том, какие действия необходимо этой программе выполнить. Директивы препроцессора всегда начинаются с символа #
Директива #include вставляет перед текстом функцииmain текст файла iostream. Обратите внимание, что эта директива не является элементом языка С++, это элемент другого языка, языка программы препроцессор.
Директива, не является инструкцией языка С++, а потому неимеет заканчивающей её точки с запятой.
В тексте файла iostreamнаходятся определения объектов cout иcin, эти определения и присоединяются к тексту программы.
Имя файла iostreamзаписано в треугольных скобках < >, что является указанием системе, где, в каких папках искать файл и соответствующую ему библиотеку. Этот поиск делается автоматически на этапе компоновки.
Объект endl определен также в файлеiostream, он работает так, как иescape-символ ‘\n‘ - переводит курсор при выводе на новую строку экрана.
Обратите внимание на инструкцию using namespace языка С++ в строке 19:
using namespace std;
Эта инструкция определяет область имен, где необходимо искать определения используемых в программе имен объектов. Дело в том, что сейчас существует очень много различных библиотек, в которых могут появиться одинаковые имена. Инструкция using namespace определяет, что поиск нужно осуществлять в области имен стандартной библиотеки std.
Последнее имя, которое используется в этой программе – имя getch. Это имя объекта типа функция. Как система и мы узнаем, что это имя функции, а не какого-то объекта любого другого типа? Этим признаком является то, что сразу после этого имени появляетсяоператор вызова функции – круглые скобки () (смотрите таблицу сводки операторов С++, приоритет 2).Этот объект, как и любой объект должен быть определен в функции, если им нужно воспользоваться.Описания стандартных функций находятся в .h файлах.Описание этой функции getchнаходится в файлеconio.h , который подключается директивой препроцессора#include в строке 10. Аопределения этого стандартного объекта-функции (его код) находится в стандартной библиотеке (LIB). Самоопределение этого объекта- функции будет найдено автоматически в стандартной библиотеке и подключено к нашему коду на этапе компоновки.
Файлы, в которых находятся описания или определения стандартных объектов называются хэдерные файлы (заголовочные файлы),имогут иметь или не иметь расширение.h
В функции main7 инструкций-выражений.
Что делают инструкции-выражения?
Инструкции-выражения делают то, что делают операторы, которые в них используются.
Инструкции-выражения
cout << "Input numbers:\t" << "\nfirst int\t";
cout << "second float\t";
cout << "summa = " << fltSumma;
cout << "\n\tBYE !";
используя оператор <<, совместно с потоковым объектом cout выводят на экран информацию из области памяти строковых констант и объектаfltSumma. Обратите внимание, чтооператор << может использоваться каскадом(то есть оператор<< используется несколько раз с одним объектомcout).
Инструкции-выражения
cin>>nA;
cin>>fltB;
используя оператор >> совместно с потоковым объектом cin копируют информацию, введенную пользователем с клавиатуры, в область объектов nA и fltB.
Заметим, что оператор >> тоже может использоваться каскадом(оператор>> используется несколько раз с одним объектомcin).
Например две инструкции могли быть записаны как одна:
Cin >> nA >>fltB;
Инструкция-выражение
fltSumma = nA + fltB;
с помощью оператора + вычисляет сумму значений объектов nA и fltB и результат этого суммирования с помощью оператора= (присвоить) копирует в объект fltSumma.
Инструкция-выражение
getch();
с помощью оператора () (оператор вызова функции)вызывает функциюс именем getch, иничего больше эта инструкция – выражение не делает!!!!!!
Еще раз напоминаем, что инструкция-выражение делает только то, что делают над объектами операторы, записанные в выражении.
Другой вопрос: а что делает вызванная стандартная функция, зачем она вызвана в этом месте?
Каждая функция делает то, что задает ее алгоритм. Эта функция – функция getchожидает, пока не будет введен какой либо символ.
В этой программе вызов функции getchв инструкции-выражение сделан для того, чтобы с ее помощью организовать задержку.
Программа не будет выполнять следующие действия, пока не будет введен пользователем любой символ. Программа не будет заканчивать свою работу по закрывающей тело функции main скобке}, пока пользователь не рассмотрит результат работы программы на экране и а после этого не введет символ, в нашей программе не важно какой.