МИНИСТЕРСТВО ОБРАЗОВАНИЯ, КУЛЬТУРЫ И ИССЛЕДОВАНИЙ.

ТЕХНИЧЕСКИЙ УНИВЕРСИТЕТ МОЛДОВЫ.

ФАКУЛЬТЕТ ИНФОРМАТИКИ, ВЫЧИСЛИТЕЛЬНОЙ ТЕХНИКИ И

МИКРОЭЛЕКТРОНИКИ.

СПЕЦИАЛЬНОСТЬ: МИКРОЭЛЕКТРОНИКА И НАНОТЕХНЕЛОГИИ.

ОТЧЕТ
По лабораторной работе №3
Тема
«Перегрузка операторов.»

Выполнила: ст.гр.MN-202 Дерменжи Алёна

Проверил: пр. Митителу Виталий

Кишинев 2021.
 Лабораторная работа №3

Тема: Перегрузка операторов.

Цели работы:
 Изучение необходимости перегрузки операторов;
 изучение синтаксиса определения операторов;
 изучение типов операторов;
 изучение форм перегрузки.

Вариант: 7
Задание:

а) Создать класс Bool – логические переменные. Определить операторы "+" –

логическое ИЛИ, "*" – логическое И "^" – ИСКЛЮЧИТЕЛЬНОЕ ИЛИ, как
методы класса, а операторы "==" и "!=" как дружественные функции.
Операторы должны позволять осуществления операций, как с переменными
данного класса, так и с переменными встроенного int. (Если целое число
отлично от нуля, считается что переменная истинна, в противном случае
ложна).

b) Создать класс String – строку, используя динамическую память.

Определить операторы "+" –сложение строк, "=" и "+=" – присваивания, как
методы класса. Определить операторы сравнения "==", "!=", "<", ">", как
дружественные функции. Операторы должны работать как со String, так и с
char*. Определить оператор "[]" для доступа к каждому символу в
отдельности. Перегрузить операторы ввода/вывода в поток.

Задание А
#include <iostream>

using namespace std;

class Bool
{
 int n;

public:
Bool() : n(0) {}

Bool(int z) : n(z) {}

Bool operator+(Bool &obj)

{
Bool res (*this);
return (res.n + obj.n) ? true : false;
}

Bool operator+(int obj)

{
Bool result (*this);
result.n += obj;
return (result);
}

Bool operator*(Bool &obj)

{
Bool res (*this);
return (res.n * obj.n) ? true : false;
}

Bool operator*(int obj)

{
Bool result (*this);
result.n *= obj;
return (result);
}

friend bool operator==(Bool &a, Bool &b)

{
return (a.n == b.n) ? true : false;
}

friend bool operator==(int a, Bool &b)

 {
return (a == b.n) ? true : false;
}

friend bool operator==(Bool &a, int b)

{
return (a.n == b) ? true : false;
}

friend bool operator!=(Bool &a, Bool &b)

{
return !(a.n == b.n) ? true : false;
}

friend bool operator!=(int a, const Bool &b)

{
return !(a == b.n) ? true : false;
}

friend bool operator!=(Bool &a, int b)

{
return !(a.n == b) ? true : false;
}

friend ostream& operator<<(ostream &out,const Bool &obj)

{
out << obj.n << endl;
return out;
}
};

int main()
{
Bool x(1);
Bool y(0);

cout << "X = 1 \nY = 0" << endl;

 if (x == 1)
{
cout << "Boolean" <<endl;
cout << " x+x= " << x + x << " x+y= " << x + y << "
y+x= " << y + x << " y+y= " << y + y << endl;
cout << " x*x= " << x * x << " x*y= " << x * y << "
y*x= " << y * x << " y*y= " << y * y << endl;
}
if (x != y)
{
cout <<"\nInteger"<<endl;
cout << " x+5= " << x + 5 << " x+0= " << x + 0 << "
15+y= " << y + 15 << " y+25= " << y +25 << endl;
cout << " x*5= " << x * 5 << " x*0= " << x * 0 << "
5*y= " << y * 5 << " y*0= " << y * 25 << endl;
}
system ("pause");
return (0);
}

Результат А
Задание Б
include <iostream>
#include<string>
using namespace std;

