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

User Tools

Site Tools

Trace:
cpp:vector_overloading_binary_operators

Differences

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

Link to this comparison view

Both sides previous revisionPrevious revision
Next revision		Previous revision
cpp:vector_overloading_binary_operators [2017/05/05 13:09] – gthanoscpp:vector_overloading_binary_operators [Unknown date] (current) – external edit (Unknown date) 127.0.0.1
Line 1: Line 1:
-===== Υπερφόρτωση δυαδικών τελεστών που δεν μεταβάλλουν τον αριστερό τελεστέο (binary operators overloading) =====+===== Υπερφόρτωση δυαδικών τελεστών που μπορούν να υλοποιηθούν ως μέλη της κλάσης ή ως φιλικές συναρτήσεις =====
  
-Παρακάτω θα δούμε την υπερφόρτωση τελεστών που δεν μεταβάλλουν τον αριστερό τελεστέο. Οι τελεστές περιγράφονται στον παρακάτω πίνακα.+Ο παρακάτω πίνακας περιγράφει τη λειτουργία της υπερφόρτωσης των τελεστών για το παράδειγμα της κλάσης //Vector// που ακολουθεί. Σε αυτή την ενότητα, θα δούμε παραδείγματα υπερφόρτωσης, τα οποία δεν μεταβάλλουν τον αριστερό τελεστέο. 
  
 ^  Τελεστής  ^  Αριστερός τελεστέος  ^  Δεξιός τελεστέος  ^ Περιγραφή  ^  Φιλική μέθοδος  ^ ^  Τελεστής  ^  Αριστερός τελεστέος  ^  Δεξιός τελεστέος  ^ Περιγραφή  ^  Φιλική μέθοδος  ^
-|  %%+%%  |  //Vector//  |  //Vector//  | Επιστρέφει ένα νέο αντικείμενο τύπου //Vector// που κάθε στοιχείο του προκύπτει από το άθροισμα των στοιχείων των δύο τελεστεών τύπου //Vector// |  και τα δύο (η φιλική συνάρτηση σε σχόλια)  | +|  %%+%%  |  //Vector//  |  //Vector//  | Επιστρέφει ένα νέο αντικείμενο τύπου //Vector// που κάθε στοιχείο του προκύπτει από το άθροισμα των στοιχείων των δύο τελεστέων τύπου //Vector// στην αντίστοιχη θέση  |  και τα δύο (η φιλική συνάρτηση σε σχόλια)  | 
-|  %%-%%  |  //Vector//  |  //Vector//  | Επιστρέφει ένα νέο αντικείμενο τύπου //Vector// που κάθε στοιχείο του προκύπτει από τη διαφορά των στοιχείων των δύο τελεστεών τύπου //Vector//  |  Όχι  | +|  %%-%%  |  //Vector//  |  //Vector//  | Επιστρέφει ένα νέο αντικείμενο τύπου //Vector// που κάθε στοιχείο του προκύπτει από τη διαφορά των στοιχείων των δύο τελεστεών τύπου //Vector// στην αντίστοιχη θέση  |  Όχι  | 
-|  %%+%%  |  //Vector//  |  //int//  | Επιστρέφει ένα νέο αντικείμενο τύπου //Vector// που κάθε στοιχείο του προκύπτει από το άθροισμα του αντίστοιχου στοιχείου του //Vector// με τον ακέραιο |  Όχι  |+|  %%*%%  |  //Vector//  |  //Vector//  | Επιστρέφει ένα νέο αντικείμενο τύπου //Vector// που κάθε στοιχείο του προκύπτει από το γινόμενο των στοιχείων των δύο τελεστεών τύπου //Vector// στην αντίστοιχη θέση  |  Όχι  | 
 +|  %%+%%  |  //Vector//  |  //int//  | Επιστρέφει ένα νέο αντικείμενο τύπου //Vector// που κάθε στοιχείο του προκύπτει από το άθροισμα του αντίστοιχου στοιχείου του //Vector// με τον ακέραιο |  Ναι  |
 |  %%+%%  |  //int//  |  //Vector//  | Επιστρέφει ένα νέο αντικείμενο τύπου //Vector// που κάθε στοιχείο του προκύπτει από το άθροισμα του αντίστοιχου στοιχείου του //Vector// με τον ακέραιο |  Ναι  | |  %%+%%  |  //int//  |  //Vector//  | Επιστρέφει ένα νέο αντικείμενο τύπου //Vector// που κάθε στοιχείο του προκύπτει από το άθροισμα του αντίστοιχου στοιχείου του //Vector// με τον ακέραιο |  Ναι  |
 |  %%-%%  |  //Vector//  |  //int//  | Επιστρέφει ένα νέο αντικείμενο τύπου //Vector// που κάθε στοιχείο του προκύπτει από τη διαφορά του αντίστοιχου στοιχείου του //Vector// με τον ακέραιο |  Όχι  | |  %%-%%  |  //Vector//  |  //int//  | Επιστρέφει ένα νέο αντικείμενο τύπου //Vector// που κάθε στοιχείο του προκύπτει από τη διαφορά του αντίστοιχου στοιχείου του //Vector// με τον ακέραιο |  Όχι  |
