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

User Tools

Site Tools

Trace:
cpp:vector_overloading_binary_operators2

Differences

This shows you the differences between two versions of the page.

Link to this comparison view

Next revision		Previous revision
cpp:vector_overloading_binary_operators2 [2017/05/05 12:57] – created gthanoscpp:vector_overloading_binary_operators2 [Unknown date] (current) – external edit (Unknown date) 127.0.0.1
Line 1: Line 1:
-===== Υπερφόρτωση δυαδικών τελεστών που δεν μεταβάλλουν τον αριστερό τελεστέο =====+===== Υπερφόρτωση δυαδικών τελεστών μπορούν να υλοποιηθούν μόνο ως μέλη της κλάσης =====
  
-Παρακάτω θα δούμε την υπερφόρτωση τελεστών που δεν μεταβάλλουν τον αριστερό τελεστέο. Οι τελεστές περιγράφονται στον παρακάτω πίνακα.+Σε αυτή την ενότητα, θα δούμε παραδείγματα υπερφόρτωσης, τα οποία μεταβάλλουν τον αριστερό τελεστέο και μπορούν να υλοποιηθού __μόνο ως μέλη της κλάσης__. 
 +  
 +^  Τελεστής  ^  Αριστερός τελεστέος  ^  Δεξιός τελεστέος  ^  Περιγραφή (//>σε όλες τις συναρτήσεις υπερφόρτωσης επιστρέφεται μία αναφορά στον αριστερό τελεστέο//)  ^ 
 +|  %%=%%  |  //Vector//  |  //Vector//  | Ο αριστερός τελεστέος γίνεται ίσος με τον δεξιό τελεστέο. Επιστρέφεται μία αναφορά στο τρέχον αντικείμενο. | 
 +|  %%[ ]%%  |  //Vector//  |  //int//  | Επιστρέφει μία αναφορά στο **i**-στο στοιχείο του //Vector//, **i** η θέση που προσδιορίζεται από τον δεξιό τελεστή. | 
 +|  %%+=%%  |  //Vector//  |  //Vector//  | Σε κάθε στοιχείο του αριστερού τελεστέου προστίθεται το αντίστοιχο στοιχείο του δεξιού τελεστέου. Επιστρέφεται μία αναφορά στο τρέχον αντικείμενο.  | 
 +|  %%+=%%  |  //Vector//  |  //int//  | Σε κάθε στοιχείο του αριστερού τελεστέου προστίθεται ο δεξιός τελεστέος | 
 +|  %%-=%%  |  //Vector//  |  //Vector//  | Σε κάθε στοιχείο του αριστερού τελεστέου αφαιρείται το αντίστοιχο στοιχείο του δεξιού τελεστέου. Επιστρέφεται μία αναφορά στο τρέχον αντικείμενο.  | 
 +|  %%-=%%  |  //Vector//  |  //int//  | Σε κάθε στοιχείο του αριστερού τελεστέου αφαιρείται ο δεξιός τελεστέος. Επιστρέφεται μία αναφορά στο τρέχον αντικείμενο. | 
 +|  %%*=%%  |  //Vector//  |  //Vector//  | Κάθε στοιχείο του αριστερού τελεστέου πολλαπλασιάζεται με το αντίστοιχο στοιχείο του δεξιού τελεστέου και το αποτέλεσμα αποθηκεύεται στο στοιχείο του αριστερού τελεστέου. Επιστρέφεται μία αναφορά στο τρέχον αντικείμενο. | 
 +|  %%*=%%  |  //Vector//  |  //int//  | Κάθε στοιχείο του αριστερού τελεστέου πολλαπλασιάζεται με τον δεξιό τελεστέο και το αποτέλεσμα αποθηκεύεται στο στοιχείο του αριστερού τελεστέου. Επιστρέφεται μία αναφορά στο τρέχον αντικείμενο.| 
 +|  %%/=%%  |  //Vector//  |  //int//  | Κάθε στοιχείο του αριστερού τελεστέου διαιρείται με τον δεξιό τελεστέο και το αποτέλεσμα της ακέραιας διαίρεσης αποθηκεύεται στο στοιχείο του αριστερού τελεστέου. Επιστρέφεται μία αναφορά στο τρέχον αντικείμενο. | 
 +|  %% %=%%  |  //Vector//  |  //int//  | Κάθε στοιχείο του αριστερού τελεστέου διαιρείται με τον δεξιό τελεστέο και το υπόλοιπο της ακέραιας διαίρεσης αποθηκεύεται στο στοιχείο του αριστερού τελεστέου. Επιστρέφεται μία αναφορά στο τρέχον αντικείμενο. | 
 +|  %%<<=%%  |  //Vector//  |  //int//  | Τα στοιχεία του αριστερού τελεστέου ολισθένουν αριστερά κατά τόσα bits όσα προσδιορίζει ο δεξιός τελεστέος. Επιστρέφεται μία αναφορά στο τρέχον αντικείμενο. | 
 +|  %%>>=%%  |  //Vector//  |  //int//  | Τα στοιχεία του αριστερού τελεστέου ολισθένουν δεξιά κατά τόσα bits όσα προσδιορίζει ο δεξιός τελεστέος. Επιστρέφεται μία αναφορά στο τρέχον αντικείμενο.|
  
-^  Τελεστής  ^  Αριστερός τελεστέος  ^  Δεξιός τελεστέος  ^ Περιγραφή  ^  Φιλική μέθοδος  ^ +<code cpp Vector.hpp>
-|  %%+%%  |  //Vector//  |  //Vector//  | Επιστρέφει ένα νέο αντικείμενο τύπου //Vector// που κάθε στοιχείο του προκύπτει από το άθροισμα των στοιχείων των δύο τελεστεών τύπου //Vector// |  και τα δύο (η φιλική συνάρτηση σε σχόλια)  | +
-|  %%-%%  |  //Vector//  |  //Vector//  | Επιστρέφει ένα νέο αντικείμενο τύπου //Vector// που κάθε στοιχείο του προκύπτει από τη διαφορά των στοιχείων των δύο τελεστεών τύπου //Vector//  |  Όχι  | +
-|  %%+%%  |  //Vector//  |  //int//  | Επιστρέφει ένα νέο αντικείμενο τύπου //Vector// που κάθε στοιχείο του προκύπτει από το άθροισμα του αντίστοιχου στοιχείου του //Vector// με τον ακέραιο |  Όχι  | +
-|  %%+%%  |  //int//  |  //Vector//  | Επιστρέφει ένα νέο αντικείμενο τύπου //Vector// που κάθε στοιχείο του προκύπτει από το άθροισμα του αντίστοιχου στοιχείου του //Vector// με τον ακέραιο |  Ναι  | +
-|  %%-%%  |  //Vector//  |  //int//  | Επιστρέφει ένα νέο αντικείμενο τύπου //Vector// που κάθε στοιχείο του προκύπτει από τη διαφορά του αντίστοιχου στοιχείου του //Vector// με τον ακέραιο |  Όχι  | +
-|  %%*%%  |  //Vector//  |  //int//  | Επιστρέφει ένα νέο αντικείμενο τύπου //Vector// που κάθε στοιχείο του προκύπτει από το γινόμενο του αντίστοιχου στοιχείου του //Vector// με τον ακέραιο |  Όχι  | +
-|  %%*%%  |  //int//  |  //Vector//  | Επιστρέφει ένα νέο αντικείμενο τύπου //Vector// που κάθε στοιχείο του προκύπτει από το γινόμενο του αντίστοιχου στοιχείου του //Vector// με τον ακέραιο |  Ναι  | +
-|  %%/%%  |  //Vector//  |  //int//  | Επιστρέφει ένα νέο αντικείμενο τύπου //Vector// που κάθε στοιχείο του προκύπτει από την ακέραια διαίρεση του αντίστοιχου στοιχείου του //Vector// με τον ακέραιο |  Όχι  | +
-|  %  |  //Vector//  |  //int//  | Επιστρέφει ένα νέο αντικείμενο τύπου //Vector// που κάθε στοιχείο του προκύπτει από το υπόλοιπο της ακέραιας διαίρεσης του αντίστοιχου στοιχείου του //Vector// με τον ακέραιο |  Όχι  | +
-|  %%<<%%  |  //Vector//  |  //int//  | Επιστρέφει ένα νέο αντικείμενο τύπου //Vector// στο οποίο έχει προστεθεί ο δεξιός τελεστέος. Το νέο αντικείμενο έχει μέγεθος κατά ένα μεγαλύτερο του αριστερού τελεστέου. |  και τα δύο (η φιλική συνάρτηση σε σχόλια)  | +
-|  %%>>%%  |  //Vector//  |  //int//  | Επιστρέφει ένα νέο αντικείμενο τύπου //Vector// στο οποίο έχει διαγραφεί ο δεξιός τελεστέος, εφόσον αυτός υπάρχει. Το νέο αντικείμενο έχει μέγεθος κατά ένα μικρότερο του αριστερού τελεστέου, εάν βρεθεί ο δεξιός τελεστέος μέσα στο //Vector//. Εάν δεν βρεθεί επιστρέφεται ένα αντικείμενο που περιέχει τα στοιχεία του αριστερού τελεστέου. |  και τα δύο (η φιλική συνάρτηση σε σχόλια)  | +
- +
-<WRAP center round info 80%> +
-Όταν έχετε μία φιλική μέθοδο και ένα μέλος της κλάσης που υλοποιούν την ίδια λειτουργικότητα υπερφόρτωσης, κατά τη χρήση του αντίστοιχου τελεστή χρησιμοποιείται (//υπερισχύει//) η συνάρτηση μέλος της κλάσης. +
-</WRAP> +
- +
- +
- +
-<code cpp Vector.cpp>+
 #include <iostream> #include <iostream>
 #include <string> #include <string>
 #include <cstdlib> #include <cstdlib>
 using namespace std; using namespace std;
 +
 +#ifndef _VECTOR_HPP_
 +#define _VECTOR_HPP_
  
 class Vector { class Vector {
   int *array;   int *array;
-  unsigned int size;+  int size;
      
 public: public:
-  Vector(unsigned int length=0); +  Vector(int length=0); 
-  Vector(const Vector &v);+  Vector(const Vector& v);
   Vector(const Vector *v);   Vector(const Vector *v);
   ~Vector();   ~Vector();
-  unsigned int length() const;           // return Vector's length. +  int length() const;           // return Vector's length. 
-  int &valueAt(unsigned int pos) const;  // return a reference to element at position pos+  int &valueAt(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    int find(int a) const;      // check if a exists in Vector. Return it position >0 or -1 
                               // if not element not found                               // if not element not found
Line 44: Line 42:
   void print() const;           // print vector values to standard output   void print() const;           // print vector values to standard output
   void print(string &msg) 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 */   /* binary operators that don't modify left operand */
-  void operator=(const Vector &v); +  Vector operator+(const Vector& v) const; 
-  Vector operator+(const Vector &v) const; +  Vector operator-(const Vector& v) const; 
-  //friend Vector operator+(const Vector &v1, const Vector v2); +  Vector operator*(Vector& v) const;
-  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; +  /* binary operators that modify left operand */ 
-  //friend Vector operator<<(const Vector &v, int a); +  Vector& operator=(const Vector& v); 
-  Vector operator >> (int a) const; +  Vector& operator+=(const Vector& v); 
-  //friend Vector operator>>(const Vector &v, int a);+  Vector& operator+=(int a); 
 +  Vector& operator-=(const Vector& v); 
 +  Vector& operator-=(int a); 
 +  Vector& operator*=(const Vector& v); 
 +  Vector& operator*=(int a); 
 +  Vector& operator/=(int a); 
 +  Vector& operator%=(int a); 
 +  Vector& operator<<=(int a); 
 +  Vector& operator>>=(int a); 
 +  int &operator[](int a) const;
      
 }; };
  
-Vector::Vector(unsigned int length) {+#endif 
 +</code> 
 + 
 +<code cpp Vector.cpp> 
 +#include "Vector.hpp" 
 + 
 +Vector::Vector(int length) {
   size = length;   size = length;
   array = new (nothrow) int[size];   array = new (nothrow) int[size];
Line 76: Line 81:
 } }
  
-Vector::Vector(const Vector &v) {+Vector::Vector(const Vector& v) {
   size = v.length();   size = v.length();
   array = new (nothrow) int[size];   array = new (nothrow) int[size];
Line 102: Line 107:
 } }
  
-unsigned int Vector::length() const { +int Vector::length() const { 
   return size;    return size; 
 } }
  
-int &Vector::valueAt(unsigned int pos) const {+int &Vector::valueAt(int pos) const {
   if(pos>=length()) {   if(pos>=length()) {
      cerr << "Invalid access position!\n";      cerr << "Invalid access position!\n";
Line 142: Line 147:
 } }
  
-void Vector::operator=(const Vector &v) {+Vector& Vector::operator=(const Vector& v) {
   if(array!=NULL)   if(array!=NULL)
     delete [] array;     delete [] array;
Line 152: Line 157:
   }   }
   for(int i=0; i<size; i++)   for(int i=0; i<size; i++)
-    array[i] = v.valueAt(i);  +    array[i] = v.valueAt(i); 
 +  return *this;
 } }
  
-Vector Vector::operator+(const Vector &v) const {+Vector Vector::operator+(const Vector& v) const {
   int length;   int length;
   if (size > v.length())   if (size > v.length())
Line 173: Line 179:
 } }
  
-/* +Vector Vector::operator-(const Vector& v) const {
-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;   int length;
   if (size > v.length())   if (size > v.length())
Line 210: Line 197:
 } }
  
-Vector Vector::operator+(int a) const { +Vector& Vector::operator+=(const Vector& v) { 
-  Vector n(size);+  if(v.length() > size) { 
 +    Vector n(v); 
 +    n = n + *this; 
 +    *this = n; 
 +  } 
 +  else { 
 +    *this = *this + v; 
 +  } 
 +  return *this; 
 +} 
 + 
 +Vector& Vector::operator+=(int a) {
   for(int i=0; i<size; i++)   for(int i=0; i<size; i++)
-    n.array[i] = array[i] + a; +    array[i] += a; 
-  return n;+  return *this;
 } }
  
-Vector operator+(int a, const Vector &v) { +Vector& Vector::operator-=(const Vector& v) { 
-  Vector n(v); +  if(v.length() > size) { 
-  for(int i=0; i<v.length(); i++) { +    Vector n(v); 
-    n.array[i] += a;+    n = n - *this; 
 +    *this = n;
   }   }
-  return n;+  else { 
 +    *this = *this - v; 
 +  } 
 +  return *this;
 } }
  
-Vector Vector::operator-(int a) const { +Vector& Vector::operator-=(int a) {
-  Vector n(size);+
   for(int i=0; i<size; i++)   for(int i=0; i<size; i++)
-    n.array[i] = array[i] - a; +    array[i] -= a; 
-  return n;+  return *this;
 } }
  
-Vector Vector::operator*(int a) const { +Vector& Vector::operator*=(const Vector& v) { 
-  Vector n(size);+  if( v.size != size ) 
 +    return *this; 
 +  
   for(int i=0; i<size; i++)   for(int i=0; i<size; i++)
-    n.array[i] = array[i] * a; +    array[i] *= v.array[i];   
-  return n;+  return *this;
 } }
  
-Vector operator*(int a, const Vector &v) { +Vector& Vector::operator*=(int a) { 
-  Vector n(v); +  for(int i=0; i<size; i++) 
-  for(int i=0; i<v.length(); i++) { +    array[i] *= a; 
-    n.array[i] *= a; +  return *this;
-  } +
-  return n;+
 } }
  
-Vector Vector::operator/(int a) const { +Vector& Vector::operator/=(int a) {
-  Vector n(size);+
   for(int i=0; i<size; i++)   for(int i=0; i<size; i++)
-    n.array[i] = array[i] / a; +    array[i] /= a; 
-  return n;+  return *this;
 } }
  
-Vector Vector::operator%(int a) const { +Vector& Vector::operator%=(int a) {
-  Vector n(size);+
   for(int i=0; i<size; i++)   for(int i=0; i<size; i++)
-    n.array[i] = array[i] % a; +    array[i] %= a; 
-  return n;+  return *this;
 } }
-/* 
-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& Vector::operator<<=(int a) { 
-  Vector n(*this); +  for(int i=0; i<size; i++) 
-  int *array_new = new (nothrow) int [n.size+1]; +    array[i] <<= a; 
-  if(array_new==NULL) { +  return *this;
-    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) { +Vector& Vector::operator>>=(int a) { 
-  int pos = v.find(a); +  for(int i=0; i<size; i++) 
-  if(pos<0) +    array[i] >>= a; 
-    return v; +  return *this; 
-  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 &Vector::operator[](int pos) const { 
-  int pos = find(a); +  return array[pos];
-  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;+
 } }
 +</code>
  
 +<code cpp VectorUsage.cpp>
 +#include "Vector.hpp"
  
 int main() { int main() {
Line 350: Line 288:
   v.print(msg);   v.print(msg);
      
-  Vector f = v; +  Vector f , g; 
-  v.print(msg="Vector f:  "); +  f = g = v; 
-  Vector k; +  f.print(msg="Vector f:  "); 
-  k = f + v; +  g.print(msg="Vector g:  "); 
-  k.print(msg="f + v:  "); +   
-  k = f - v; +  g = f += v; 
-  k.print(msg="f - v:  "); +  g.print(msg="g = f += v:  ");   
-  k = f + 2; +   
-  k.print(msg="f + 2:  "); +  f -= v; 
-  k = f - 2; +  f.print(msg="f -= v:  "); 
-  k.print(msg="f - 2:  "); +  f *= v; 
-  k = f * 2; +  f.print(msg="f *= v:  "); 
-  k.print(msg="f * 2:  "); +   
-  k = f / 2; +  f = v;   
-  k.print(msg="f / 2:  "); +  f += 2; 
-  k = f % 2; +  f.print(msg="f += 2:  "); 
-  k.print(msg="f % 2:  "); +  f -= 2; 
-  f = f << 7; +  f.print(msg="f -= 2:  "); 
-  f.print(msg="f = f << 7:  "); +  f *= 2; 
-  f = f << 7; +  f.print(msg="f *= 2:  "); 
-  f.print(msg="f = f << 7:  "); +  f /= 2; 
-  f = f >> 6; +  f.print(msg="f /= 2:  "); 
-  f.print(msg="f = f >> 6:  "); +  f %= 2; 
-  f = f >> 6; +  f.print(msg="f %= 2:  ");
-  f.print(msg="f = f >> 6:  ");+
      
 +  cout << "v[2]:  " << v[2] << endl;
 +  v[2] = 100;
 +  v.print(msg="[v[2] = 100] v:  ");  
 } }
 </code> </code>
  
  
cpp/vector_overloading_binary_operators2.1493989025.txt.gz · Last modified: 2017/05/05 11:57 (external edit)