здесь определена функция countX

void countX (float c, float& x)

{

x = (aGl * cos(bGl + c) - bGl * sin(aGl + c)) / (pow(aGl,3) + bGl * bGl);

}

 

 

Приложение 1

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

 

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

Например, имя NameStudent, summa, MyType.

Старые программные языки высокого уровня никогда не имели сложной файловой структуры сегодняшних приложений С/C++. Они не различали регистр, так что имена вроде mytype, MYTYPE и MyType рассматривались как одно и тоже имя. Для С/C++ это разные имена. Разумное использование символов ВЕРХНЕГО и нижнего регистров делает профессиональный код более читабельным. Для имен объектов  в исходных файлах (.c/.cpp) используют СмеШанНый регистр. Зная это, делаем вывод, что имена MyType  или  myType предпочтительнее, чем имена mytype и MYTYPE, так как такие имена легче читаются.

 

Введенное венгром Чарльзом Симонии из Microsoft соглашение об именах, которое называется «венгерская нотация», позволяет программисту по имени объекта узнать и его  тип. Это достигается присоединением к имени мнемонического префикса, кодирующего тип.

Так как типичное приложение Windows использует десятки различных типов данных, констант (определяемых ключевым словом const), символических констант (определяемых директивой препроцессора # define), структур, классов, сообщений и прочего, то

такое «встроенное»  в имя объявление типа облегчает расшифровку кода, поскольку отпадает необходимость по его тексту вспоминать или отыскивать определение каждого объекта.

Соглашения Microsoft об именах, специфических для Windows, показаны в таблице.

 

 

Префикс	Тип	Описание	Пример имени
g_	-	префикс глобального объекта	g_gravConst
c	const	Именованная константа произвольного типа	cfltPi
ch	char	8 битный символ	chGrade
ch	TCHAR	16-битный символ, если определен _UNICODE	chName
b	BOOL	булевое значение	bEnabled
n, i	int	целое (размер зависит от системы)	nLength, iLength
n	UINT	беззнаковое целое	nHight
w	unsigned int	16-битовое беззнаковое целое	wMaska
w	WORD	16-битовое беззнаковое целое	wPos
l	LONG	32-битное целое со знаком	lOffset
l	long	32-битное целое со знаком	lLenght
dw	DWORD	32-битное целое без знака	dwRange
flt	float	32-битное действительное	fltValue
dbl	double	64-битное действительное	dblValue
p	тип *	указатель	pDoc
lp	FAR*	дальний указатель	lpDoc
sz	string	строка	szNameStudent
psz	char*	указатель на символьную строку	lpszName
lpsz	LPSTR	32-битный указатель на символьную строку	lpszName
lpsz	LPSTR	32-битный указатель на символьную строку	lpszName
pv	void*	указатель на void	pvMember
h	handle	дескриптор объекта Windows	hWnd
lpfn	callback	Дальний указатель  на CALLBACK -функцию	lpfnProc

 

Посмотрите на такой фрагмент текста:

Value1 = 1;

Value2 = 2;

Result = Value1 / Value2;

// результат получает почему-то значение 0, вместо ожидаемого значения 0.5

 

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

 

А теперь рассмотрим тот же фрагмент, написанный в стиле венгерской нотации:

nValue1 = 1;

nValue2 = 2;

fltResult = nValue1 / nValue2;

// результат получает почему-то значение 0, вместо ожидаемого значения  0.5

 

 Здесь добавлены в имена мнемонические префиксы. Это позволяет программисту, читающему этот текст, даже не ища инструкции определения объектов, предположить потенциальную ошибку усечения результата -  в С++ оператор деления   /   при делении целого на целое дает целый результат, то есть  в данном случае результатом является

целый 0.

 

Читая венгерскую нотацию, профессиональные программисты автоматически отбрасывают префикс, так в имени объекта   flt Result, и видят и читают только основную часть имени – Result.

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

 

Понятие функции

 

Синтаксической программной единицей является объект, тип которого относится к группе производных типов и называется function - «функция».

Объект типа функция (часто мы будем говорить просто функция) – это специальный вид подпрограмм.

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

 

Вот как синтаксически выглядит определение функции:

тип_возвращаемого_значения    имя_объекта_функции ( список_формальных_параметров )

{

       /*    Это тело функции. Здесь пишутся инструкции, которые определяют объекты,

                   создаваемые внутри функции.

                   Здесь пишутся инструкции, задающие действия над этими объектами, которые

                   задают алгоритм работы функции

       */

}

 

Итак, определение функции состоит из заголовка функции:

 

тип_возвращаемого_значения    имя_объекта_функции ( список_формальных_параметров )

 

и тела функции, заключенного в фигурные скобки:

 

{

       /*    Это тело функции. Здесь пишутся инструкции, которые определяют объекты,

                   создаваемые внутри функции.

                   Здесь пишутся инструкции, задающие действия над этими объектами, которые

                   задают алгоритм работы функции

       */

}

 

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

 Как выглядит инструкция описания функции? Синтаксически – это точная копия заголовка функции, после которого стоит точка с запятой (ведь это инструкция!):

тип_возвращаемого_значения    имя_объекта_функции ( список_формальных_параметров );

 

Для инструкции описания функции есть специальное название – прототип (prototype).

 

 

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

/*   это много

       строковый

       комментарий */

Комментарий, который занимает одну строку, можно создать так:

// это комментарий в одну строку

 

В комментарии можно использовать любые символы.

 

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

// тип_возвращаемого_значения   имя_объекта_функции ( список_формальных_параметров )

void                                                 main                    (              void                             )

{

       //    инструкции тела функции   main

}

Слово void является зарезервированным словом и именем никакого типа. В заголовке этой функции void используется, чтобы указать, что функция не имеет возвращаемого значения и список ее формальных параметров пустой.

 

 

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

  Обратите внимание на цвет текста. Зарезервированные слова в редакторе пишутся синим цветом, комментарии зеленным, все остальные слова (слова, начертания которых определяет программист) и символы–операторы черные.

 

 

/* файл MyFirst.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<<"\n\tBYE!";         // ПОКА 25

getch();                    // 26

}                                // 27

 

Рассмотрим приведенный текст. Программа содержит функцию main. Она состоит из заголовка (строка 13) и тела (строки 14 – 27). 

Тело функции состоит из инструкций. Каждая инструкция заканчивается точкой с запятой. Инструкций в теле функции всего 11, из них 3 – это инструкции определения объектов nA, fltB, fltS umma. Эти инструкции создают объекты. Напоминаем, что любой объект, имя которого встречается в программе, должен быть определен и определен всего один раз. Инструкции определения объектов легко распознать, т.к. они всегда начинаются с имен типов - здесь int и float (строки 15, 16, 22).

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

 Вот они: "Input numbers: \t ",

 " \n first int \t ",

 "second float \t ",

 "summa = ",

 " \ n \ t BYE!".

Обратите внимание, что почти в каждой из этих строк присутствуют escape-символы (здесь, для того чтобы их разглядеть, они выделены жирным курсивом).

Кроме объектов a, b, summaи константных строк в тексте появились имена cout и  cin. Это имена объектов, но где их определения?

Объекты cout и cin – стандартные абстрактные объекты, тип их называется «поток», с их помощью организуется ввод и вывод. Описание этих объектов присоединяется в строке 9. В этой строке записана директива специальной программы – препроцессор. Директива #include вставляет перед текстом функции текст файла iostream. Обратите внимание, что эта директива не является элементом языка С++, это элемент другого языка, языка программы, которая называется  препроцессор. Директива, не являясь инструкцией языка С++, не имеет заканчивающей её точки с запятой.  В тексте включенного файла iostream находятся описания объектов cout и  cin, эти описания и присоединяются к тексту программы. А определения этих объектов cout и  cin находятся в стандартной библиотеке. Написание имени файла в треугольных скобках < > указывает системе, где, в каких папках искать файл и соответствующую ему библиотеку. Это делается автоматически.

 

Обратите внимание на инструкцию в строке 19:

using namespace std;

Эта инструкция определяет область имен, где необходимо искать определения используемых в программе имен объектов. Дело в том, что сейчас существует очень много различных библиотек, в которых могут появиться одинаковые имена. Инструкция   using namespace определяет, что поиск нужно осуществлять в области имен стандартной библиотеки std.

 

Последнее имя, которое используется в этой программе – имя  getch. Это имя объекта типа функция. По какому внешнему признаку система и мы узнаем, что это имя функции, а не какого-то объекта любого другого типа? Этим признаком является то, что сразу после этого имени   появляется оператор вызова функции – круглые скобки ().  

Это стандартная функция, ее описание находится в файле conio.h, который подключается директивой препроцессора  #include в строке  10. Само определение этого объекта функции (последовательность команд, определяющих алгоритм выполнения функции) будет найдено автоматически в стандартной библиотеке.

 

 

В функции main 7 инструкций-выражений.

Что делают инструкции-выражения?  

То, что делают операторы, которые в них используются!!!

Обратите внимание, как внешне по разному эти инструкции выглядят. Их разнообразие бесконечно.

 

 

Инструкции-выражения

cout << "Input numbers:\t" << "\nfirst int\t";

cout << "second float\t";       

cout << "summa = " << fltSumma;

cout << "\n\tBYE!"; 

используя оператор << совместно с потоковым объектом cout выводят на экран строковые константы и значение объекта summa.

 

Инструкции-выражения

cin>>nA;                                                                       

cin>>fltB;

используя оператор >> совместно с потоковым объектом cin копируют (вводят) в область объектов а и b значения, которые вводятся с клавиатуры.

 

 

Инструкция-выражение

fSumma = nA + fB;

с помощью оператора + вычисляет сумму значений объектов a иb и результат этого суммирования с помощью оператора = (присвоить) копирует в объект   summa.

 

Инструкция-выражение

getch();

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

Вопрос: а вот что делает вызванная стандартная функция?

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