Line 13: Line 14:
 |  %%/%%  |  //Vector//  |  //int//  | Επιστρέφει ένα νέο αντικείμενο τύπου //Vector// που κάθε στοιχείο του προκύπτει από την ακέραια διαίρεση του αντίστοιχου στοιχείου του //Vector// με τον ακέραιο |  Όχι  | |  %%/%%  |  //Vector//  |  //int//  | Επιστρέφει ένα νέο αντικείμενο τύπου //Vector// που κάθε στοιχείο του προκύπτει από την ακέραια διαίρεση του αντίστοιχου στοιχείου του //Vector// με τον ακέραιο |  Όχι  |
 |  %  |  //Vector//  |  //int//  | Επιστρέφει ένα νέο αντικείμενο τύπου //Vector// που κάθε στοιχείο του προκύπτει από το υπόλοιπο της ακέραιας διαίρεσης του αντίστοιχου στοιχείου του //Vector// με τον ακέραιο |  Όχι  | |  %  |  //Vector//  |  //int//  | Επιστρέφει ένα νέο αντικείμενο τύπου //Vector// που κάθε στοιχείο του προκύπτει από το υπόλοιπο της ακέραιας διαίρεσης του αντίστοιχου στοιχείου του //Vector// με τον ακέραιο |  Όχι  |
