kontener.cpp

/*
 * File:   kontener.cpp
 * Author: Marcin
 */

#include "kontener.h"
//------------------------------------------------------------------------------
// Konstruktory i destruktory
// Konstruktor domyślny - tworzy kontener danego typu o domyślnym rozmiarze

template <typename TYP>
Kontener<TYP>::Kontener() {
    rozmiar = DOMYSLNY_ROZMIAR;
    kontener = new TYP [rozmiar];
}
// Konstruktor z parametrami - tworzy kontener danego typu o podanym rozmiarze

template <typename TYP>
Kontener<TYP>::Kontener(unsigned int podany_rozmiar) {
    rozmiar = podany_rozmiar;
    kontener = new TYP [rozmiar];
}
// Konstruktor kopiujący

template <typename TYP>
Kontener<TYP>::Kontener(const Kontener& orig) {
    rozmiar = orig.rozmiar;
    kontener = new TYP [rozmiar];
    memcpy(kontener, orig.kontener, rozmiar * sizeof (TYP));
    // Alternatywnie:
    //for (unsigned int i = 0; i < rozmiar; i++) kontener[i] = orig.kontener[i];
}
// Wirtualny destruktor

template <typename TYP>
Kontener<TYP>::~Kontener() {
    delete [] kontener;
}
//------------------------------------------------------------------------------
// Metody

template <typename TYP>
unsigned int Kontener<TYP>::pobierz_rozmiar() const {
    return rozmiar;
}

template <typename TYP>
TYP Kontener<TYP>::pobierz_elem(unsigned int index) {
    // Chroni przed przekorczeniem indeksu
    if (index < rozmiar) return kontener[index];
        // W przypadku przekroenia indeksu zwraca 0
    else return 0;
}

template <typename TYP>
bool Kontener<TYP>::dodaj_elem(TYP wartosc) {
    // Zapisuje index
    int index = rozmiar;
    // Zmienia rozmiar kontenera
    Kontener::zmien_rozm(rozmiar +1);
    // Dodaje element
    kontener[index] = wartosc;
}
template <typename TYP>
bool Kontener<TYP>::modyfikuj_elem(unsigned int index, TYP wartosc) {
    // W przypadku przekroczenia indeksu zwraca false
    if (index >= rozmiar) return false;
    else if (rozmiar == 0) return false;
    else {
        kontener[index] = wartosc;
        return true;
    }
}

template <typename TYP>
bool Kontener<TYP>::usun_elem(unsigned int index) {
    // Chroni przed przekorczeniem indeksu
    if (!(index < rozmiar)) {
        // W przypadku przekroenia indeksu zwraca false
        return false;
    }
    if (rozmiar == 0) return false;
    // Alokuje nowy kontener, o rozmiarze mniejszym o jeden
    TYP* nowy_kontener = new TYP [rozmiar - 1];
    // Kopiuje bajty ze starego kontenera do nowego, pomijając wskazany element
    for (unsigned int i = 0; i < index; i++) nowy_kontener[i] = kontener[i];
    for (unsigned int i = index + 1; i < rozmiar; i++) nowy_kontener[i - 1] = kontener[i];
    //    memcpy(nowy_kontener, kontener, index * sizeof (int));
    //    memcpy(nowy_kontener + index, kontener, (rozmiar - index) * sizeof (int));
    // Usuwa stary kontener
    delete[] kontener;
    // Zapisuje nowy kontener i jego rozmiar do klasy
    kontener = nowy_kontener;
    rozmiar = rozmiar - 1;
    // Wszystko sie udalo - zwraca true
    return true;
}

template <typename TYP>
bool Kontener<TYP>::zamien_elem(TYP& a, TYP& b) {
    if (rozmiar < 2) return false;
    TYP c(a);
    a = b;
    b = c;
}

template <typename TYP>
bool Kontener<TYP>::zmien_rozm(unsigned int nowy_rozmiar) {
    // Sprawdza czy nowy rozmiar jest większy od starego, jeśli nie - zwraca false
    if (!(nowy_rozmiar > rozmiar)) return false;
    // Alokuje nowy kontener
    TYP* nowy_kontener = new TYP [nowy_rozmiar];
    // Kopiuje bajty ze starego kontenera do nowego
    memcpy(nowy_kontener, kontener, rozmiar * sizeof (TYP));
    // Usuwa stary kontener
    delete[] kontener;
    // Zapisuje nowy kontener i jego rozmiar do klasy
    kontener = nowy_kontener;
    rozmiar = nowy_rozmiar;
    // Wszystko sie udalo - zwraca true
    return true;
}

// Przeciążone operatory
// Przeciążony operator przypisania

template <typename TYP>
        Kontener<TYP>& Kontener<TYP>::operator=(const Kontener& nowa) {
    // Zabezpiecza przed przypisaniem nowa = nowa;
    if (&nowa == this) return *this;
    // Usuwa tablice do której przypisujemy
    delete[] kontener;
    // Alokuje tyle pamięci, aby pomieścić przypisywaną tablicę
    rozmiar = nowa.rozmiar;
    kontener = new TYP [rozmiar];
    // Kopiuje zawartosc przypisywanej tablicy
    memcpy(kontener, nowa.kontener, rozmiar * sizeof (TYP));
    // Zwraca refencję do *this
    return *this;
}
// Przeciążony operator indeksowania

template <typename TYP>
TYP& Kontener<TYP>::operator[](unsigned index) {
    // Jeśli przekroczymy zakres zwróci odwołanie do ostatniego elementu
    return kontener[index < rozmiar ? index : rozmiar - 1];
}