Αντικειμενοστραφής Προγραμματισμός

Παρακάτω θα δούμε την υπερφόρτωση τελεστών που δεν μεταβάλλουν τον αριστερό τελεστέο. Οι τελεστές περιγράφονται στον παρακάτω πίνακα.

Vector.cpp

#include <iostream>
#include <string>
#include <cstdlib>
using namespace std;
 
class Vector {
  int *array;
  unsigned int size;
 
public:
  Vector(unsigned int length=0);
  Vector(const Vector &v);
  Vector(const Vector *v);
  ~Vector();
  unsigned int length() const;           // return Vector's length.
  int &valueAt(unsigned int pos) const;  // return a reference to element at position pos
  int find(int a) const;      // check if a exists in Vector. Return it position >0 or -1 
                              // if not element not found
 
  void print() const;           // print vector values to standard output
  void print(string &msg) const;  // print vector values to standard output
 
  /* binary operators that don't modify left operand */
  void operator=(const Vector &v);
  Vector operator+(const Vector &v) const;
  //friend Vector operator+(const Vector &v1, const Vector v2);
  Vector operator-(const Vector &v) const;
  Vector operator+(int a) const;
  friend Vector operator+(int a, const Vector &v);
  Vector operator-(int a) const;
  Vector operator*(int a) const;
  friend Vector operator*(int a, const Vector &v);
  Vector operator/(int a) const;
  Vector operator%(int a) const;
 
  Vector operator << (int a) const;
  //friend Vector operator<<(const Vector &v, int a);
  Vector operator >> (int a) const;
  //friend Vector operator>>(const Vector &v, int a);
 
};
 
Vector::Vector(unsigned int length) {
  size = length;
  array = new (nothrow) int[size];
  if(array==NULL) {
    cerr << "Memory allocation failure!" << endl;
    exit(-1);
  }
  for(int i=0; i<size; i++)
    array[i] = 0;
}
 
Vector::Vector(const Vector &v) {
  size = v.length();
  array = new (nothrow) int[size];
  if(array==NULL) {
    cerr << "Memory allocation failure!" << endl;
    exit(-1);
  }
  for(int i=0; i<size; i++)
    array[i] = v.valueAt(i);
}
 
Vector::Vector(const Vector *v) {
  size = v->length();
  array = new (nothrow) int[size];
  if(array==NULL) {
    cerr << "Memory allocation failure!" << endl;
    exit(-1);
  }
  for(int i=0; i<size; i++)
    array[i] = v->valueAt(i);
}
 
Vector::~Vector() {
  delete [] array;
}
 
unsigned int Vector::length() const { 
  return size; 
}
 
int &Vector::valueAt(unsigned int pos) const {
  if(pos>=length()) {
     cerr << "Invalid access position!\n";
     return array[size-1];
  }
  return array[pos];
}
 
int Vector::find(int a) const {
  for(int i=0; i<size; i++)
    if(array[i] == a)
      return i;
    return -1;
}
 
void Vector::print() const {
  for(int i=0; i<size; i++) {
    cout << array[i];
    if(i==size-1)
      cout << endl;
    else
      cout << ", ";
  }
}
 
void Vector::print(string &msg) const {
  cout << msg;
  for(int i=0; i<size; i++) {
    cout << array[i];
    if(i==size-1)
      cout << endl;
    else
      cout << ", ";
  }
}
 
void Vector::operator=(const Vector &v) {
  if(array!=NULL)
    delete [] array;
  size = v.length();
  array = new (nothrow) int[size];
  if(array==NULL) {
    cerr << "Memory allocation failure!" << endl;
    exit(-1);
  }
  for(int i=0; i<size; i++)
    array[i] = v.valueAt(i);  
}
 
Vector Vector::operator+(const Vector &v) const {
  int length;
  if (size > v.length())
    length = size;
  else
    length = v.length();
  Vector n(length);
  for(int i=0; i<length; i++) {
    int sum = 0;
    if(i<size)
      sum += array[i];
    if(i<v.length())
      sum += v.array[i];
    n.array[i] = sum;
  }
  return n;
}
 
/*
Vector operator+(const Vector &v1, const Vector v2) {
  int length;
  if (v1.size > v2.size)
    length = v1.length();
  else
    length = v2.length();
  Vector n(length);
  for(int i=0; i<length; i++) {
    int sum = 0;
    if(i<v1.length())
      sum += v1.array[i];
    if(i<v2.length())
      sum += v2.array[i];
    n.array[i] = sum;
  }
  return n;
}*/
 
