// Tablica_Dynamiczna_kolos_PK.cpp : Defines the entry point for the console application.
//
#include "stdafx.h"
#include <iostream>
class Zespolona
{
double rzeczywista;
double urojona;
public:
Zespolona():rzeczywista(0), urojona(0) {}
//nie trzeba tworzyć konstruktorów kopiującego i przenoszącego, bo nie operujemy na
//strukturach dynamicznych, gdzie obie struktury miałyby te same wskaźnik
Zespolona(double r, double u): rzeczywista(r), urojona(u) {}
double getR() const { return rzeczywista; }
double getU() const { return urojona; }
void setR(const double r):rzeczywista(r) {}
void setU(const double u):urojona(u) {}
friend std::istream& operator >>(std::istream& s, Zespolona& z)
{
s >> z.rzeczywista >> z.urojona;
return s;
}
bool operator <(const Zespolona& z) const //ten const to tego, że nie zmieniamy this
{
return rzeczywista*rzeczywista + urojona*urojona
< z.rzeczywista*z.rzeczywista + z.urojona*z.urojona;
}
};
class Tab
{
protected:
//Zespolona** tablica; dla tablic dynamicznych wsk
Zespolona* tablica;
unsigned int rozmiar;
public:
Tab(): tablica(nullptr), rozmiar(0) {}
~Tab()
{
//dla tablic dynamicznych wsk, a nie obiektów jak niżej
//for (int i = 0; i < rozmiar; ++i)
// delete tablica[i];
//delete[] tablica;
delete[] tablica;
}
//operator += dodaje element na koniec tablicy
virtual void operator +=(const Zespolona& z)
{
//new Zespolona*[rozmiar + 1]; - dla tablicy wsk
auto nowaTab = new Zespolona[rozmiar + 1];
for (unsigned int i = 0; i < rozmiar; ++i)
{
nowaTab[i] = tablica[i]; //dla tabWsk: nowaTab[i]= new Zespolona(*tablica[i]);
//dla tabWsk musimy stworzyć nową tablicę na podstawie tablica[i], i trzeba wyłuskać te wartości
}
nowaTab[rozmiar] = z;
delete[] tablica;
tablica = nowaTab;
++rozmiar;
}
//operator przypisania
Tab& operator=(const Tab& t)
{
//zwraca Tab&, żeby można było to łańcuchować
//int a = 5;
//int a = b = 5;
if (this == &t) //ZAWSZE!!!
return *this;
delete[] tablica;
rozmiar = t.rozmiar;
tablica = new Zespolona[rozmiar];
for (unsigned int i = 0; i < rozmiar; ++i)
tablica[i] = t.tablica[i];
return *this;
}
//operator przenoszenia
Tab& operator=(Tab&& t)
{
if (this == &t) //ZAWSZE!!!
return *this;
delete[] tablica;
rozmiar = t.rozmiar;
t.rozmiar = 0;
tablica = t.tablica;
t.tablica = nullptr;
}
Zespolona operator[](unsigned int i)//const jest do referencji
{
if (i >= rozmiar)
{
throw std::exception();
}
return tablica[i];
}
};
class Kolejka: public Tab
{
public:
void operator+=(const Zespolona& z) override
{
auto nowaKolejka = new Zespolona[rozmiar + 1];
int i = 0;
//wyszukiwanie elementu i przepisywanie elementów do szukanego
while (i < rozmiar && tablica[i] < z)
{
nowaKolejka[i] = tablica[i];
++i;
}
//wpisanie nowego elementu
nowaKolejka[i] = z;
++rozmiar;
++i;
//przepisanie reszty elementów
while (i < rozmiar)
{
nowaKolejka[i] = tablica[i-1];
++i;
}
delete[] tablica;
tablica = nowaKolejka;
}
friend std::ostream& operator>>(std::ostream& s, Kolejka& k)
{
//for (int i = 0; i < rozmiar; ++i) dla tabWSk
// delete tablica[i]; dla tabWSk
for (int i = 0; i < rozmiar; ++i)
{
//tablica[i] = new Zespolona(); dla tabWSk
s >> tablica[i];
}
return s;
}
operator Zespolona()
{
double sumaR = 0;
double sumaU = 0;
for (unsigned int i = 0; i < rozmiar; ++i)
{
sumaR += tablica[i].getR();
sumaU += tablica[i].getU();
}
return Zespolona(sumaR, sumaU);
}
Zespolona pop()
{
auto bufor = tablica[0];
auto nowaTab = new Zespolona[rozmiar - 1];
for (unsigned int i = 1; i < rozmiar; ++i)
{
nowaTab[i - 1] = tablica[i];
}
delete[] tablica;
--rozmiar;
tablica = nowaTab;
return bufor;
}
};
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// Kolokwium_lista.cpp : Defines the entry point for the console application.
//
#include "stdafx.h"
#include <iostream>
#include <stdlib.h>
class Payment
{
char* name;
double cost;
int day;
int month;
int year;
public:
//konstruktor 5-cio argumentowy
Payment(char *n, double c, int d, int m, int y) : cost(c), day(d), month(m), year(y)
{
name = new char[strlen(n) + 1];
for (unsigned int i = 0; i <= strlen(n); ++i)
name[i] = n[i];
}
//konstruktor kopiujący
Payment(const Payment& p) : Payment(p.name, p.cost, p.day, p.month, p.year) {}
//konstruktor przenoszący
Payment(Payment&& p)
{
name = p.name;
day = p.day;
month = p.month;
year = p.year;
cost = p.cost;
p.cost = 0;
p.day = 0;
p.month = 0;
p.year = 0;
p.name = nullptr;
}
//operator przypisania
Payment& operator=(const Payment& p)
{
if (this == &p) // ten if na początek każdego operatora = (& i &&) kopiującego i przenoszącego/przypisującego
return *this;
cost = p.cost;
day = p.day;
month = p.month;
year = p.year;
delete[] name;
name = new char[strlen(p.name) + 1];
for (unsigned int i = 0; i <= strlen(p.name); ++i)
name[i] = p.name[i];
}
//operator porównania
bool operator<(const Payment& p) const
{
if (year == p.year)
if (month == p.month)
return day < p.day;
else
return month < p.month;
else
return year < p.year;
}
//gettery
char* getName() const { return name; }
double getCost() const { return cost; }
int getDay() const { return day; }
int getMonth() const { return month; }
int getYear() const { return year; }
//settery
void setName(const char* n):name(n) {}
void setCost(const double c): cost(c) {}
//itd...
//zaprzyjażniony operator strumieniowy
friend std::ostream& operator << (std::ostream& s, const Payment& p)
{
s << p.name << " " << p.cost << " " << p.day << "." << p.month << "." << p.year;
return s;
}
};
struct element
{
element* next;
element* prev;
Payment p;
//konstruktor kopiujący
element(const Payment& other) : next(nullptr), prev(nullptr), p(other) {}
};
class List
{
protected:
element* head;
element* tail;
public:
//konstruktor bezargumentowy
List() : head(nullptr), tail(nullptr) {}
//destruktor
~List()
{
while (head)
{
auto bufor = head;
head = head->next;
delete bufor;
}
tail = nullptr;
}
//jak operator ma być przeciążony w klasie pochodnej to stosujemy "virtual" w klasie nadrzednej, a w klasie pochodnej "override", bo nadpisujemy
//przeciążony operator +=
virtual void operator+=(const Payment& p) //typy klasowe moga byc bardzo duze i chcemy uniknac ich kopiowania dlatego &
{
auto newElement = new element(p);
if (tail)
{
auto bufor = tail;
tail = newElement;
bufor->next = tail;
tail->prev = bufor;
}
else
{
tail = head = newElement;
}
}
//jeśli mamy opertator += napisać to robimy to przed konstruktorem, bo go wykorzystujemy
//konstruktor kopiujący
List(const List& other)
{
auto ptr = other.head;
while (ptr)
{
*this += ptr->p;
ptr = ptr->next;
}
}
//zaprzyjaźniony operator strumieniowy <<
friend std::ostream& operator <<(std::ostream& s, const List& l)
{
auto ptr = l.head;
while (ptr)
{
s << ptr->p << std::endl;
ptr = ptr->next;
}
return s;
}
};
class Queue: public List
{
public:
//nadpisany operator +=
void operator+=(const Payment& p) override
{
auto newElement = new element(p);
auto ptr = head;
while (ptr && p < ptr->p)
{
ptr = ptr->next;
}
if (ptr)
{
auto bufor = ptr->prev;
ptr->prev = newElement;
if (ptr == head) head = newElement; //czy to jest konieczne?
if (bufor) bufor->next = newElement;
newElement->prev = bufor;
newElement->next = ptr;
}
else
{
auto bufor = tail;
tail = newElement;
if (bufor)
{
bufor->next = tail;
tail->prev = bufor;
return;
}
else
{
head = tail;
}
}
}
//usuwanie listy
void deleteList()
{
while (head)
{
auto bufor = head;
head = head->next;
delete bufor;
}
tail = nullptr;
}
//operator = przypisania
Queue& operator=(const Queue& q)
{
if (this == &q)
return *this;
deleteList();
auto ptr = q.head;
while (ptr)
{
*this += ptr->p;
ptr = ptr->next;
}
return *this;
}
//operatory konwersji zapisuje się: operator TypDoKtoregoKonwertujesz() { funkcja }
operator double()
{
auto ptr = head;
auto sum = 0.0;
while (ptr)
{
sum += (ptr->p).getCost();
ptr = ptr->next;
}
return sum;
}
Payment pop()
{
auto toReturn = head->p;
auto bufor = head;
head = head->next;
if (tail == bufor)
tail = nullptr;
delete bufor;
return toReturn;
}
};
int main()
{
Queue list;
list += Payment("Adam", 50, 4, 12, 1997);
list += Payment("Piotr", 30, 5, 12, 1997);
list += Payment("Tomasz", 80, 4, 8, 1997);
list += Payment("Domek", 25, 14, 1, 1998);
list += Payment("Lipa", 60, 17, 2, 1995);
list += Payment("Lol", 56, 19, 7, 2000);
std::cout << list;
Queue l;
l = list;
std::cout << std::endl << l;
std::cout << std::endl << (double)l;
std::cout << std::endl << l.pop();
std::cout << std::endl <<std::endl << l;
return 0;
}