class String
{
friend bool operator == (String string1, String
string2);
friend bool operator == (String string1, char* mem);
friend bool operator == (String string1, const char*
mem);
friend bool operator != (String string1, String
string2);
friend bool operator != (String string1, char* mem);
friend bool operator != (String string1, const char*
mem);
friend bool operator > (String string1, String string2);
friend bool operator > (String string1, char* mem);
friend bool operator > (String string1, const char*
mem);
friend bool operator < (String string1, String string2);
friend bool operator < (String string1, char* mem);
friend bool operator < (String string1, const char*
mem);
public:
int Lenght;
char* arr;

void SizeAndTrim(char *mem) {

while (mem[Lenght] != '\0')
++Lenght;
char* temp = new char[Lenght+1];
for (int i = 0; i < Lenght; i++)
{
temp[i] = mem[i];
 }
temp[Lenght] = '\0';
arr = temp;
}
void SizeAndTrim(const char *mem) {
while (mem[Lenght] != '\0')
++Lenght;
char* temp = new char[Lenght+1];
for (int i = 0; i < Lenght; i++)
{
temp[i] = mem[i];
}
temp[Lenght] = '\0';
arr = temp;
}
int SizeofChar( char* mem) {
int i = 0;
while (mem[i]!='\0')
++i;
return i;
}
int SizeofChar(const char* mem) {
int i = 0;
while (mem[i]!='\0')
++i;
return i;
}
String() {
Lenght=0;
}

String(char *mem) {
Lenght = 0;
SizeAndTrim(mem);
}

String(const char *mem) {

Lenght = 0;
SizeAndTrim(mem);
}

String( const String& string) {

Lenght = string.Lenght;
arr = new char[Lenght+1];
for (int i = 0; i < Lenght; i++)
{
arr[i] = string.arr[i];
}
arr[Lenght] = '\0';
}

~String() {
delete arr;
}

String& operator=(char* mem) {

Lenght = 0;
SizeAndTrim(mem);
return *this;
}

String& operator=(const char* mem) {

Lenght = 0;
SizeAndTrim(mem);
return *this;
}

String& operator=(String& string) {

Lenght = string.Lenght;
arr = new char[Lenght + 1];
for (int i = 0; i < Lenght; i++)
{
arr[i] = string.arr[i];
}
arr[Lenght] = '\0';
return *this;
return (string);
}
 String &operator+(char* mem) {
int size = SizeofChar(mem) + Lenght;
char* temp = new char[size+1];
for (int i = 0; i < Lenght; i++)
{
temp[i] = arr[i];
}
for (int i = Lenght, j = 0; i < (size); i++, j++)
{
temp[i] = mem[j];
}
temp[size] = '\0';
arr = temp;
Lenght = size;
return *this;
}

String& operator+(const char* mem) {

int size= SizeofChar(mem) + Lenght;
char* temp = new char[size+1];
for (int i = 0; i < Lenght; i++)
{
temp[i] = arr[i];
}
for (int i = Lenght,j=0; i < (size); i++,j++)
{
temp[i] = mem[j];
}
temp[size] = '\0';
arr = temp;
Lenght = size;
return *this;
}

String& operator+=(char* mem) { return (*this +

mem); }
String& operator+=(const char* mem) { return (*this +
mem); }
 String& operator+=(String string) { return (*this +
string.arr);}

char& operator [](const int index) { return

arr[index]; }

};

bool operator == (String string1, String string2) {

return string1.Lenght == string2.Lenght; }
bool operator == (String string1, char*mem) {
return string1.Lenght == (string1.SizeofChar(mem)); }
bool operator == (String string1, const char*mem) {
return string1.Lenght == (string1.SizeofChar(mem)); }
bool operator != (String string1, String string2) {
return string1.Lenght != string2.Lenght; }
bool operator != (String string1, char* mem) {
return string1.Lenght != (string1.SizeofChar(mem)); }
bool operator != (String string1, const char* mem){
return string1.Lenght != (string1.SizeofChar(mem)); }
bool operator > (String string1, String string2) {
return string1.Lenght > string2.Lenght; }
bool operator > (String string1, char*mem) {
return string1.Lenght > (string1.SizeofChar(mem)); }
bool operator > (String string1, const char*mem) {
return string1.Lenght > (string1.SizeofChar(mem)); }
bool operator < (String string1, String string2) {
return string1.Lenght < string2.Lenght; }
bool operator < (String string1, char* mem) {
return string1.Lenght < (string1.SizeofChar(mem)); }
bool operator < (String string1, const char* mem) {
return string1.Lenght < (string1.SizeofChar(mem)); }

ostream& operator <<(ostream& out, const String &string) {

return out << string.arr; }
istream& operator >>(istream& in, String& string) {
return in >> string.arr; }

char* operator +(String string, String string1) {

 char* temp = new char[string1.Lenght + string.Lenght +
1];
for (int i = 0; i < string.Lenght; i++)
{
temp[i] = string.arr[i];
}
for (int i = string.Lenght, j = 0; i < (string.Lenght +
string1.Lenght); i++, j++)
{
temp[i] = string1.arr[j];
}
temp[string.Lenght + string1.Lenght] = '\0';
return temp;
}

int main()
{
cout << endl<< "Create class String with const char in
ctor: ";
String a("Hello ");
cout << a;
cout << endl<< "Create class String with *char in ctor:
";
char* arraychar = new char[6]{
'w','o','r','l','d','\0' };
String b(arraychar);
cout << b;
cout << endl<< "Create class String with String in ctor:
";
String c(a);
cout << c <<endl;

cout << endl << "String + String: " << a + b;

cout << endl << "String = String: ";
c = a;
cout << c;
cout << endl << "String += String: ";
c += b;
 cout << c;
cout << endl << "String + *char: " << c+arraychar;
cout << endl << "String = *char: ";
c = arraychar;
cout << c;
cout << endl << "String += *char: ";
b+= arraychar;
cout << b<<endl;

cout << endl << "String == String: " << (a == b);

b = arraychar;
cout << endl << "String == *char: " << (b == arraychar);
a = "Hello";
cout << endl << "String == const char: " << (a ==
"Hello") <<endl;

cout << endl << "String != String: " << (a != b);

cout << endl << "String != *char: " << (b != arraychar);
cout << endl << "String != const char: " << (a !=
"Hello") <<endl;

cout << endl << "String < String: " << (a < b);
cout << endl << "String < *char: " << (c < arraychar);
cout << endl << "String < const char: " << (b < "Hello")
<<endl;

cout << endl << "String > String: " << (a > b);
cout << endl << "String > *char: " << (c > arraychar);
cout << endl << "String > const char: " << (b > "Hello")
<<endl;

cout << endl << "Object \"a\" have string: " << a;
cout << endl << "Acces object \"a\" with index[4]: " <<
a[4]<<endl <<endl;

return 0;
}
Результат Б
Вывод: В данной лабораторной работе были изучены и
закреплены практикой такое понятие как перегрузка
операторов: перегрузка операторов присваивания,
сравнения, сложения и индексации. Ее выполнение явилось
основой для применения на практике теоретических знаний
об использовании операторов. Таким образом, можно
судить о широких возможностях, предоставляемых языком
C ++ в отношении манипулирования памятью в желаемом
пользователем направлении