#include <iostream>
#include "vettore.h"
using std::ostream;
using std::endl;
using std::cout;

vettore::vettore(unsigned int s, int x):punt(s == 0 ? nullptr : new int[s]), size(s){
    for(int i=0; i<size; ++i){
        punt[i]=x;
    }
}
unsigned int vettore::_size() const{
    return size;
}
vettore::vettore(const vettore& v):punt(v._size() == 0 ? nullptr : new int[v._size()]), size(v._size()){
    for(int i=0; i<size; ++i){
        this[i] = v[i];                                                                      // lui fa cosi v.punt[i], ma perché NON v[i] direttamente??
                                                                                                  // soprattutto essendo l'perator[] ridefinio;
    }
}
vettore::~vettore(){
    delete[] punt;
}
ostream& operator<<(ostream& os, const vettore& v){
    for(int i=0; i<v._size(); ++i){
        os<<" "<<v[i];
    }
    return os;
}

int& vettore::operator[](unsigned int i) const{
    return punt[i];
}

vettore operator+(const vettore& v1, const vettore& v2){                        // quandi si è costretti ad avere due operatori, usare sempre oggetto di supporto
    vettore aux(v1._size()+v2._size());                                           // mi serve un indice per entrambi
    int i=0,sec=0;
    for(i; i<v1._size(); ++i) aux[i]=v1[i];
    for(i; i<aux._size(); ++i){
        aux[i]=v2[sec];
        sec++;
    }
    return aux;
}
void vettore::append(const vettore& v){               //domanda magari stupida, ma se io dereferenzio *this ottengo l'oggetto di invocazione perch* this è un puntatore a calsse o tipo giusto ?
    *this=*this+v;
}
bool vettore::operator==(const vettore& v)const{      // da chidere perché *this == v.punt non va bene e perché *this.punt == v.punt non va bene
    if(this == &v) return true;
    if(this->size != v._size()) return false;
    for(int i=0; i<this->size; ++i){
        if(this->punt[i] != v[i]) return false;                  // perché con v[i] okay e con *this[i] non funge ? okay basta aggiungere le parentesi bha
    }
    return true;
}
vettore& vettore::operator=(const vettore& v){
    if(this != &v){
        delete[] punt;
        punt = v._size() == 0 ? nullptr : new int[v._size()];
        size=v._size();
        for(int i=0; i<v._size(); ++i){
            this->punt[i] = v[i];
        }
    }
    return *this;                                                   // perché devo ritornare *this e non semplicemente this?
}
int main() {
  vettore v1(1), v2(3), v3(2,1);
  v1 = v2+v3;
  v2.append(v1);
  v3.append(v1);
  cout << v1 <<" v1"<<endl;
  cout << v2 <<" v2"<<endl;
  cout << v3 <<" v3" <<endl;
}