Подякувати Студентському архіву довільною сумою
Admin
26.02.2023 12:38
Дякуємо, що користуєтесь нашим архівом!
Перевантаження операторів
Інформація про навчальний заклад
ВУЗ:
Національний університет Львівська політехніка
Інститут:
Не вказано
Факультет:
КН
Кафедра:
Кафедра ЕОМ
Інформація про роботу
Рік:
2013
Тип роботи:
Лабораторна робота
Предмет:
Програмування Ч 3 Структури даних і алгоритми
Частина тексту файла (без зображень, графіків і формул):
Міністерство освіти і науки України
Національний університет „ Львівська політехніка “
Кафедра ЕОМ
Звіт
З Лабораторної роботи №5:
“ Перевантаження операторів”
МЕТА РОБОТИ: ПОЗНАЙОМИТИСЯ ІЗ ПЕРЕВАНТАЖЕННЯМ ОПЕРАТОРІВ.
Короткі теоретичні відомості
Перевантаження операторів
Кожному оператору мова С++ ставить у відповідність ім'я функції, що складається з ключового слова operator, власне оператору та аргументів відповідних типів:
тип operator [символ оператору] (списокПараметрів)
{
//тіло метода
}
Щоб використовувати операцію над об'єктами класів, ця операція повинна бути перевантажена, але є два виключення. Операція присвоювання (=) може бути використана з кожним класом без явного перевантаження. За замовчуванням операція присвоювання зводиться до побітового копіювання даних-елементів класу. Проте таке побітове копіювання небезпечне для класів з елементами, що вказують на динамічно виділені області пам'яті; для таких класів слід явно перевантажувати операцію присвоювання. Операція адресації (&) також може бути використана з об'єктами будь-яких класів без перевантаження; вона просто повертає адресу об'єкта в пам'яті. Але операцію адресації можна також і перевантажувати.
Перевантаження операцій підпорядковується наступним правилам:
При перевантаженні зберігаються кількість аргументів, пріоритети операцій та правила асоціації, що використовуються у стандартних типах даних;
Для стандартних типів даних операції не підлягають перевизначенню;
Перевантажена функція-оператор не може мати параметрів по замовчуванню, не успадковується та не може бути визначеною як static;
Функція-оператор може бути визначена трьома способами – метод класу, дружня функція або звичайна функція. В останніх двох випадках вона повинна приймати хоча б один аргумент, що має тип класу, покажчика або посилання на клас.
При перевантаженні операцій ( ), [], -> або = функція перевантаження операції повинна бути оголошена як елемент класу. Для інших операцій функції перевантаження операцій можуть не бути функціями-елементами.
Коли функція-операція реалізована як функція-елемент, крайній лівий (або єдиний) операнд повинен бути об'єктом того класу (або посиланням на об'єкт того класу), елементом якого є функція. Якщо лівий операнд повинен бути об'єктом іншого класу або убудованого типу, така функція-операція не може бути реалізована як функція-елемент. Функція-операція, реалізована не як функція-елемент, повинна бути другом, якщо ця функція повинна мати прямий доступ до закритих або захищених елементів цього класу. Щоб оголосити функцію як друга (frіend) класу, перед її прототипом в описі класу ставиться ключове слово frіend. Дружні функції класу визначаються поза областю дії класу, але мають право доступу до закритих елементів класу.
Перевантажена операція << повинна мати лівий операнд типу ostream & (такий, як cout), так що вона не може бути функцією-елементом. Аналогічно, перевантажена операція >> повинна мати лівий операнд типу іstream & (такий, як cіn), так що вона теж не може бути функцією-елементом. До того ж кожна з цих перевантажених функцій-операцій може забажати доступу до закритих елементів-даних об'єкта класу, так що ці перевантажені функції-операції роблять функціями-друзями класу.
Будь-яку бінарну операцію можна перевантажувати як нестатичну функцію-елемент з одним аргументом, або як функцію, що не є елементом, із двома аргументами (один з цих аргументів повинен бути або об'єктом класу, або посиланням на об'єкт класу).
Унарну операцію класу можна перевантажувати як функцію-елемент без аргументів, або як функцію, що не є елементом, з одним аргументом; цей аргумент повинен бути або об'єктом класу, або посиланням на об'єкт класу. Функції-елементи, що реалізують перевантажені операції, повинні бути нестатичними, щоб вони могли мати доступ до даних класу. Нагадаємо, що статичні функції-елементи можуть мати доступ тільки до статичних даних-елементів класу.
При перевантаженні унарних операцій переважно створюють функції-операції, що є елементами класу, замість дружніх функцій, що не є елементами. Дружніх функцій краще уникати доти, поки вони не стануть абсолютно необхідними. Використання друзів порушує інкапсуляцію класу.
Щоб перевантажити операцію інкремента та декремента для одержання можливості використання і префіксної, і постфіксної форм, кожна з цих двох перевантажених функцій-операцій повинна мати різну сигнатуру, щоб компілятор мав можливість визначити, яка версія мається на увазі в кожному конкретному випадку. Префіксний варіант перевантажується як будь-яка інша префіксна унарна операція. Для постфіксної форми вводиться додатковий параметр цілого типу у список аргументів, щоб зробити функцію для постфіксного варіанту відмінною від функції для префіксної форми.
Зауваження щодо перевантаження операцій:
Існують обмеження на перевантаження: не підлягають цій процедурі селектор елемента структури (.), оператор доступу до елементу за покажчиком (*), операція дозволу видимості (::), символи препроцесору (#, ##) та sizeof(). Неможливим є введення власних операторів.
Компілятор С++ не розуміє семантики перевантаженого оператору, а отже, не нав'язує жодних математичних концепцій. Можна перевантажити, скажімо, оператор інкременту в якості зменшення аргументу, проте навряд чи в цьому є сенс.
Не існує виведення складних операторів з простих: якщо ви перевантажили оператори operator+ та operator=, це зовсім не означає, що С++ обчислить вираз a += b, оскільки ви не перевантажили operator +=.
Перевантаження бінарних операторів не тотожньо відносно перестановки аргументів місцями, тим більше, якщо вони різного типу.
Завдання
Описати клас, що реалізовує вказаний нижче тип даних. Клас повинен містити множину конструкторів для створення об'єктів певного типу (конструктор по замочуванню та з параметрами, конструктор копії) та подані у таблиці операції над об'єктами класу (плюс обов'язково операцію присвоювання) з використанням механізму перевантаження операцій.
Написати програму, яка демонструє роботу з об'єктами цього класу. Організувати виведення та введення даних за допомогою класів-потоків сin та cout.
4
Клас HugeInt (цілі числа)
Операції: - =, < , >.
Програма:
Main.cpp
#include<iostream>
#include<time.h>
#include"HugeInt.h"
using namespace std;
void main()
{
int t;
srand(time(NULL));
setlocale(0,"");
for(;;)
{
HugeInt chislo1(9);
HugeInt chislo2(9);
int i=1;
while(i==1)
{
cout<<"\nВиберiть режим роботи:\n 1-Ввiд вручну \n 2-Довiльний ввiд комп'ютером\n 3-Вихiд\n";
cin>>t;
switch (t){
case 1 :
{
i=0;
cin>>chislo1;
cin>>chislo2;
break;
}
case 2 :
{
i=0;
chislo1.random();
chislo2.random();
cout<<chislo1<<endl<<chislo2;
break;
}
case 3 : return ;
default :
{ i=1;
cout<<"\n Ввiд неправельний\n\n";
}
}
}
cout<<endl;
while(i==0)
{
cout<<"\nВиберiть oперацiю :\n 1- -= \n 2- > \n 3- < \n";
cin>>t;
switch (t){
case 1 :
{
i=1;
cout<<chislo1<<"-="<<chislo2;
chislo1-=chislo2;
cout<<"\n результат "<<chislo1<<endl;
break;
}
case 2 :
{
i=1;
cout<<chislo1<<">"<<chislo2;
if(chislo1>chislo2)
{
cout<<"ПРАВИЛЬНО";
}
else cout<<"НЕПРАВИЛЬНО";
break;
}
case 3 :
{
i=1;
cout<<chislo1<<"<"<<chislo2;
if(chislo1<chislo2)
{
cout<<"ПРАВИЛЬНО";
}
else cout<<"НЕПРАВИЛЬНО";
break;
}
default :
{
i=0;
cout<<"\n Ввiд неправельний\n\n";
break;
}
}
}
while(i==1)
{
cout<<"\n Бажаєте продовжити ?\n 1 - так\n 2 - нi\n";
cin>>t;
switch (t){
case 1 :
{
i=0;
break;
}
case 2 :
{
return ;
}
default :
{
i=1;
cout<<"\n Ввiд неправельний\n\n";
break;
}
}
}
}
}
HugeInt.срр
#include"HugeInt.h"
//--------------------------------------------------------------------------------------------------------
HugeInt::HugeInt(int g)
{
size=g;
HI=new int[size];
for(int i=0;i<size;i++)
HI[i]=0;
}
//--------------------------------------------------------------------------------------------------------
HugeInt::HugeInt(HugeInt & s)
{
size=s.size;
HI=new int[size];
for(int i=0;i<size;i++)
HI[i]=s.HI[i];
}
//--------------------------------------------------------------------------------------------------------
HugeInt::~HugeInt()
{
delete[] HI;
}
//--------------------------------------------------------------------------------------------------------
HugeInt & HugeInt::operator= (HugeInt& s)
{
if(this != &s)
{
delete[] HI;
size = s.size;
HI = new int[size];
for(int i = 0; i < size; i++)
{
HI[i] =s.HI[i];
}
}
return *this;
}
//--------------------------------------------------------------------------------------------------------
ostream & operator << (ostream & output,HugeInt & s)
{
for(int i=0;i<s.size;i++)
output<<s.HI[i]<<" ";
output << endl;
return output;
}
//--------------------------------------------------------------------------------------------------------
istream & operator >> (istream & in,HugeInt & s)
{
cout<<" Введiть число \n";
char*f=new char[s.size+1];
cin>>f;
s.size=strlen(f);
s.HI=new int [s.size];
int r=atof(f);
for(int i=s.size-1 , j=10 ,l ,u,m; i>=0 ; i--,j=j*10)
{
u = r%j;
l = j/10;
m = u/l;
s.HI[i]=m;
}
delete[] f;
return in;
}
//--------------------------------------------------------------------------------------------------------
void HugeInt::random()
{
for(int i = 0; i < size; i++)
{
HI[i] = rand()%9 ;
}
}
//--------------------------------------------------------------------------------------------------------
bool HugeInt ::operator > (HugeInt &arr)
{
if (this->size > arr.size)
{
return true;
}
else
if (this->size < arr.size)
{
return false;
}
else
{
for(int i=0;i<(this->size);i++)
{
if (this->HI[i]>arr.HI[i])
{
return true;
}
else
if (this->HI[i]<arr.HI[i])
{
return false;
}
}
}
}
//--------------------------------------------------------------------------------------------------------
bool HugeInt ::operator < (HugeInt &arr)
{
if (this->size < arr.size)
{
return true;
}
else
if (this->size > arr.size)
{
return false;
}
else
{
for(int i=0;i<(this->size);i++)
{
if (this->HI[i]<arr.HI[i])
{
return true;
}
else
if (this->HI[i]>arr.HI[i])
{
return false;
}
}
}
}
//--------------------------------------------------------------------------------------------------------
HugeInt & HugeInt::operator-=(HugeInt & arr)
{
HugeInt temsp;
int mins = (size > arr.size) ? size : arr.size;
HugeInt vas(mins);
HugeInt doc(mins);
for(int i=mins-1,j=size-1;j>=0;i--,j--)
{
doc.HI[i]=HI[j];
}
for(int i=mins-1,j=arr.size-1;j>=0;i--,j--)
{
vas.HI[i]=arr.HI[j];
}
if (doc> vas)
{
for(int i = mins-1; i >=0; i--)
{
if (vas.HI[i]>doc.HI[i])
{
if(doc.HI[0]>0)
{
doc.HI[i]+=10;
doc.HI[i-1]--;
}
}
doc.HI[i] -= vas.HI[i];
}
}
else
{
for(int i = mins; i>=0; i--)
{
if (vas.HI[i]<doc.HI[i])
{
if (vas.HI[0]>0)
{
vas.HI[i]+=10;
vas.HI[i-1]--;
}
}
doc.HI[i] = vas.HI[i]-doc.HI[i];
}
for(int i=0;i<mins;i++)
if (doc.HI[i]!=0)
{
doc.HI[i]=doc.HI[i]*(-1);
break;
}
}
*this=doc;
return *this;
}
HugeInt.h
#pragma once
#include<iostream>
using namespace std;
class HugeInt
{
friend ostream & operator << (ostream & out,HugeInt & s);
friend istream & operator >> ( istream & in,HugeInt & s);
int*HI;
int size;
public:
HugeInt(int s=9);
HugeInt(HugeInt & s);
~ HugeInt();
void random();
HugeInt & operator =(HugeInt & s);
bool operator >(HugeInt & s);
bool operator <(HugeInt & s);
HugeInt & operator -=(HugeInt & s);
};
Висновок: На лабораторній роботі №5, я познайомився з перевантаженням операторів .
04.06.2014 18:06-
Ділись своїми роботами та отримуй миттєві бонуси!
0%
Оголошення від адміністратора