// zad1
// zapoznaj się z implementacją klasy info (klasa raportuje operacje na niej wykonywane, obiekty są automatycznie numerowane)
// dokończ implementację klasy schowek
// klasa schowek przechowuje (za pomocą wskaźnika) daną typu info, lub nic (np. po konstrukji bezargumentowej)
// klasa schowek winna posiadać zwykłe i przenoszące warianty konstruktora (kopiującego) i operatora przypisania oraz konstruktor
// z argumentem &info, konstruktor bezargumentowy i destruktor, metody te powinny na wyjście raportować wykonywane operacje;
// wywołanie metody przenoszącej schowka nie powinno powodować konstrukcji obiektu info, ani błędów przy poźniejszej destrukcji
// przeanalizuj efekty wywołania funkcji zad1 - wykonując ją krokowo oraz śledząc komunikaty wyprowadzanie na konsolę
// rozbuduj funkcję zad1, by ten sposób sprawdzić:
// -w jakich sytuacjach wywoływane są metody zwykłe, a kiedy przenoszące (w razie potrzeby dopisz nowe metody/operatory do schowka)?
// -co jest wywoływane przy konstrukcji/przypisaniu do schowka z wyrażenia zwracającego tymczasowy nienazwany schowek?
// -co jest wywoływane przy konstrukcji/przypisaniu do schowka ze zmiennej zwracanej z funkcji przez wartość?
// -wypróbuj działanie move(), co się stanie gdy użyjemy move(), a w klasie nie ma metod przenoszących(zakomentuj je chwilowo)?
// -czy kompilator poprawnie rozpoznał wszystkie sytuacje kiedy można użyć metody przenoszącej?
// -czy metody przenoszące poprawiają wydajność kodu? Odpowiedź uzasadnij.

// zad2
// zapoznaj się za strukturą osoba i funkcją zad2
// dokończ funkcję zad2 posługując się algorytmami stl (sort for_each) i funkcjami lambda tak, aby
// - posortować listę liste osob los wg wieku osób
// - wyświetlić posortowane osoby (tylko imie i wiek każdej osoby)
// - zwiększyć wiek każdej z osób o 1 i ponownie wyświetlić listę
// - wyznaczyć średni wiek osoby, wyświetlić go i wyświetlić osoby starsze niż średnia
// uwaga: w capture list funkcji lambda należy przekazywać wyłącznie faktycznie potrzebne zmienne, nie używać [&] ani tym bardziej [=]




#include <iostream>
#include <vector>
#include <string>
#include <algorithm>

using namespace std;


class info
{
	static int serial,	// ++ przy konstrukcji
		cntr;	// ++ przy konstrukcji, -- przy destrukcji, zwracany przez getcntr
	const int  nr;		// =++serial przy konstrukcji
public:
	static int getcntr() { return cntr; };
	info() :nr(++serial) { cntr++; cout << "\ninfo() nr: " << nr; }
	info(const info &cri) :nr(++serial) { cntr++; cout << "\ninfo(const info &cri) nr: " << nr << " cri.nr: " << cri.nr; }
	~info() { cntr--; cout << "\n~info() nr: " << nr; }
	info & operator=(const info &cri) { cout << "\ninfo & operator=(const info &cri) nr: " << nr << " cri.nr: " << cri.nr; return *this; }
	friend ostream& operator<<(ostream &os, const info& cri) { return os << " info nr: " << cri.nr; }
};
int info::serial = 0,		// static w klasie
info::cntr = 0;		// static w klasie


struct osoba
{
	string imie, nazwisko;
	int wiek;
	//	osoba():wiek(-1){}
	osoba(const string & imie, const string & nazwisko, const int wiek) :imie(imie), nazwisko(nazwisko), wiek(wiek) {}
	friend ostream& operator<<(ostream &os, const osoba& cro) { return os << endl << cro.imie << ' ' << cro.nazwisko << ' ' << cro.wiek; }
};


class schowek
{
	info *ptr; // gdy ==nullptr, to schowek jest pusty
public:
	schowek() :ptr(nullptr) { cout << "\nschowek()"; }
	schowek(const info &crt) :ptr(new info(crt)) { cout << "\nschowek(const info &crt)"; }
	~schowek() { cout << "\n~schowek()"; delete ptr; }
	friend ostream& operator<<(ostream &os, const schowek& crs) { return crs.ptr ? os << *crs.ptr : os << " nullptr"; }

	//TODO

	schowek(const schowek &crs);
	schowek(schowek &&rrs);
	schowek& operator=(const schowek &crs);
	schowek& operator=(schowek &&rrs);
};


void zad1()
{
	info i1;
	schowek	si1(i1),
		si2,
		si3(i1),
		si4(si1),
		si5(move(si4));

	cout << endl << si1 << si2 << si3 << si4 << si5;

	cout << "\n\n zamiana s1-s2 z move(), przed " << si1 << si2 << si3;

	si3 = move(si2);
	si2 = move(si1);
	si1 = move(si3);

	cout << "\n\n zamiana s1-s2 bez move(), przed " << si1 << si2 << si3;

	si3 = si2;
	si2 = si1;
	si1 = si3;

	cout << "\n\n po zamianie " << si1 << si2 << si3;

	//TODO

}


void zad2()
{
	vector<osoba> los;
	los.push_back(osoba("Jan", "Kowalski", 25));
	los.push_back(osoba("Tomek", "Kowalski", 5));
	los.push_back(osoba("Anna", "Kowalska", 20));
	los.push_back(osoba("Antoni", "Kowalski", 65));
	los.push_back(osoba("Onufry", "Kowalski", 99));
	los.push_back(osoba("Zosia", "Kowalska", 3));

	cout << "\n\n Lista osob:";
	for (auto const & p : los) cout << p;


	// odtąd bez deklarowania zmiennych typu iteratorowego (jawnie ani auto), bez for, z algorytmami i funkcjami lambda
	// użyj wartości iteratora zwracanej przez metody kontenera .begin(), .end() jako argumentów algorytmów

	cout << "\n\n Sortowanie wg wieku...";
	//TODO
	cout << "\n\n Lista (imie i wiek):";
	//TODO
	cout << "\n\n Zwiekszenie wieku:";
	//TODO
	cout << "\n\n Lista:";
	//TODO
	cout << "\n\n Sredni wiek...";
	//TODO
	cout << "\n\n Starsi od sredniej:";
	//TODO
}

int main()
{
	int checkleak = info::getcntr();
	zad1();
	if (checkleak != info::getcntr())
		cerr << "\n\n\tWYCIEK PAMIECI !!!\n";

	zad2();
	return 0;
}

schowek::schowek(const schowek & crs)
{
	ptr = new info(*crs.ptr);
}

schowek::schowek(schowek && rrs)
{
	ptr = move(rrs.ptr);
	rrs.ptr = nullptr;
}

schowek & schowek::operator=(const schowek & crs)
{
	if (crs.ptr == nullptr)
	{
		return *this;
	}
	if (this != &crs)
	{
		delete ptr;
		ptr = new info(*crs.ptr);
	}
	return *this;
}

schowek & schowek::operator=(schowek && rrs)
{
	if (this != &rrs)
	{
		delete ptr;
		ptr = rrs.ptr;
		rrs.ptr = nullptr;
	}
	return *this;
}