-|  %%<<%%  |  //Vector//  |  //int//  | Επιστρέφει ένα νέο αντικείμενο τύπου //Vector// στο οποίο έχει προστεθεί ο δεξιός τελεστέος. Το νέο αντικείμενο έχει μέγεθος κατά ένα μεγαλύτερο του αριστερού τελεστέου. |  και τα δύο (η φιλική συνάρτηση σε σχόλια)  | +|  %%<<%%  |  //Vector//  |  //int//  | Επιστρέφει ένα νέο αντικείμενο τύπου //Vector//, το οποίο προκύπτει από τον αριστερό τελεστέο εάν ολισθήσουμε όλα τα στοιχεία του αριστερά κατά τόσα bits όσα προσδιορίζει ο δεξιός τελεστέος. |  και τα δύο (η φιλική συνάρτηση σε σχόλια)  | 
-|  %%>>%%  |  //Vector//  |  //int//  | Επιστρέφει ένα νέο αντικείμενο τύπου //Vector// στο οποίο έχει διαγραφεί ο δεξιός τελεστέος, εφόσον αυτός υπάρχει. Το νέο αντικείμενο έχει μέγεθος κατά ένα μικρότερο του αριστερού τελεστέου, εάν βρεθεί ο δεξιός τελεστέος μέσα στο //Vector//. Εάν δεν βρεθεί επιστρέφεται ένα αντικείμενο που περιέχει τα στοιχεία του αριστερού τελεστέου. |  και τα δύο (η φιλική συνάρτηση σε σχόλια)  |+|  %%>>%%  |  //Vector//  |  //int//  | Επιστρέφει ένα νέο αντικείμενο τύπου //Vector//, το οποίο προκύπτει από τον αριστερό τελεστέο εάν ολισθήσουμε όλα τα στοιχεία του δεξιά κατά τόσα bits όσα προσδιορίζει ο δεξιός τελεστέος. |  και τα δύο (η φιλική συνάρτηση σε σχόλια)  | 
 +|  %%==%%  |  //int//  |  //Vector//  | Επιστρέφει //true// εάν για κάθε (0<=i<=size) το στοιχείο του αριστερού τελεστέου στην θέση i, είναι ίσο με το στοιχείο του δεξιού τελεστέου στην ίδια θέση, διαφορετικά //false// |  Όχι  | 
 +|  %%!=%%  |  //int//  |  //Vector//  | Επιστρέφει //true// εάν για κάθε (0<=i<=size) το στοιχείο του αριστερού τελεστέου στην θέση i, ΔΕΝ είναι ίσο με το στοιχείο του δεξιού τελεστέου στην ίδια θέση, διαφορετικά //false// |  Όχι  |
  
 <WRAP center round info 80%> <WRAP center round info 80%>
-Μία φιλική μέθοδο και ένα μέλος της κλάσης δεν είναι δυνατόν να υλοποιούν την ίδια λειτουργικότητα υπερφόρτωσης. Θα πρέπει να επιλέξετε έναν από τους δύο τρόπους για να υλοποιήσετε τη λειτουργία της υπερφόρτωσης.+Μία φιλική μέθοδος και ένα μέλος της κλάσης δεν είναι δυνατόν να υλοποιούν την ίδια λειτουργικότητα υπερφόρτωσης. Θα πρέπει να επιλέξετε έναν από τους δύο τρόπους για να υλοποιήσετε τη λειτουργία της υπερφόρτωσης.
 </WRAP> </WRAP>
  
-<code cpp Vector.cpp>+<code cpp Vector.hpp>
 #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
      
-  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);                // assignment operator 
-  Vector operator+(const Vector &v) const; +  Vector operator+(const Vector& v) const;           // Adds v to *this and returns the sum in a new vector. 
-  //friend Vector operator+(const Vector &v1, const Vector v2); +  //friend Vector operator+(const Vector& v1, const Vector& v2);  // same as above 
-  Vector operator-(const Vector &v) const; +  Vector operator-(const Vector& v) const;           // Subtracts v from *this and returns the subtraction in a new vector. 
-  Vector operator+(int a) const; +  Vector operator*(const Vector& v) const;           // Returns a new vector that is the product of v and *this. 
-  friend Vector operator+(int a, const Vector &v); +  friend Vector operator+(const Vector& v, int a);   // Returns a new vector. Each element of vector equals the sum of v[i] + a 
-  Vector operator-(int a) const; +  friend Vector operator+(int a, const Vector& v);   // Returns a new vector. Each element of vector equals the sum of v[i] + a 
-  Vector operator*(int a) const; +  Vector operator-(int a) const;                     // Returns a new vector. Each element of vector equals the subtraction:  v[i] - a 
-  friend Vector operator*(int a, const Vector &v); +  Vector operator*(int a) const;                     // Returns a new vector. Each element of vector equals the product:  v[i] * a 
-  Vector operator/(int a) const; +  friend Vector operator*(int a, const Vector& v);   // Returns a new vector. Each element of vector equals the product:  v[i] * a 
-  Vector operator%(int a) const;+  Vector operator/(int a) const;                     // Returns a new vector. Each element of vector equals the division (int):  v[i] / a 
 +  Vector operator%(int a) const;                     // Returns a new vector. Each element of vector equals the modulo:  v[i] % a
      
