Современные технологии разработки лабараторная 2. Лабораторная работа 2. Лабораторная работа 2 студент гр. Зп81 Северов Александр Евгеньевич фио студента 3 июля 2022 г

• Название: Лабораторная работа 2 студент гр. Зп81 Северов Александр Евгеньевич фио студента 3 июля 2022 г
• Анкор: Современные технологии разработки лабараторная 2
• Дата: 10.07.2022
• Размер: 111.5 Kb.
• Имя файла: Лабораторная работа 2.doc
• Тип: Лабораторная работа; #627979

Федеральное государственное бюджетное образовательное учреждение высшего образования

«Сибирский государственный университет телекоммуникаций и информатики»

(СибГУТИ)
Факультет заочного обучения

09.03.01 "Информатика и вычислительная техника"

профиль "Программное обеспечение средств вычислительной техники и автоматизированных систем"

Современные технологии программирования


Лабораторная работа № 2




Выполнил:
студент гр.ЗП-81 ________/Северов Александр Евгеньевич/

ФИО студента

«3» июля 2022 г.


Проверил
_____________/____________/
«__» _____________ 2022г. Оценка__________________
Новосибирск 2022 г.

Цель

Сформировать практические навыки реализации абстрактных типов данных

в соответствии с заданной спецификацией с помощью классов С++. Синтаксис

классов: инкапсуляция, простые свойства

Задание

1. Реализовать абстрактный тип данных «комплексное число», используя класс

С++, в соответствии с приведенной ниже спецификацией.

2. Протестировать каждую операцию, определенную на типе данных, используя

средства модульного тестирования.

Текст программы

#include

#include "UComplex.h"

#include
using namespace std;

int main()

{

TComplex* MyCx1 = new TComplex(1,1);

cout << "MyCx1 = TComplex(1,1) = " << MyCx1->GetComplexStr() << endl;

TComplex* MyCx2 = new TComplex(8.3, 1.2);

cout << "MyCx2 = TComplex(8.3, 1.2) = " << MyCx2->GetComplexStr() << endl;

TComplex* MyCx3 = new TComplex(-3, 4);

cout << "MyCx3 = TComplex(-3, 4) = " << MyCx3->GetComplexStr() << endl;

TComplex* MyCx4 = new TComplex(*MyCx3);

cout << "MyCx4 = TComplex(MyCx3) = " << MyCx4->GetComplexStr() << endl;

TComplex* MyCx5 = new TComplex("-20.5+i*3.45");

cout << "MyCx5 = TComplex(\"-20.5+i*3.45\") = " << MyCx5->GetComplexStr() << endl << endl<< endl;

TComplex* MyCx6 = *MyCx1 + *MyCx2;

cout << "MyCx6 = *MyCx1 + *MyCx2 = " << MyCx6->GetComplexStr() << endl;

TComplex* MyCx7 = *MyCx6 - *MyCx2;

cout << "MyCx7 = *MyCx6 - *MyCx2 = " << MyCx7->GetComplexStr() << endl;

TComplex* MyCx8 = *MyCx1 * *MyCx3;

cout << "MyCx8 = *MyCx1 * *MyCx3 = " << MyCx8->GetComplexStr() << endl;

TComplex* MyCx9 = *MyCx1 / *MyCx2;

cout << "MyCx9 = *MyCx1 / *MyCx2 = " << MyCx9->GetComplexStr() << endl << endl<< endl;

cout << "Re(MyCx9) = " << MyCx9->GetReStr() << endl;

cout << "Im(MyCx9) = " << MyCx9->GetImStr() << endl << endl<< endl;

TComplex* MyCx10 = MyCx3->Square();

cout << "MyCx3->Square() = " << MyCx10->GetComplexStr() << endl;

TComplex* MyCx11 = MyCx2->Negative();

cout << "MyCx2->Negative() = " << MyCx11->GetComplexStr() << endl;

TComplex* MyCx12 = MyCx1->Invert();

cout << "MyCx1->Invert() = " << MyCx12->GetComplexStr() << endl<< endl<< endl;

bool bb= ((*MyCx2) == (*MyCx3));

cout << "((*MyCx2) == (*MyCx3)) = " << bb << endl;

bb = ((*MyCx2) != (*MyCx3));

cout << "((*MyCx2) != (*MyCx3)) = " << bb << endl<< endl<< endl;

double dd = MyCx1->Module();

cout << "MyCx1->Module() = " << dd << endl;

dd = MyCx3->Rad();

cout <<"MyCx3->Rad() = " << dd << endl;

dd = MyCx3->Deg();

cout << "MyCx3->Deg() = " << dd << endl;

TComplex* MyCx13 = MyCx2->Pow(4);

cout << "MyCx2->Pow(4) = " << MyCx13->GetComplexStr()<< endl;

TComplex* MyCx14 = MyCx2->Root(3, 2);

cout << "MyCx2->Root(3, 2) = " << MyCx14->GetComplexStr() << endl;

} #include

