Untitled

//OVVIAMENTE NON UTILIZZEREMO PIU' LE NEW INT MA LE NEW T, SICCOME USIAMO IL CONTENITORE TEMPLATE 
template <class T>
DinamicContainer<T>::DinamicContainer(int firstCapacity) { //OBBLIGO CAPACITA' ALMENO 1
    if (firstCapacity >= 1) {
        usedValues = 0;
        elements = new T[firstCapacity];
        capacity = firstCapacity;
    }
    else
        do {
            int tmp = 0;
            cout << "Minimum capacity = 1" << endl << "Please insert new value = ";
            cin >> tmp;
            cout << endl;
            firstCapacity = tmp;
            usedValues = 0;
            elements = new T[firstCapacity];
            capacity = firstCapacity;
        } while (firstCapacity < 1);
}
template <class T>
int DinamicContainer<T>::getUsedValues() {
    return this->usedValues;
}
template <class T>
int DinamicContainer<T>::getCapacity() {
    return this->capacity;
}
template <class T>
int DinamicContainer<T>::getSize(DinamicContainer<T>& firstIstance, DinamicContainer<T>& secondIstance) {
    //Un getSize mi permette di fermarmi solo ai valori che effettivamente posso sommare, così faccio un doppio check riguardo l' inline operator +
    if (firstIstance.getUsedValues() < secondIstance.getUsedValues())
        return firstIstance.getUsedValues();
    return secondIstance.getUsedValues();
}
template <class T>
T DinamicContainer<T>::getElements(int index) {
    return elements[index];
}
template <class T>
void DinamicContainer<T>::add(T value) {
    //Funzione abbastanza complicata, se gli elementi utilizzati non superano la capacità del contenitore posso inserire un valore
    if (usedValues < capacity) {
        elements[usedValues] = value;
        usedValues += 1;
        //cout << utilizzati;
    }
    else {/*Cerchiamo di ottenere una doppia traccia dei nostri valori, iniziamo con un puntatore d' appoggio, dove prendere tutti i valori
          precedenti del primo puntatore in modo da non perderli questo puntatore d' appoggio avrà la dimensione incrementata di 1
          in modo che ogni volta che l' utente supera la capacità ma vuole reisenrire un valore, non si va in overflow, di conseguenza
          il nostro puntatore di partenza viene liberato e si riprende tutti i valori che si salva momentaneamente il puntatore d' appoggio*/
          //Nel momento in cui i valori utilizzati sono uguali alla capacità, rischio di andare in overflow appena inserisco un valore
        T* v = new T[usedValues + 1]; //Puntatore con dimensione incrementata di 1
        for (int i = 0; i < usedValues; i++) //Questo puntatore si salva gli elementi del vettore di partenza
            v[i] = elements[i]; //In questo modo i valoro iniziali inserita da utente non vanno persi
        v[usedValues] = value; //E ora, in testa al nostro puntatore, che é diventato un vettore, andiamo a inserire il nuovo valore inserito da utente
        usedValues += 1; //Aggiornamiamo la variabili utilizzati
        delete[] elements; //Ora liberiamo il vettore iniziale
        elements = new T[usedValues]; //Allochiamo al puntatore, e lo facciamo diventare un vettore nuovo con dimensione incrementata
        for (int i = 0; i < usedValues; i++)
            /*Quello che era il nostro vettore iniziale, continua ad esserlo, e si riprende i suoi valori iniziali insieme a quello nuovo
            che sarebbe andato in overflow*/
            elements[i] = v[i];
        capacity = usedValues; //Aggiorniamo la capacità del contenitore
        delete[] v; //Cancelliamo anche lo spazio dedicato nel nostro puntatore secondario
    }
}
template <class T>
int DinamicContainer<T>::count(T value) {
    int counter = 0;
    for (int i = 0; i < usedValues; i++) {
        if (elements[i] == value) {
            counter++;
        }
    }
    return counter;
}
template <class T>
bool DinamicContainer<T>::removeOne(T elem) {
    for (int i = 0; i < usedValues; i++) {
        if (elements[i] == elem) {
            usedValues--;
            elements[i] = elements[usedValues];
            return true;
        }
    }
    return false;
}
template <class T>
int DinamicContainer<T>::removeAll(T value) {
    int removed = 0;
    int i = 0;
    while (i < usedValues) {
        if (elements[i] == value) {
            usedValues--;
            elements[i] = elements[usedValues];
            removed++;
        }
        else {
            i++;
        }
    }
    return removed;
}
template <class T>
void DinamicContainer<T>::setDinamicSize(int value) {
    int* v = new int[usedValues + value]; //Puntatore con dimensione incrementata con valore da allocare
    for (int i = 0; i < usedValues; i++) //Questo puntatore si salva gli elementi del vettore di partenza
        v[i] = elements[i]; //In questo modo i valoro iniziali inserita da utente non vanno persi
    delete[] elements; //Ora liberiamo il vettore iniziale
    elements = new int[usedValues + value]; //Allochiamo al puntatore, e lo facciamo diventare un vettore nuovo con dimensione incrementata
    for (int i = 0; i < usedValues; i++)
        /*Quello che era il nostro vettore iniziale, continua ad esserlo, e si riprende i suoi valori iniziali insieme a quello nuovo
        che sarebbe andato in overflow*/
        elements[i] = v[i];
    capacity = usedValues + value; //Aggiorniamo la capacità del contenitore
    delete[] v; //Cancelliamo anche lo spazio dedicato nel nostro puntatore secondario
}
template <class T>
void DinamicContainer<T>::istancesSum(DinamicContainer<T>& firstIstance, DinamicContainer<T>& secondIstance, DinamicContainer<T>& thirdIstance) {
    T* p; //Pointer che uso per la funzione inline e calcolare la somma tra i due contenitori
    p = firstIstance + secondIstance;
    int size = firstIstance.getSize(firstIstance, secondIstance);
    for (int i = 0; i < size; i++)
        thirdIstance.add(p[i]);
}
template <class T>
void DinamicContainer<T>::operator +=(DinamicContainer<T> istance) {
    if (usedValues + istance.getUsedValues() > capacity) {
        setDinamicSize(usedValues + istance.getUsedValues());
    }
    for (int i = usedValues; i < usedValues + istance.getUsedValues(); i++) {
        int index = i - usedValues;
        elements[i] = istance.getElements(index);
    }
    usedValues += istance.getUsedValues();
}
template <class T>
void DinamicContainer<T>::operator = (DinamicContainer<T> istance) {
    if (this == &istance) { //Se passo la stessa istanza della classe come parametro , ESCO!
        return;
    }
    if (capacity != istance.getCapacity()) {
        T* v = new T[istance.getCapacity()];
        delete[] elements;
        elements = v;
        capacity = istance.getCapacity();
    }

    for (int i = 0; i < istance.getUsedValues(); i++) {
        elements[i - 1] = istance.getElements(i);
    }
    usedValues = istance.getUsedValues();
}