-  Vector operator << (int a) const; +  bool operator==(const Vector& v) const;            // Returns true if each element of the left operand equals each element of right operand. 
-  //friend Vector operator<<(const Vector &v, int a); +  bool operator!=(const Vector& v) const;            // Returns true if each element of the left operand is NOT equal with each element  
-  Vector operator >> (int a) const; +                                                     // of right operand.
-  //friend Vector operator>>(const Vector &v, int a);+
      
 +  Vector operator << (int a) const;                  // Returns a new vector. Each element of vector is left shifted by a positions.
 +  //friend Vector operator<<(const Vector& v, int a);// Same as above
 +  Vector operator >> (int a) const;                  // Returns a new vector. Each element of vector is right shifted by a positions.
 +  //friend Vector operator>>(const Vector& v, int a);// Same as above  
 }; };
  
-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 74: Line 90:
 } }
  
-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 100: Line 116:
 } }
  
-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 131: Line 147:
 void Vector::print(string &msg) const { void Vector::print(string &msg) const {
   cout << msg;   cout << msg;
-  for(int i=0; i<size; i++) { +  print();
-    cout << array[i]; +
-    if(i==size-1) +
-      cout << endl; +
-    else +
-      cout << ", "; +
-  }+
 } }
  
-void Vector::operator=(const Vector &v) {+Vector& Vector::operator=(const Vector& v) {
   if(array!=NULL)   if(array!=NULL)
     delete [] array;     delete [] array;
Line 150: Line 160:
   }   }
   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 172: Line 183:
  
 /* /*
-Vector operator+(const Vector &v1, const Vector v2) {+Vector operator+(const Vector& v1, const Vector v2) {
   int length;   int length;
   if (v1.size > v2.size)   if (v1.size > v2.size)
Line 190: Line 201:
 }*/ }*/
  
-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 208: Line 219:
 } }
  
-Vector Vector::operator+(int a) const { +Vector Vector::operator*(const Vector& v) const { 
-  Vector n(size); +  int length; 
-  for(int i=0; i<size; i++) +  if (size < v.size) 
-    n.array[i] = array[i] + a;+    length = size; 
 +  else 
 +    length = v.size; 
 +  Vector n(length); 
 +  for(int i=0; i<length; i++) 
 +    n.array[i] = array[i] * v.array[i];
   return n;   return n;
 } }
  
