contenitore.cpp

#include "contenitore.h"

Contenitore::Contenitore(int cIniziale) {
    utilizzati = 0;
    elementi = new int[cIniziale];
    capacita = cIniziale;
}

Contenitore operator +(Contenitore c1, Contenitore c2) {
    Contenitore c = Contenitore(c1.dimensione() + c2.dimensione());
    return c;

}

ostream& operator <<(ostream& out, Contenitore c) {
    int ultimo = c.dimensione() - 1;
    for(int i = 0; i < ultimo; i++) {
        out << c.getElemento(i) << ", ";

    }
    out << c.getElemento(ultimo);
    return out;
}

int Contenitore::conta(int elem) {
    int numero = 0;

    for(int i = 0; i < utilizzati; i++) {
        if(elementi[i] == elem) {numero++;}
    }
    return numero;
}

int Contenitore::elimina(int elem) {

    int eliminati = 0;
    int i = 0;

    while(i < utilizzati) {
        if(elementi[i] == elem) {
            utilizzati--;
            elementi[i] = elementi[utilizzati];
            eliminati++;
        }
        else {
            i++;
        }
    }
    return eliminati;
}

bool Contenitore::eliminaUno(int elem) {
    int i = 0;

    while (i < utilizzati) {
        if(elementi[i] == elem) {
            utilizzati--;
            elementi[i] = elementi[utilizzati];
            return true;
        }
        else {
            i++;
        }
    }
    return false;
}

void Contenitore::inserisci(int elem) {
    cout << endl << "######## Procedura inserisci(" << elem << ") ########" << endl;
    cout << "elem: " << elem << " Utilizzati: " << utilizzati << endl;

    for(int i = 0; i < utilizzati; i++) {
                cout << "elementi[" << i << "]: " << elementi[i] << " ";
        }
    if(utilizzati == capacita) {
        alloca(utilizzati+1);
    }
    elementi[utilizzati] = elem;
    cout << "elementi[" << utilizzati << "] = " << elementi[utilizzati] << endl;
    utilizzati++;
    cout << "########################################" << endl;
}

int Contenitore::getElemento(int i) {
    if(i < 0 || i >= utilizzati) {
        return 0;
    }
    return elementi[i];

}

void Contenitore::operator +=(Contenitore c) {
    if(utilizzati + c.dimensione() > capacita) {
        alloca(utilizzati + c.dimensione());
    }

    for(int i = utilizzati; i < utilizzati + c.dimensione() ; i++) {
        int indice = i - utilizzati;
        elementi[i] = c.getElemento(indice);
    }
    utilizzati += c.dimensione();
}

void Contenitore::operator =(Contenitore c) {
    if(this == &c) {return;}
    if(capacita != c.getCapacita()) {
        int *v = new int[c.getCapacita()];
        delete[] elementi;
        elementi = v;
        capacita = c.getCapacita();
    }

    for(int i = 0; i < c.dimensione(); i++) {
        elementi[i] = c.getElemento(i);
    }
    utilizzati = c.dimensione();
}

void Contenitore::alloca(int dim) {
    cout << endl << endl << "======== Procedura alloca ============" << endl;
    if(capacita == dim) {
        return;
    }
    if(dim < utilizzati) {
        dim = utilizzati;
    }
    int *v = new int[dim];
    for(int i = 0; i < utilizzati; i++) {
        v[i] = elementi[i];
        cout << "v[" << i << "]: " << v[i] << " elementi[" << i << "]: " << elementi[i] << endl;
    }
    delete[] elementi;
    elementi = v;
    delete[] v;
    capacita = dim;
    cout << "======================================" << endl << endl;
}