// tablica.hpp
#include <iostream>

using namespace std;

template <class T>
class Tablica
{
    //friend ostream& operator<<(ostream&, const Tablica<T>&);
private:
    T* dane;
    unsigned rozmiar;
public:
    Tablica();          // tworzy pusty obiekt (pust¹ tablicê)
    ~Tablica();
    explicit Tablica(unsigned);  // tworzy tablicê o podanym rozmiarze
    void dodaj_element(T);
    void wypisz() const;
    T get_wartosc(unsigned) const;
    void set_wartosc(unsigned, T);
    unsigned get_rozmiar() const;
    void clear();
    void zmien_rozmiar(unsigned);
    T& operator[](unsigned el) { return dane[el]; }
};

template <class T>
Tablica<T>::Tablica() : dane(nullptr), rozmiar(0) {}

/*
Tablica::Tablica()
{
    dane = nullptr;
    rozmiar = 0;
}
*/

template <class T>
Tablica<T>::Tablica(unsigned size) : dane(new T[size]), rozmiar(size)
{
    for(unsigned i = 0; i < size; ++i)
        dane[i] = 0;
}

template <class T>
void Tablica<T>::dodaj_element(T num)
{
    //1.
    T* temp = new T[rozmiar];

    //2.
    for(unsigned i = 0; i < rozmiar; ++i)
        temp[i] = dane[i];

    //3.
    delete[] dane;

    //4.
    dane = new T[rozmiar + 1];

    //5.
    for(unsigned i = 0; i < rozmiar; ++i)
    {
        dane[i] = temp[i];
    }

    //6.
    delete[] temp;

    //7.
    dane[rozmiar] = num;

    rozmiar++;
}

template <class T>
void Tablica<T>::wypisz() const
{
    for(unsigned i = 0; i < rozmiar; i++)
    {
        cout << dane[i] << " ";
    }
    cout << endl;
}

template <class T>
Tablica<T>::~Tablica()
{
    delete[] dane;
    cout << "Zniszczono tablice";
}

template <class T>
T Tablica<T>::get_wartosc(unsigned nr) const
{
    return dane[nr];
}

template <class T>
void Tablica<T>::set_wartosc(unsigned index, T num)
{
    dane[index] = num;
}

template <class T>
unsigned Tablica<T>::get_rozmiar() const
{
    return rozmiar;
}

template <class T>
void Tablica<T>::clear()
{
    delete[] dane;
    rozmiar = 0;
}

template <class T>
void Tablica<T>::zmien_rozmiar(unsigned newSize)
{
    if(newSize == rozmiar)
        return;

    if(newSize > rozmiar)
    {

        T* temp = new T[rozmiar];

        for(unsigned i = 0; i < rozmiar; ++i)
        {
            temp[i] = dane[i];
        }

        delete[] dane;

        dane = new T[newSize];

        for(unsigned i = 0; i < rozmiar; ++i)
        {
            dane[i] = temp[i];
        }

        delete[] temp;

        for(unsigned i = rozmiar; i < newSize; ++i)
        {
            dane[i] = 0;
        }

        rozmiar = newSize;
    }

    else
    {
        T* temp = new T[newSize];

        for(unsigned i = 0; i < newSize; ++i)
        {
            temp[i] = dane[i];
        }

        delete[] dane;

        dane = new T[newSize];

        for(unsigned i = 0; i < newSize; ++i)
        {
            dane[i] = temp[i];
        }

        delete[] temp;

        rozmiar = newSize;
    }
}

template <class T>
ostream& operator<<(ostream& strumien, const Tablica<T>& obiekt)
{
    for(unsigned i = 0; i < obiekt.get_rozmiar(); ++i)
        strumien << obiekt.get_wartosc(i) << '\t';
    return strumien;
}

// main.cpp
#include <iostream>
#include <cstdlib>
#include <ctime>
#include "tablica.hpp"

using namespace std;

int main()
{
    Tablica<double> tablica(5);     // tworzy tablicê piêcioelementow¹
    tablica.wypisz();
    tablica.zmien_rozmiar(10);
    tablica.wypisz();
    tablica.zmien_rozmiar(7);

    srand(static_cast<unsigned>(time(nullptr)));

    const unsigned rozmiar = tablica.get_rozmiar();
    for(unsigned i = 0; i < rozmiar; ++i)
    {
        tablica[i] = 1.0 * rand() / RAND_MAX;
    }
    cout << tablica << endl;

    tablica.zmien_rozmiar(15);

    cout << tablica << endl;

    return 0;
}