#include

#include

#include

using namespace std;
class TComplex

{

private:

double Re;

double Im;

public:

TComplex(double MyRe, double MyIm);// КонструкторЧисло

TComplex(string str); // КонструкторСтрока

TComplex(const TComplex& K); // Копировать

TComplex* operator + (const TComplex& K); // Сложить

TComplex* operator * (const TComplex& K); // Умножить

TComplex* operator - (const TComplex& K); // Вычесть

TComplex* operator / (const TComplex& K); // Делить

TComplex* Negative(); // Минус

TComplex* Square(); // Квадрат

TComplex* Invert(); // Обратное

double Module(); // Модуль

double Rad(); // УголРад

double Deg(); // УголГрад

TComplex* Pow(int n); // Степень

TComplex* Root(int n, int i); // i-ый корень степени n

bool operator == (const TComplex& K); // Равно

bool operator != (const TComplex& K); // НеРавно

string GetReStr() const;

string GetImStr() const;

double GetReNum() const;

double GetImNum() const;

string GetComplexStr();

};


TComplex::TComplex(double MyRe, double MyIm)

{

this->Re = MyRe;

this->Im = MyIm;

}

TComplex::TComplex(string str)

{

int pos = str.find("+");

this->Re = atof(str.substr(0,pos).c_str());

pos = str.find("*");

this->Im = atof(str.substr(pos+1,str.length()-pos).c_str());

};

TComplex::TComplex(const TComplex& K)

{

Re = K.Re;

Im = K.Im;

};

TComplex* TComplex::operator + (const TComplex& K)

{

double MyRe = Re + K.Re;

double MyIm = Im + K.Im;

TComplex* Res = new TComplex(MyRe, MyIm);

return Res;

};

TComplex* TComplex::operator - (const TComplex& K)

{

double MyRe = Re - K.Re;

double MyIm = Im - K.Im;

TComplex* Res = new TComplex(MyRe, MyIm);

return Res;

};

TComplex* TComplex::operator * (const TComplex& K)

{

double MyRe = Re * K.Re - Im * K.Im;

double MyIm = Re * K.Im + Im * K.Re;

TComplex* Res = new TComplex(MyRe, MyIm);

return Res;

};
TComplex* TComplex::operator / (const TComplex& K)

{

if ((K.Re != 0) && (K.Im != 0))

{

double MyRe = ((Re * K.Re + Im * K.Im) / (K.Re * K.Re + K.Im * K.Im));

double MyIm = ((Im * K.Re - Re * K.Im) / (K.Re * K.Re + K.Im * K.Im));

TComplex* Res = new TComplex(MyRe, MyIm);

return Res;

}

else

{

TComplex* Res = new TComplex(0, 0);

return Res;

}

};
TComplex* TComplex::Negative()

{

double MyRe = 0 - Re;

double MyIm = 0 - Im;

TComplex* Res = new TComplex(MyRe, MyIm);

return Res;

};

