L3 --- TP4 --- POO

# include <stdlib.h>
# include <assert.h>
# include "vector.hpp"

using namespace std ;

Vector::Vector() {
    this->size = 0;
    this->element = NULL;
}

Vector::Vector(unsigned int const _size) {
    (*this).size = _size;
    element = new float[(*this).size]();
    /* () Permet d'initialiser les valeurs à 0 ; équivalent à :
    for(unsigned int i = 0 ; i < (*this).size; ++i)
      this->element[i] = 0;*/
}

/* Constructeur par recopie */
Vector::Vector(const Vector &v) {
    this->size = v.size;
    this->element = new float[this->size];
    for(unsigned int i = 0; i < v.size; ++i)
        this->element[i] = v[i];
}

Vector::~Vector() {
    // Marche -normalement- si element == NULL
    delete[] element;
}

void Vector::init_alea() {
    for (unsigned int i = 0 ; i < size ; i++) {
        element[ i ] = drand48 () ;
    }
}

/* Référence sur l'élément à la position i */
float & Vector::operator[] (unsigned int const i) {
    assert(i < size);
    return element[i];
}

float const & Vector::operator[] (unsigned int const i) const {
    assert(i < size);
    return element[i];
}

Vector & Vector::operator= (Vector const & v) {
    std::cout << "Operateur =" << std::endl;
    /* Réallocation mémoire nécessaire si nombre d'éléments différent */
    if(this->size != v.size) {
        delete [] element;
        (*this).size = v.size;
        (*this).element = new float[v.size];
    }
    for(unsigned int i = 0; i < v.size; ++i)
        (*this).element[i] = v[i];
    return (* this) ;
}

Vector Vector::operator+ (Vector const & v) const {
    std::cout << "Operateur +" << std::endl;
    Vector somme(v.size);
    for(unsigned int i = 0; i < v.size; ++i)
        somme.element[i] = v[i] + (*this).element[i];
    return somme;
}

Vector Vector::operator- (Vector const & v) const {
    std::cout << "Operateur -" << std::endl;
    Vector soustraction(v.size);
    for(unsigned int i = 0; i < v.size; ++i)
        soustraction.element[i] = v[i] - (*this).element[i];
    return soustraction;
}

Vector Vector::operator* (float const a) const {
    // Appel au constructeur par recopie
    Vector produit((*this));
    for(unsigned int i = 0; i < size; i++)
        produit.element[i] *= a;
    return produit ;
}

float Vector::operator| (Vector const & v) const {
    float sum = 0 ;
    for (unsigned int i = 0 ; i < size ; i ++) {
        // (*this)[i] valable grâce à la surcharge d'opérateur
        sum += (*this)[i] * v[i] ;
    }
    return sum ;
}

bool Vector::operator== (Vector const & v) const {
    for (unsigned int i = 0 ; i < size ; i ++) {
        if ((*this)[i] != v[i]) {
            return false ;
        }
    }
    return true ;
}

/* Méthodes non-membres de la classe Vector */
Vector operator* (float const a, Vector const & v) {
    // return v.operator*(a);
    return v*a;
}

/* Méthode amie */
std::ostream & operator<< (std::ostream& ost, Vector const & v) {
    ost.precision(10);
    ost << "(";
    /* size est accessible car méthode amie/friend */
    for(unsigned int i = 0; i < v.size-1; ++i)
        ost << v[i] << ", ";
    /* Gestion particulière pour le dernier élément */
    ost << v[v.size-1] << ")" << std::endl;
    return ost ;
}