-Vector operator+(int a, const Vector &v) {+Vector operator+(const Vector& v, int a) { 
 +  Vector n(v.size); 
 +  for(int i=0; i<v.size; i++) 
 +    n.array[i] = v.array[i] + a; 
 +  return n; 
 +} 
 + 
 +Vector operator+(int a, const Vector& v) {
   Vector n(v);   Vector n(v);
   for(int i=0; i<v.length(); i++) {   for(int i=0; i<v.length(); i++) {
Line 237: Line 260:
 } }
  
-Vector operator*(int a, const Vector &v) {+Vector operator*(int a, const Vector& v) {
   Vector n(v);   Vector n(v);
   for(int i=0; i<v.length(); i++) {   for(int i=0; i<v.length(); i++) {
Line 258: Line 281:
   return n;   return n;
 } }
 +
 +bool Vector::operator==(const Vector& v) const {
 +  if( size != v.size )
 +    return false;
 +  for(int i=0; i<size; i++)
 +    if( array[i] != v.array[i] )
 +      return false;
 +  return true;
 +}
 +
 +bool Vector::operator!=(const Vector& v) const {
 +  return !(*this == v);
 +}
 +
 /* /*
-Vector operator<<(const Vector &v, int a){+Vector operator<<(const Vector& v, int a){
   Vector n(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++)   for(int i=0; i<n.size; i++)
-    array_new[i] = n.array[i]; +    n.array[i] <<= a;
-  array_new[n.size] = a; +
-  n.size++; +
-  delete [] n.array; +
-  n.array = array_new;+
   return n;   return n;
 }*/ }*/
Line 277: Line 305:
 Vector Vector::operator << (int a) const { Vector Vector::operator << (int a) const {
   Vector n(*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++)   for(int i=0; i<n.size; i++)
-    array_new[i] = n.array[i]; +    n.array[i] <<= a;
-  array_new[n.size] = a; +
-  n.size++; +
-  delete [] n.array; +
-  n.array = array_new;+
   return n;   return n;
 } }
  
-/*Vector operator>>(const Vector &v, int a) { +/*Vector operator>>(const Vector& v, int a) {
-  int pos = v.find(a); +
-  if(pos<0) +
-    return v;+
   Vector n(v);   Vector n(v);
-  int *array_new = new (nothrow) int [n.size-1]; +  for(int i=0; i<n.size; i++) 
-  if(array_new==NULL) { +    n.array[i] >>= a;
-    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;   return n;
 }*/ }*/
  
 Vector Vector::operator >> (int a) const { Vector Vector::operator >> (int a) const {
-  int pos = find(a); 
-  if(pos<0) 
-    return *this; 
   Vector n(*this);   Vector n(*this);
-  int *array_new = new (nothrow) int [n.size-1]; +  for(int i=0; i<n.size; i++) 
-  if(array_new==NULL) { +    n.array[i] >>= a;
-    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;   return n;
 } }
 +</code>
  
 +<code cpp VectorUsage.cpp>
 +#include "Vector.hpp"
  
 int main() { int main() {
Line 350: Line 338:
   Vector f = v;   Vector f = v;
   v.print(msg="Vector f:  ");   v.print(msg="Vector f:  ");
 +  if( f == v )
 +    cout << "f == v " << endl;
 +  else
 +    cout << "f != v " << endl;
 +  
 +  
   Vector k;   Vector k;
   k = f + v;   k = f + v;
-  k.print(msg="f + v:  ");+  k.print(msg="k = f + v:  ");
   k = f - v;   k = f - v;
-  k.print(msg="f - v:  ");+  k.print(msg="k = f - v:  "); 
 +  k = f * v; 
 +  k.print(msg="k = f * v:  ");
   k = f + 2;   k = f + 2;
-  k.print(msg="f + 2:  ");+  k.print(msg="k = f + 2:  "); 
 +  k = 2 + f; 
 +  k.print(msg="k = 2 + f:  ");
   k = f - 2;   k = f - 2;
-  k.print(msg="f - 2:  ");+  k.print(msg="k = f - 2:  ");
   k = f * 2;   k = f * 2;
-  k.print(msg="f * 2:  ");+  k.print(msg="k = f * 2:  ");
   k = f / 2;   k = f / 2;
-  k.print(msg="f / 2:  ");+  k.print(msg="k = f / 2:  ");
   k = f % 2;   k = f % 2;
-  k.print(msg="f % 2:  "); +  k.print(msg="k = f % 2:  "); 
-  f = f << 7; +  f = f << 2; 
-  f.print(msg="f = f << 7:  "); +  f.print(msg="f = f << 2: "); 
-  f = f << 7; +  f = f >> 2; 
-  f.print(msg="f = f << 7:  "); +  f.print(msg="f = f >> 2: "); 
-  f = f >> 6; +  if( f == v ) 
-  f.print(msg="f = f >> 6:  "); +    cout << "f == v " << endl; 
-  f = f >> 6; +  else 
-  f.print(msg="f = f >> 6:  "); +    cout << "f != v " << endl;
-  +
 } }
 </code> </code>
- 
  
cpp/vector_overloading_binary_operators.1493989746.txt.gz · Last modified: 2017/05/05 12:09 (external edit)