// 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;
}
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
#include <iostream>
#include <utility>
#include <string>
using namespace std;
///////////////////////////////////////////////////////////////////////////////
class task
{
string todo = "empty task";
int date = 0;
public:
task(string, int);
task() = default;
task(const task &) = default;
task & operator=(const task &) = default;
void complete(void);
int operator>(const task &); // porownoje daty
int operator==(const task &); // porownuje cale zadania
friend ostream & operator<<(ostream &, const task &);
friend istream & operator>>(istream &, task &);
};
task::task(string todo, int date) : todo(todo), date(date) {}
void task::complete(void)
{
cout << "\ntask " << todo << " scheduled for " << date << " done successfully!";
}
int task::operator>(const task &rt)
{
return date>rt.date;
}
int task::operator==(const task &rt)
{
return ((todo == rt.todo) && (date == rt.date));
}
ostream & operator<<(ostream &os, const task &rt)
{
os << rt.todo;
os << " ";
os << rt.date;
return os;
};
istream & operator>>(istream &is, task &rt)
{
return is >> rt.todo >> rt.date;
};
struct q_elem
{
task t;
q_elem * next;
q_elem(const task &ctr) :t(ctr), next(nullptr) {};
};
///////////////////////////////////////////////////////////////////////////////
class queue
{
protected:
q_elem *head, /* nullptr dla pustej kolejki */
*tail; /* istotny jesli head != nullptr */
public:
queue() :head(nullptr) {}
virtual queue & operator+=(const task &rq) // virtual!!!
{
q_elem *qep = new q_elem(rq);
if (head)
tail->next = qep;
else
head = qep;
tail = qep;
return *this;
}
queue(const queue &rq) :head(nullptr)
{
q_elem *qep = rq.head;
while (qep)
{
(*this) += qep->t;
qep = qep->next;
}
}
queue(queue &&rrq) : head(rrq.head), tail(rrq.tail)
{
rrq.head = rrq.tail = nullptr;
}
~queue()
{
while (head)
{
const q_elem * qep = head;
head = head->next;
delete qep;
}
}
void empty() // pozostawia obiekt pusty (head==nullptr)
{
while (head)
{
const q_elem * qep = head;
head = head->next;
delete qep;
}
}
queue & operator=(const queue &rq)
{
if (&rq == this)
return *this;
empty();
q_elem *qep = rq.head;
while (qep)
{
(*this) += qep->t;
qep = qep->next;
}
return *this;
}
queue & operator=(queue &&rq)
{
swap(head, rq.head);
swap(tail, rq.tail);
return *this;
}
int contains(const task & ctr)
{
q_elem *qep = head;
while (qep)
if (qep->t == ctr)
return 1;
else
qep = qep->next;
return 0;
}
friend istream & operator>>(istream &is, queue &rq)
{
task t; // wymaga konstruktora bezargumentowego task()
rq.empty();
while (is >> t)
rq += t;
return is;
}
friend ostream & operator<<(ostream &os, const queue &rq)
{
q_elem *qep = rq.head;
while (qep)
{
os << qep->t << " ";
qep = qep->next;
}
return os;
}
};
///////////////////////////////////////////////////////////////////////////////
class sorted_q :public queue
{
public:
sorted_q & operator+=(const task &rq) // inny typ zwracany - ok tutaj
{
q_elem * const newel = new q_elem(rq);
if ((!head) || (head->t > rq)) // wstaw na pocz�tek
{
newel->next = head;
head = newel;
}
else
{
q_elem * pq = head;
while (pq->next && !(pq->next->t>rq))
pq = pq->next;
newel->next = pq->next;
pq->next = newel;
}
if (!newel->next)
tail = newel;
return *this;
}
void complete(queue &tobedone)
{
q_elem *qep = head;
while (qep)
{
if (tobedone.contains(qep->t))
qep->t.complete();
qep = qep->next;
}
}
using queue::operator=;
// kolejno�� wywo�ywania konstruktor�w powoduje ze poni�sza deklaracja nie jest potrzebna
//
// using queue::queue;
// automatyczne konwersje o kl. bazowej i metody wirtualne powoduj� �e poni�sze nie s� niezb�dne
//
// friend istream & operator>>(istream &is, sorted_q &rq)
// friend ostream & operator<<(ostream &os, const sorted_q &rq)
};
int main()
{
queue q1;
sorted_q s1;
q1 += task("task a", 20161020);
q1 += task("task b", 20161020);
q1 += task("task c", 20161515);
q1 += task("task d", 20160505);
queue q2 = move(q1);
cout << "q1 " << q1 << endl << "q2 " << q2 << endl;
q1 = move(q2);
cout << "q1 " << q1 << endl << "q2 " << q2 << endl;
q2 = q1;
q1 += task("task e", 20160505);
cout << endl << q1;
q1 = q2;
cout << endl << q1;
s1 = q1;
cout << endl << s1;
s1 += task("task f", 900000000);
s1 += task("task g", 00000);
cout << endl << s1;
s1.complete(q1);
cin >> s1;
cout << endl << s1;
cout.flush();
}