1) if (/*логическое выражение*/) /*выполняется если лог. выражение = TRUE*/ ;
2) if (/*логическое выражение*/) /*выполняется если лог. выражение = TRUE*/;
3) if (/*логическое выражение*/) { //выполняется если логическое. выражение = TRUE }
4) if (/*логическое выражение*/) { //выполняется если логическое выражение = TRUE }
else { //выполняется если логическое выражение = FALSE }
5) if (/*логическое выражение1*/) { //выполняется если логическое выражение1 = TRUE }
else if (/*логическое выражение2*/) { //выполняется если логическое выражение 2 = TRUE }
&& - логическое «И»;

|| - логическое «ИЛИ»;

! – отрицание;

== - логическое «РАВНО»;

!= - логическое «НЕ РАВНО»
if (A == 0)
{
      if (C > 10)
               {
                  if (N < 15) {
                            сout << N;
                              }
               }
}

int number;
cin >> number;
switch (number)
{ case 0:
A = B;
break; c
ase 1:
B = A;
break;
case 2:
 A += B;
break;
case 3:
B *= A;
break;
default: B /= A; };
________________________________________________________________

n++;
cout << n <<"\n";
}



int n = 0;
do
{
n++;
cout << n << "\n";
}
while (n < 11)




for (int n = 1; n <= 10; n++)
{
cout << n << "\n";
}



for (int n = 1; n <= 10; n++)
{ c
out << n << "\n";
if (n == 5)
break;
}






for (int n = 1; n <= 10; n++)
{
if (n == 5)
continue;
cout << n << "\n";
}

______________________________________________________________________

ОДНОМЕРНЫЙ
#define SIZE 4
int num[10];
float res[5][5];
double mass[SIZE];

ДИНАМИЧЕСКИЙ
int size;
cin >> size;
int *mass = new int[size];
//действия с массивом
delete[] mass;


int Xsize,Ysize;
cin >> Xsize >> Ysize;
int **mass = new int*[Xsize];
for (int i = 0; i < Xsize; i++)
{
mass[i] = new int[Ysize];
} //действия с массивом
delete[] mass;


#include "stdafx.h"
#include <iostream>
#include <ctime> //для функции
time using namespace std;
int main()
{ int mass[10]; srand(time(0)); // автоматическая рандомизация по текущей дате в секундах
for (int i = 0; i < 10; i++)
{
mass[i] = -5 + rand() % 11;
// приведение случайных чисел к диапазону -5...5
}
return 0; }

____________________________________________________________________

//прототип функции вычисления факториала
int faktorial(int N);
int main()
{
int M,N,K; cin >> M >> N >> K;
int FM = faktorial(M);
int FN = faktorial(N);
int FK = faktorial(K);
cout << FM << endl << FN << endl << FK;
}
//реализация функции вычисления факториала
int faktorial(int N)
{
int res = 1;
for (int i = 1; i <= N; i++)
{ res *= i; // вычисляем значение факториала
} return res; // возвращаем значение факториала
}






//прототип функции нормирования вектора
void Normalize(float *X,float*Y,float *Z);
int main()
{
float X,Y,Z; //координаты вектора
cin >> X >> Y >> Z;
Normalize(&X, &Y, &Z); //вызов функции с передачей X,Y,Z "по ссылке"
cout << X << endl << Y << endl << Z<<endl;
system("pause");
 }
//реализация функции нормирования вектора
void Normalize(float *X, float*Y, float *Z)
{
float L = sqrt((*X)*(*X) + (*Y)*(*Y) + (*Z)*(*Z));
*X /= L;
*Y /= L;
*Z /= L;
}


_______________________________________________________________________________________

//Записать случайно выбранные числа в бинарный файл
// и считать их записав в другой массив
#include <time.h>
#include <iostream>
#define
FNAME "D:\\Test.dat" u
sing namespace std;
void main()
{
FILE *in;
// Инициализация переменных
int a[10],b[10]; // Массивы a типа int,
// размер - 10 элементов
int i;
 fopen_s(&in, FNAME, "wb");
// Сброс генератора случайных чисел
srand(time(NULL));
// Заполнить массив случайными числами
for (i = 0; i < 10; i++)
a[i] = rand();
// Вывести массив а на экран
fwrite(a, sizeof(int), 10, in); //записать бинарно все 10 элементов
for (i = 0; i < 10; i++)
{
printf("a[%i]=%i\n", i, a[i]);
}
fclose(in);
// открыть на чтение бинарно
fopen_s(&in, FNAME, "rb");
fread(&b[i], sizeof(int), 10, in); // читаем массив b целиком
for (i = 0; i < 10; i++)
 {
printf("b[%i]=%i\n", i, b[i]);
 }
fclose(in);
system("pause");
}





//Имеется файл данных, содержащий целые числа,
//разделенные пробелами. Количество чисел в файле неизвестно.
//Требуется найти среднее арифметическое значение этих чисел

#include <iostream>
void main()
{
int S = 0, count = 0, numb;
double aver;
FILE *in;
if ((in = fopen("D:\\1.txt", "r")) != NULL)
{
while (!feof(in))
{
fscanf_s(in, "%i", &numb);
S += numb;
count++;
printf("%i\n", numb);
}
aver = (double)S / count;
printf("Average=%lf\n", aver);
fclose(in);
}
else
printf("\nФайл не найден!");
system("pause");
}





//Записать нуль на место максимального значения в бинарном файле
#include <iostream>
void main()
{ FILE *in;
int i, imax; // номер максимального элемента
int a[10], max, zero = 0;
in = fopen("D:\\Test.dat", "rb"); i
f (!in)
{ p
uts("Error!");
return;
}
fread(&max, sizeof(int), 1, in);
imax = 1;
for (i = 1; i < 10; i++)
{
fread(&a[i], sizeof(int), 1, in);
printf("a[%i]=%i\n", i, a[i]);
if (a[i] > max)
{
max = a[i];
imax = i;
}
}
printf("\nmax=%i, imax= %4i", max, imax);
fseek(in, (imax)*sizeof(int), SEEK_SET);
fwrite(&zero, sizeof(int), 1, in);
int b[10];// проверочный массив
rewind(in); //перематываем файл в начало
fread(b, sizeof(int), 10, in); //читаем массив
for (i = 0; i < 10; i++)
{
printf("b[%i]=%i\n", i, b[i]);
 }
fclose(in);
system("pause");
}

_______________________________________________________________________

// объявление классов в С++
class /*имя класса*/
{
private:
                /* список свойств и методов для использования внутри класса */
public:
         /* список методов доступных другим функциям и объектам программы */
protected:
            /*список средств, доступных при наследовании*/
};



#include "stdafx.h"
#include <iostream>
using namespace std;
// начало объявления класса
class CppStudio // имя класса
{
public: // спецификатор доступа
void message() // функция (метод класса) выводящая сообщение на экран
{
cout << "This is message from C++ class!\n";
} }
; // конец объявления класса CppStudio
int main()
{
CppStudio *objMessage = new CppStudio;
objMessage.message(); // вызов функции класса message
system("pause");
delete objMessage;// сложный класс
return 0;
}






#include "stdafx.h"
#include <iostream>
using namespace std;
class CppStudio // имя класса
{ private: // спецификатор доступа private
int day, // день
month, // месяц
year; // год
public: // спецификатор доступа public
void message() // функция (метод класса) выводящая сообщение на экран
{
cout << "This is message from C++ class!\n";
}
void setDate(int date_day, int date_month, int date_year) // установка даты в формате дд.мм.гг
{
day = date_day; // инициализация день
month = date_month; // инициализация месяц
year = date_year; // инициализация год
}
void getDate() // отобразить текущую дату
{
cout << "Date: " << day << "." << month << "." << year << endl;
}
}; // конец объявления класса CppStudio
int main()
{
setlocale(LC_ALL, "RUS"); // установка локализации
int day, month, year;
cout << "Введите текущий день месяц и год!\n";
cout << "день: "; cin >> day;
cout << "месяц: "; cin >> month;
cout << "год: "; cin >> year;
CppStudio objCppstudio; // объявление объекта
objCppstudio.message(); // вызов функции класса message
objCppstudio.setDate(day, month, year); // инициализация даты
objCppstudio.getDate(); // отобразить дату
system("pause");
return 0;
}

__________________________________________________________________________

#include "stdafx.h"
#include <iostream>
#include "math.h"

using namespace std;



int main()
{
	setlocale(LC_ALL, "Russian");
	float x, eps;
	cout << "Введите x" << endl;
	cin >> x;
	cout << "Введите погрешность" << endl;
	cin >> eps;

	float f = ((1 - cos(x) - x * sin(x)) / pow(x, 2)) + 0.5;
	float n = (3 * pow(x, 2)) / 24;
    int m = 1;
	int i = 2;
	int fac;
	int ind = 1;
	float sum = 0;
	while (abs(n) >= eps)

	{
		int z = 2 * i;
		for (int j = 1; j <= (z + 2); j++)
		{
			fac = m * j;
			m = fac;
		}
		sum += n;
		n = ((z + 1) * pow(x, z)) / fac;
		ind = ind + 1;
		if (ind % 2 == 0)
		{
			n = abs(n)*(-1);
		}
		i++;
		ind++;
		m = 1;

	}

	cout << "Выражение: " << f << endl;
	cout << "Искомая сумма "<< sum <<endl;







	system("pause");
	return 0;
}

___________________________________________________________________

#define _USE_MATH_DEINES
#include "stdafx.h"
#include<iostream>
#include<math.h>
#include <ctime>

using namespace std;


int main()
{
	setlocale(LC_ALL, "Rus");

	int xSize, ySize;

	cout << "Введите  x" << endl;
	cin >> xSize;
	cout << "Введите  y" << endl;
	cin >> ySize;

	int **massdv = new int*[xSize] ;

	int s = 0;
	srand(time(0));

	for (int i = 0; i < xSize; i++)
	{
		massdv[i] = new int[ySize];
	}

	for (int i = 0; i < xSize; i++)
	{
		for (int j = 0; j < ySize;j++) {

			massdv[i][j] = -50 + rand() % 101;

		}

	}

	for (int i = 0; i < xSize; i++)
	{
		for (int j = 0; j < ySize;j++) {

			cout << massdv[i][j] << " ";

		}
		cout << endl;

	}


	for (int i = 0; i < xSize; i++)
	{
		for (int j = 0; j < ySize; j++) {
			if ((j > i) && (massdv[i][j] < 0)) {
				massdv[i][j] = abs(massdv[i][j]);

			}
		}
	}

	cout << endl;

	for (int i = 0; i < xSize; i++)
	{
		for (int j = 0; j < ySize;j++) {

			cout << massdv[i][j] << " ";

		}
		cout << endl;

	}




	for (int i = 0; i < xSize; i++)
	{
		for (int j = 0; j < ySize; j++)
		{
			if (i == j) {
				s = s + massdv[i][j];
			}
		}
	}

	printf("\n");

	cout << "Сумма элементов гл диагонали = " << s << endl;






	delete[] massdv;
	system("pause");
	return 0;
}

_______________________________________________________________________

// KursachDlg.cpp: файл реализации
//

#include "stdafx.h"
#include "Kursach.h"
#include "KursachDlg.h"
#include "afxdialogex.h"

#ifdef _DEBUG
#define new DEBUG_NEW
#endif
#import <C:\Users\ashel\Desktop\Kursach2\Kursach\InventorApp\RxInventor.tlb> \
rename_namespace("InventorNative") \
named_guids raw_dispinterfaces \
high_method_prefix("Method") \
rename("DeleteFile", "APIDeleteFile") \
rename("CopyFile", "APICopyFile") \
rename("MoveFile", "APIMoveFile") \
rename("SetEnvironmentVariable", "APISetEnvironmentVariable") \
rename("GetObject", "APIGetObject") \
exclude("_FILETIME", "IStream", "ISequentialStream", \
"_LARGE_INTEGER", "_ULARGE_INTEGER", "tagSTATSTG", \
"IEnumUnknown", "IPersistFile", "IPersist", "IPictureDisp")

using namespace InventorNative;

CComPtr<Application> pInvApp; //приложение
InventorNative::PartDocumentPtr pPartDoc; //документ
InventorNative::PartComponentDefinition *pPartComDef;//компоненты детали
InventorNative::TransientGeometry *pTransGeom; //геометрия детали
InventorNative::Transaction *pTrans; //операции
TransactionManagerPtr pTransManager; //менеджер операций
Document *Doc;
PlanarSketches *sketches; // эскизы
Sketches3D *sketches3D;
PartFeatures *ft; //элементы детали
WorkPlanes *wp; //рабочие плоскости
WorkAxes *wax;//рабочие оси
WorkPoints *wpt;//рабочие точки



// Диалоговое окно CAboutDlg используется для описания сведений о приложении

class CAboutDlg : public CDialogEx
{
public:
	CAboutDlg();

// Данные диалогового окна
#ifdef AFX_DESIGN_TIME
	enum { IDD = IDD_ABOUTBOX };
#endif

	protected:
	virtual void DoDataExchange(CDataExchange* pDX);    // поддержка DDX/DDV

// Реализация
protected:
	DECLARE_MESSAGE_MAP()
};

CAboutDlg::CAboutDlg() : CDialogEx(IDD_ABOUTBOX)
{
}

void CAboutDlg::DoDataExchange(CDataExchange* pDX)
{
	CDialogEx::DoDataExchange(pDX);
}

BEGIN_MESSAGE_MAP(CAboutDlg, CDialogEx)
END_MESSAGE_MAP()


// Диалоговое окно CKursachDlg



CKursachDlg::CKursachDlg(CWnd* pParent /*=NULL*/)
	: CDialog(IDD_KURSACH_DIALOG, pParent)
	, m_dRMalVirez(0.35)
	, m_dRMarOkr(0.5)
	, m_dRMedVirez(1.08)
	, m_dRMedOkr(1.18)
	, m_dRBigVirez(2.14)
	, m_dRBigOkr(2.33)
	, m_dGlubMalVirez(0)
	, m_dGlubMedVirez(0.72)
	, m_dHightBigOkr(1.15)
	, m_dGlubVneshVirez(0.25)
	, m_dHightMedOkr(0.95)
	, m_dHightSmallOkr(0.52)
	, m_nZb(30)
	, m_Shir1(0.1309)
	, m_Shir2(0.1425)
{
	m_hIcon = AfxGetApp()->LoadIcon(IDR_MAINFRAME);
}

void CKursachDlg::DoDataExchange(CDataExchange* pDX)
{
	CDialog::DoDataExchange(pDX);
	DDX_Text(pDX, IDC_EDIT1, m_dRMalVirez);
	DDX_Text(pDX, IDC_EDIT2, m_dRMarOkr);
	DDX_Text(pDX, IDC_EDIT3, m_dRMedVirez);
	DDX_Text(pDX, IDC_EDIT4, m_dRMedOkr);
	DDX_Text(pDX, IDC_EDIT5, m_dRBigVirez);
	DDX_Text(pDX, IDC_EDIT6, m_dRBigOkr);
	DDX_Text(pDX, IDC_EDIT7, m_dGlubMalVirez);
	DDX_Text(pDX, IDC_EDIT8, m_dGlubMedVirez);
	DDX_Text(pDX, IDC_EDIT9, m_dHightBigOkr);
	DDX_Text(pDX, IDC_EDIT10, m_dGlubVneshVirez);
	DDX_Text(pDX, IDC_EDIT11, m_dHightMedOkr);
	DDX_Text(pDX, IDC_EDIT12, m_dHightSmallOkr);
	DDX_Text(pDX, IDC_EDIT13, m_nZb);
	DDX_Text(pDX, IDC_EDIT15, m_Shir1);
	DDX_Text(pDX, IDC_EDIT16, m_Shir2);
}

BEGIN_MESSAGE_MAP(CKursachDlg, CDialog)
	ON_WM_SYSCOMMAND()
	ON_WM_PAINT()
	ON_WM_QUERYDRAGICON()
	ON_BN_CLICKED(IDC_BUTTON1, &CKursachDlg::OnBnClickedButton1)
END_MESSAGE_MAP()


// Обработчики сообщений CKursachDlg

BOOL CKursachDlg::OnInitDialog()
{
	CDialog::OnInitDialog();

	// Добавление пункта "О программе..." в системное меню.

	// IDM_ABOUTBOX должен быть в пределах системной команды.
	ASSERT((IDM_ABOUTBOX & 0xFFF0) == IDM_ABOUTBOX);
	ASSERT(IDM_ABOUTBOX < 0xF000);

	CMenu* pSysMenu = GetSystemMenu(FALSE);
	if (pSysMenu != NULL)
	{
		BOOL bNameValid;
		CString strAboutMenu;
		bNameValid = strAboutMenu.LoadString(IDS_ABOUTBOX);
		ASSERT(bNameValid);
		if (!strAboutMenu.IsEmpty())
		{
			pSysMenu->AppendMenu(MF_SEPARATOR);
			pSysMenu->AppendMenu(MF_STRING, IDM_ABOUTBOX, strAboutMenu);
		}
	}

	// Задает значок для этого диалогового окна.  Среда делает это автоматически,
	//  если главное окно приложения не является диалоговым
	SetIcon(m_hIcon, TRUE);			// Крупный значок
	SetIcon(m_hIcon, FALSE);		// Мелкий значок

	// TODO: добавьте дополнительную инициализацию

	return TRUE;  // возврат значения TRUE, если фокус не передан элементу управления
}

void CKursachDlg::OnSysCommand(UINT nID, LPARAM lParam)
{
	if ((nID & 0xFFF0) == IDM_ABOUTBOX)
	{
		CAboutDlg dlgAbout;
		dlgAbout.DoModal();
	}
	else
	{
		CDialog::OnSysCommand(nID, lParam);
	}
}

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

void CKursachDlg::OnPaint()
{
	if (IsIconic())
	{
		CPaintDC dc(this); // контекст устройства для рисования

		SendMessage(WM_ICONERASEBKGND, reinterpret_cast<WPARAM>(dc.GetSafeHdc()), 0);

		// Выравнивание значка по центру клиентского прямоугольника
		int cxIcon = GetSystemMetrics(SM_CXICON);
		int cyIcon = GetSystemMetrics(SM_CYICON);
		CRect rect;
		GetClientRect(&rect);
		int x = (rect.Width() - cxIcon + 1) / 2;
		int y = (rect.Height() - cyIcon + 1) / 2;

		// Нарисуйте значок
		dc.DrawIcon(x, y, m_hIcon);
	}
	else
	{
		CDialog::OnPaint();
	}
}

// Система вызывает эту функцию для получения отображения курсора при перемещении
//  свернутого окна.
HCURSOR CKursachDlg::OnQueryDragIcon()
{
	return static_cast<HCURSOR>(m_hIcon);

}






void CKursachDlg::OnBnClickedButton1()
{
	//Поиск приложения по ID
	CLSID InvAppClsid;
	HRESULT hRes = CLSIDFromProgID(L"Inventor.Application", &InvAppClsid);
	if (FAILED(hRes)) {
		pInvApp = nullptr;
		return;
	}

	//Проверка запущено ли приложение
	CComPtr<IUnknown> pInvAppUnk = nullptr;
	hRes = ::GetActiveObject(InvAppClsid, NULL, &pInvAppUnk);
	if (FAILED(hRes)) {
		// Если не запущено - запускаем
		TRACE(L"Could not get hold of an active Inventor, will start a new session\n");
		hRes = CoCreateInstance(InvAppClsid, NULL, CLSCTX_LOCAL_SERVER, __uuidof(IUnknown), (void **)&pInvAppUnk);
		if (FAILED(hRes)) {
			pInvApp = nullptr;
			return;
		}
	}

	// Получаем указатель на запущенное приложение (hRes)
	// если происходит повторный запуск то указатель уже существует и с ним не надо ничего   делать
	if (!pInvApp)
		hRes = pInvAppUnk->QueryInterface(__uuidof(Application), (void **)&pInvApp);

	if (FAILED(hRes)) {
		return;
	}

	pInvApp->put_Visible(TRUE);

	pPartDoc = pInvApp->Documents->MethodAdd(kPartDocumentObject,
		pInvApp->FileManager->MethodGetTemplateFile(kPartDocumentObject, kMetricSystemOfMeasure, kGOST_DraftingStandard), true);

	pPartDoc->DisplayName = _T("Шестерня");

	pPartDoc->get_ComponentDefinition(&pPartComDef);

	pInvApp->get_TransientGeometry(&pTransGeom);


	pTransManager = pInvApp->GetTransactionManager();

	Doc = CComQIPtr <Document>(pPartDoc);

	pTransManager->raw_StartTransaction(Doc, _T(""), &pTrans);

	pPartComDef->get_Sketches(&sketches);
	pPartComDef->get_Sketches3D(&sketches3D);


	pPartComDef->get_WorkPlanes(&wp);
	pPartComDef->get_Features(&ft);
	pPartComDef->get_WorkAxes(&wax);
	pPartComDef->get_WorkPoints(&wpt);

	if (m_dRMarOkr - m_dRMalVirez < 0.15)
	{
		AfxMessageBox(_T("Ошибка! Радиус малой окружности должен быть не меньше радиуса малого выреза"));
		return;
	}
	if (m_dGlubVneshVirez <= 0 || m_dRMalVirez <= 0 || m_dRMarOkr <= 0 || m_dHightSmallOkr <= 0 || m_dRMedOkr <= 0 || m_dRBigVirez <= 0 || m_dRBigOkr <= 0
		|| m_dHightBigOkr <= 0 || m_dRMedVirez <= 0 || m_dGlubMedVirez <= 0)
	{
		AfxMessageBox(_T("Ошибка! Все параметры кроме начального не могут быть равны 0 или быть меньше 0."));
		return;

	}
	if (m_dRMarOkr >= m_dRBigOkr || m_dRMarOkr >= m_dRMedOkr || m_dRMedOkr >= m_dRBigOkr)
	{
		AfxMessageBox(_T("Ошибка! Параметры малой окр не должны быть больше средней и большой."));
		return;
	}
	if (m_nZb >= 80 || m_nZb <= 0)
	{
		AfxMessageBox(_T("Ошибка! Количество зубев должно быть больше 0 и меньше 80"));
		return;
	}
	if (m_Shir1 <= 0 || m_Shir2 <= 0)
	{
		AfxMessageBox(_T("Ошибка! Ширена вырезов для зубьев не должна быть меньше 1"));
		return;
	}
	if (m_Shir1 >= m_Shir2)
	{
		AfxMessageBox(_T("Ошибка! Внешняя ширина должна быть больше внутренней "));
		return;
	}

	PlanarSketch *pSketch;
	sketches->raw_Add(wp->GetItem(3), false, &pSketch);
	SketchPointPtr point[12];
	SketchLinePtr lines[12];


	SketchPoints *skPoints;
	SketchLines *skLines;
	Profiles *skProfiles;


	pSketch->get_SketchPoints(&skPoints);
	pSketch->get_SketchLines(&skLines);
	pSketch->get_Profiles(&skProfiles);

	UpdateData();

    point[0] = skPoints->MethodAdd(pTransGeom->MethodCreatePoint2d(m_dGlubMalVirez, m_dRMalVirez), false);
	point[1] = skPoints->MethodAdd(pTransGeom->MethodCreatePoint2d(m_dGlubMalVirez, m_dRMarOkr), false);
	point[2] = skPoints->MethodAdd(pTransGeom->MethodCreatePoint2d(m_dHightSmallOkr, m_dRMarOkr), false);
	point[3] = skPoints->MethodAdd(pTransGeom->MethodCreatePoint2d(m_dHightSmallOkr, m_dRMedOkr), false);
	point[4] = skPoints->MethodAdd(pTransGeom->MethodCreatePoint2d(m_dHightMedOkr, m_dRMedOkr), false);
	point[5] = skPoints->MethodAdd(pTransGeom->MethodCreatePoint2d(m_dHightMedOkr, m_dRBigVirez), false);
	point[6] = skPoints->MethodAdd(pTransGeom->MethodCreatePoint2d(m_dGlubVneshVirez, m_dRBigVirez), false);
	point[7] = skPoints->MethodAdd(pTransGeom->MethodCreatePoint2d(m_dGlubVneshVirez, m_dRBigOkr), false);
	point[8] = skPoints->MethodAdd(pTransGeom->MethodCreatePoint2d(m_dHightBigOkr, m_dRBigOkr), false);
	point[9] = skPoints->MethodAdd(pTransGeom->MethodCreatePoint2d(m_dHightBigOkr, m_dRMedVirez), false);
	point[10] = skPoints->MethodAdd(pTransGeom->MethodCreatePoint2d(m_dGlubMedVirez, m_dRMedVirez), false);
	point[11] = skPoints->MethodAdd(pTransGeom->MethodCreatePoint2d(m_dGlubMedVirez, m_dRMalVirez), false);

	lines[0] = skLines->MethodAddByTwoPoints(point[0], point[1]);
	lines[1] = skLines->MethodAddByTwoPoints(point[1], point[2]);
	lines[2] = skLines->MethodAddByTwoPoints(point[2], point[3]);
	lines[3] = skLines->MethodAddByTwoPoints(point[3], point[4]);
	lines[4] = skLines->MethodAddByTwoPoints(point[4], point[5]);
	lines[5] = skLines->MethodAddByTwoPoints(point[5], point[6]);
	lines[6] = skLines->MethodAddByTwoPoints(point[6], point[7]);
	lines[7] = skLines->MethodAddByTwoPoints(point[7], point[8]);
	lines[8] = skLines->MethodAddByTwoPoints(point[8], point[9]);
	lines[9] = skLines->MethodAddByTwoPoints(point[9], point[10]);
	lines[10] = skLines->MethodAddByTwoPoints(point[10], point[11]);
	lines[11] = skLines->MethodAddByTwoPoints(point[11], point[0]);

	//создаем профиль для 3D построений.
	Profile *pProfile;
	skProfiles->raw__AddForSolid(&pProfile);

	RevolveFeatures *ftRevolve;
	ft->get_RevolveFeatures(&ftRevolve); //указатель на коллекцию вращений в документе
										 //добавляем новое вращение
	RevolveFeaturePtr revolve1 = ftRevolve->MethodAddFull(pProfile, wax->GetItem(1),
		kJoinOperation);

	//создаем смещенную плоскость для эскиза зубца
	wp->MethodAddByPlaneAndOffset(wp->GetItem(1), m_dHightSmallOkr / 2.f, true);

	//эскиз для построения зуба
	PlanarSketch *pSketch3;
	sketches->raw_Add(wp->GetItem(1), false, &pSketch3);
	SketchPointPtr point3[4];
	SketchLinePtr lines3[4];
	SketchPoints *skPoints3;
	SketchLines *skLines3;
	pSketch3->get_SketchPoints(&skPoints3);
	pSketch3->get_SketchLines(&skLines3);
	point3[0] = skPoints3->MethodAdd(pTransGeom->MethodCreatePoint2d(0 ,
		-m_dRBigOkr), false);
	point3[1] = skPoints3->MethodAdd(pTransGeom->MethodCreatePoint2d(m_Shir2,
		-m_dRBigOkr), false);
	point3[2] = skPoints3->MethodAdd(pTransGeom->MethodCreatePoint2d(m_Shir1
		, -m_dRBigVirez * 0.9 ), false);
	point3[3] = skPoints3->MethodAdd(pTransGeom->MethodCreatePoint2d(0 , -m_dRBigVirez), false);


	lines3[0] = skLines3->MethodAddByTwoPoints(point3[0], point3[1]);
	lines3[1] = skLines3->MethodAddByTwoPoints(point3[1], point3[2]);
	lines3[2] = skLines3->MethodAddByTwoPoints(point3[2], point3[3]);
	lines3[3] = skLines3->MethodAddByTwoPoints(point3[3], point3[0]);
	Profiles *skProfiles3;
	pSketch3->get_Profiles(&skProfiles3);
	Profile *pProfile3;
	skProfiles3->raw__AddForSolid(&pProfile);



	ExtrudeFeatures *ftExtrude;
	ft->get_ExtrudeFeatures(&ftExtrude);


	ExtrudeFeaturePtr  extrude1 = ftExtrude->MethodAddByDistanceExtent(pProfile, m_dHightMedOkr * 0.7 , kPositiveExtentDirection, kCutOperation);
	pTrans->MethodEnd();

	// множим зубья
	ObjectCollection *pCollection;
	pInvApp->TransientObjects->raw_CreateObjectCollection(vtMissing, &pCollection);
	pCollection->MethodAdd(extrude1);
	CircularPatternFeatures *pCircPatFeat;
	ft->get_CircularPatternFeatures(&pCircPatFeat);
	CircularPatternFeature *circFeat = pCircPatFeat->MethodAdd(pCollection, wax->GetItem(1),
		true, m_nZb, "360 град", true, kIdenticalCompute);
}

______________________________________________________________________________________________________________________________________

#include <iostream>
#include <cmath>

float lenght(float x, float y) {
    return sqrtf((x * x) + (y * y));
}

int main() {

    setlocale(LC_ALL, "RUS");

    FILE *file;

    fopen_s(file, "1.dat", "r"); // Открываем файл

    char buff[100]; // Буфер

    float points[2][100]; // Массив точек!

    int i = 0; // Счетчик

    float x, y;

    while(fgets(buff, 100, file)) {

        sscanf_s(buff, "%f %f", &x, &y);

        points[0][i] = x;
        points[1][i] = y;

        i++;
    }

    // Определяем область принадлежности:

    int n;

    float radius = 2.f;

    for (int j = 0; j < i; j++) {
        x = points[0][j];
        y = points[0][j];

        if (y >= 0) {
            if (y <= 1.f && (x >= -1.f || x <= 1.f)) {
                n = 3;
            } else {
                if (lenght(x, y) <= radius) {
                    n = 4;
                } else {
                    n = 1;
                }
            }
        } else {
            if (y >= -1.f && (x >= -1.f || x <= 1.f)) {
                n = 3;
            } else {
                if (lenght(x, y) <= radius) {
                    n = 4;
                } else {
                    n = 2;
                }
            }
        }

        std::cout << "Точка " << j + 1 << ": (" << x <<
        ";" << y << ") в зоне " << n << std::endl;
    }

    fclose(file);

    system("pause");

    return 0;
}