TComplex* TComplex::Square()

{

double MyRe = Re * Re - Im * Im;

double MyIm = Re * Im + Im * Re;

TComplex* Res = new TComplex(MyRe, MyIm);

return Res;

};
TComplex* TComplex::Invert()

{

if ((Re != 0) && (Im != 0))

{

double MyRe = Re / (Re * Re + Im * Im);

double MyIm = Im / (Re * Re + Im * Im);

TComplex* Res = new TComplex(MyRe, MyIm);

return Res;

}

else

{

TComplex* Res = new TComplex(0, 0);

return Res;

}

};
double TComplex::Module()

{

double Res = sqrt(Re * Re + Im * Im);

return Res;

};

double TComplex::Rad()

{

double Res;

if (Re > 0)

Res = atan(Im / Re);

else

if ((Re == 0) && (Im > 0))

Res = asin(1);

else

if (Re < 0)

Res = atan(Im / Re) + 2*asin(1);

else

if ((Re == 0) && (Im < 0))

Res = -asin(1);

else

Res = 0;

return Res;

};

double TComplex::Deg()

{

double Res;

if (Re > 0)

Res = (atan(Im / Re) * 360) / (2 * 2*asin(1));

else

if ((Re == 0) && (Im > 0))

Res = 90;

else

if (Re < 0)

Res = ((atan(Im / Re) + 2*asin(1)) * 360) / (2 * 2*asin(1));

else

if ((Re == 0) && (Im < 0))

Res = - 90;

else

Res = 0;

return Res;

};

TComplex* TComplex::Pow(int n)

{

double MyRe, MyIm, fi, magn;

fi = (*this).Rad();

magn = (*this).Module();

MyRe = pow(magn, n) * (cos(n * fi));

MyIm = pow(magn, n) * (sin(n * fi));

TComplex* Res = new TComplex(MyRe, MyIm);

return Res;

};

TComplex* TComplex::Root(int n, int i)

{

double MyRe, MyIm, fi, magn;

fi = (*this).Rad();

magn = (*this).Module();

MyRe = pow(magn, 1 / n) * (cos((fi + 2 * (i - 1) * 2*asin(1)) / n));

MyIm = pow(magn, 1 / n) * (sin((fi + 2 * (i - 1) * 2*asin(1)) / n));

TComplex* Res = new TComplex(MyRe, MyIm);

return Res;

};
bool TComplex::operator == (const TComplex& K)

{

if ((Re == K.Re) && (Im == K.Im))

return true;

else

return false;

};
bool TComplex::operator != (const TComplex& K)

{

if ((Re == K.Re) && (Im == K.Im))

return false;

else

return true;

};

string TComplex::GetReStr() const

{

string MyRe = to_string(Re);

return MyRe.substr(0,MyRe.find_last_not_of('0')+2);

};
string TComplex::GetImStr() const

{

string MyIm = to_string(Im);

return MyIm.substr(0,MyIm.find_last_not_of('0')+2);

};


double TComplex::GetReNum() const

{

return Re;

}

double TComplex::GetImNum() const

{

return Im;

}

string TComplex::GetComplexStr()

{

string str1 = to_string(Re);

string str2 = to_string(Im);

str2 = str2.substr(0,str2.find_last_not_of('0')+2);

if (Im<0)

str2 = "("+str2+")";

return str1.substr(0,str1.find_last_not_of('0')+2) + "+i*" + str2;

}

Тестовые наборы данных для тестирования типа данных.

Контрольные вопросы:

1. 
   
   Что такое инкапсуляция?
   

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

2. 
   
   Как синтаксически представлено поле в описании класса?
   

При объявлении имен полей принято к названию поля добавлять заглавную букву F FSomeField.

3. 
   
   Как синтаксически представлен метод в описании класса?
   

В описании класса как типа данных методы представлены своими заголовками.

4. 
   
   В чём состоит назначение конструктора?
   

Конструктор создаёт новый экземпляр объекта.