Vector Vector::operator-(const Vector &v) const {
  int length;
  if (size > v.length())
    length = size;
  else
    length = v.length();
  Vector n(length);
  for(int i=0; i<length; i++) {
    int sum = 0;
    if(i<size)
      sum += array[i];
    if(i<v.length())
      sum -= v.array[i];
    n.array[i] = sum;
  }
  return n;
}
 
Vector Vector::operator+(int a) const {
  Vector n(size);
  for(int i=0; i<size; i++)
    n.array[i] = array[i] + a;
  return n;
}
 
Vector operator+(int a, const Vector &v) {
  Vector n(v);
  for(int i=0; i<v.length(); i++) {
    n.array[i] += a;
  }
  return n;
}
 
Vector Vector::operator-(int a) const {
  Vector n(size);
  for(int i=0; i<size; i++)
    n.array[i] = array[i] - a;
  return n;
}
 
Vector Vector::operator*(int a) const {
  Vector n(size);
  for(int i=0; i<size; i++)
    n.array[i] = array[i] * a;
  return n;
}
 
Vector operator*(int a, const Vector &v) {
  Vector n(v);
  for(int i=0; i<v.length(); i++) {
    n.array[i] *= a;
  }
  return n;
}
 
Vector Vector::operator/(int a) const {
  Vector n(size);
  for(int i=0; i<size; i++)
    n.array[i] = array[i] / a;
  return n;
}
 
Vector Vector::operator%(int a) const {
  Vector n(size);
  for(int i=0; i<size; i++)
    n.array[i] = array[i] % a;
  return n;
}
/*
Vector operator<<(const Vector &v, int a){
  Vector n(v);
  int *array_new = new (nothrow) int [n.size+1];
  if(array_new==NULL) {
    cerr << "Memory allocation failure in operator<< !" << endl;
    exit(-1);
  }
  for(int i=0; i<n.size; i++)
    array_new[i] = n.array[i];
  array_new[n.size] = a;
  n.size++;
  delete [] n.array;
  n.array = array_new;
  return n;
}*/
 
Vector Vector::operator << (int a) const {
  Vector n(*this);
  int *array_new = new (nothrow) int [n.size+1];
  if(array_new==NULL) {
    cerr << "Memory allocation failure in operator<< !" << endl;
    exit(-1);
  }
  for(int i=0; i<n.size; i++)
    array_new[i] = n.array[i];
  array_new[n.size] = a;
  n.size++;
  delete [] n.array;
  n.array = array_new;
  return n;
}
 
/*Vector operator>>(const Vector &v, int a) {
  int pos = v.find(a);
  if(pos<0)
    return v;
  Vector n(v);
  int *array_new = new (nothrow) int [n.size-1];
  if(array_new==NULL) {
    cerr << "Memory allocation failure in operator<< !" << endl;
    exit(-1);
  }
  for(int i=0; i<n.size; i++) {
    if(i<pos)
      array_new[i] = n.array[i];
    if(i==pos)
      continue;
    if(i>pos)
      array_new[i-1] = n.array[i];
  }  
  n.size--;
  delete [] n.array;
  n.array = array_new;
  return n;
}*/
 
Vector Vector::operator >> (int a) const {
  int pos = find(a);
  if(pos<0)
    return *this;
  Vector n(*this);
  int *array_new = new (nothrow) int [n.size-1];
  if(array_new==NULL) {
    cerr << "Memory allocation failure in operator<< !" << endl;
    exit(-1);
  }
  for(int i=0; i<n.size; i++) {
    if(i<pos)
      array_new[i] = n.array[i];
    if(i==pos)
      continue;
    if(i>pos)
      array_new[i-1] = n.array[i];
  }  
  n.size--;
  delete [] n.array;
  n.array = array_new;
  return n;
}
 
 
int main() {
  Vector v(5);
  v.valueAt(0) = 2;  v.valueAt(1) = 3;
  v.valueAt(2) = 4;  v.valueAt(3) = 5;  v.valueAt(4) = 6;
 
  string msg = "Vector v:  ";  
  v.print(msg);
 
  Vector f = v;
  v.print(msg="Vector f:  ");
  Vector k;
  k = f + v;
  k.print(msg="f + v:  ");
  k = f - v;
  k.print(msg="f - v:  ");
  k = f + 2;
  k.print(msg="f + 2:  ");
  k = f - 2;
  k.print(msg="f - 2:  ");
  k = f * 2;
  k.print(msg="f * 2:  ");
  k = f / 2;
  k.print(msg="f / 2:  ");
  k = f % 2;
  k.print(msg="f % 2:  ");
  f = f << 7;
  f.print(msg="f = f << 7:  ");
  f = f << 7;
  f.print(msg="f = f << 7:  ");
  f = f >> 6;
  f.print(msg="f = f >> 6:  ");
  f = f >> 6;
  f.print(msg="f = f >> 6:  ");
 
}