C++/Overload/Plus

Содержание

1 additional meanings for the + and = operations
2 Define operator +(plus) and cast to double operator
3 Friendly operator+
4 friend overloaded + operator
5 + is overloaded for three_d + three_d and for three_d + int.
6 overloaded "+" operator adds two Distances
7 overloaded "+" operator concatenates strings
8 Overload + for "ob + int" as well as "ob + ob".
9 Overloading the + (or any other binary operator) using a friend allows a built-in type to occur on the left or right side of the operator.
10 overload the "+" operator so that several angles, in the format degrees minutes seconds, can be added directly.
11 Overload the + relative to MyClass.
12 String class with custom +/- operator

additional meanings for the + and = operations

  
#include <iostream>  
#include <string.h>  
using namespace std;
class str_type {  
  char string[80];  
public:  
  str_type(char *str = "\0") { strcpy(string, str); }  
     
  str_type operator+(str_type str);  
  str_type operator+(char *str);  
     
  str_type operator=(str_type str);  
  str_type operator=(char *str);  
     
  void show_str(void) { cout << string; }  
} ;  
     
str_type str_type::operator+(str_type str) {  
  str_type temp;  
     
  strcpy(temp.string, string);  
  strcat(temp.string, str.string);  
  return temp;  
}  
     
str_type str_type::operator=(str_type str) {  
  strcpy(string, str.string);  
  return *this;  
}  
     
str_type str_type::operator=(char *str)  
{  
  str_type temp;  
     
  strcpy(string, str);  
  strcpy(temp.string, string);  
  return temp;  
}  
     
str_type str_type::operator+(char *str)  
{  
  str_type temp;  
     
  strcpy(temp.string, string);  
  strcat(temp.string, str);  
  return temp;  
}  
     
main(void)  
{  
  str_type a("Hello "), b("There"), c;  
     
  c = a + b;  
     
  c.show_str();  
  cout << "\n";  
     
  a = "to program in because";  
  a.show_str();  
  cout << "\n";  
     
  b = c = "C++ is fun";  
     
  c = c+" "+a+" "+b;  
  c.show_str();  
     
  return 0;  
}

Define operator +(plus) and cast to double operator

  
#include <iostream>
using namespace std;
class Power {
   double b;
   int e;
   double val;
 public:
   Power(double base, int exp);
   Power operator+(Power obj) {
      double base;
      int exp; 
      base = b + obj.b;
      exp = e + obj.e;
      Power temp(base, exp);
      return temp;
   }
   operator double(void) {return val;}     
};
Power::Power(double base, int exp){
   b = base;
   e = exp;
   val = 1;
   if (exp!=0)
      while(exp-- > 0)
         val *= b;
}
int main(void){
   Power pwr1(4.0, 2);
   double doub1;
   doub1 = pwr1;                
   cout << (doub1 + 100.2) << endl;
   Power pwr2(3.3, 3), pwr3(0,0);
   pwr3 = pwr1 + pwr2;          
   doub1 = pwr3;                
   cout << doub1;
}

Friendly operator+

  
#include <iostream>
#include <string.h>
using namespace std;
class String{
   public:
      String();
      String(const char *const);
      String(const String &);
      ~String();
      char & operator[](int offset);
      char operator[](int offset) const;
      String operator+(const String&);
      friend String operator+(const String&, const String&);
      void operator+=(const String&);
      String & operator= (const String &);
      int GetLen()const { return itsLen; }
      const char * GetString() const { return itsString; }
   private:
      String (int);
      char * itsString;
      unsigned short itsLen;
};
String::String()
{
   itsString = new char[1];
   itsString[0] = "\0";
   itsLen=0;
}
String::String(int len)
{
   itsString = new char[len+1];
   for (int i = 0; i<=len; i++)
      itsString[i] = "\0";
   itsLen=len;
}
String::String(const char * const cString)
{
   itsLen = strlen(cString);
   itsString = new char[itsLen+1];
   for (int i = 0; i<itsLen; i++)
      itsString[i] = cString[i];
   itsString[itsLen]="\0";
}
String::String (const String & rhs)
{
   itsLen=rhs.GetLen();
   itsString = new char[itsLen+1];
   for (int i = 0; i<itsLen;i++)
      itsString[i] = rhs[i];
   itsString[itsLen] = "\0";
}
String::~String ()
{
   delete [] itsString;
   itsLen = 0;
}
String& String::operator=(const String & rhs)
{
   if (this == &rhs)
      return *this;
   delete [] itsString;
   itsLen=rhs.GetLen();
   itsString = new char[itsLen+1];
   for (int i = 0; i<itsLen;i++)
      itsString[i] = rhs[i];
    itsString[itsLen] = "\0";
    return *this;
}
char & String::operator[](int offset)
{
   if (offset > itsLen)
      return itsString[itsLen-1];
   else
      return itsString[offset];
}
char String::operator[](int offset) const
{
   if (offset > itsLen)
      return itsString[itsLen-1];
   else
      return itsString[offset];
}
String String::operator+(const String& rhs)
{
   int  totalLen = itsLen + rhs.GetLen();
   String temp(totalLen);
   int i, j;
   for (i = 0; i<itsLen; i++)
      temp[i] = itsString[i];
   for (j = 0, i = itsLen; j<rhs.GetLen(); j++, i++)
      temp[i] = rhs[j];
   temp[totalLen]="\0";
   return temp;
}
String operator+(const String& lhs, const String& rhs)
{
   int  totalLen = lhs.GetLen() + rhs.GetLen();
   String temp(totalLen);
   int i, j;
   for (i = 0; i<lhs.GetLen(); i++)
      temp[i] = lhs[i];
   for (j = 0, i = lhs.GetLen(); j<rhs.GetLen(); j++, i++)
      temp[i] = rhs[j];
   temp[totalLen]="\0";
   return temp;
}
int main()
{
   String s1("String One ");
   String s2("String Two ");
   char *c1 = { "C-String One " } ;
   String s3;
   String s4;
   String s5;
   cout << "s1: " << s1.GetString() << endl;
   cout << "s2: " << s2.GetString() << endl;
   cout << "c1: " << c1 << endl;
   s3 = s1 + s2;
   cout << "s3: " << s3.GetString() << endl;
   s4 = s1 + c1;
   cout << "s4: " << s4.GetString() << endl;
   s5 = c1 + s2;
   cout << "s5: " << s5.GetString() << endl;
 return 0;
}

friend overloaded + operator

  
#include <iostream>  
using namespace std;  
class Distance{  
   private:  
      int feet;  
      float inches;  
   public:  
      Distance(){ 
         feet = 0; 
         inches = 0.0; 
      }  
      Distance( float fltfeet ){                        
         feet = int(fltfeet);     
         inches = 12*(fltfeet-feet);
      }  
      Distance(int ft, float in){ 
         feet = ft; 
         inches = in; 
      }  
      void showdist(){ 
         cout << feet << "\"-" << inches << "\""; 
      }  
      friend Distance operator + (Distance, Distance); 
};
Distance operator + (Distance d1, Distance d2){  
   int f = d1.feet + d2.feet;        
   float i = d1.inches + d2.inches;  
   if(i >= 12.0){ 
      i -= 12.0; f++;  
   }        
   return Distance(f,i);          
}  
int main(){  
   Distance d1 = 2.5;
   Distance d2 = 1.25;
   Distance d3;  
   cout << "\nd1 = "; 
   d1.showdist();  
   cout << "\nd2 = "; 
   d2.showdist();  
  
   d3 = d1 + 10.0;
   cout << "\nd3 = "; d3.showdist();  
   d3 = 10.0 + d1;
   cout << "\nd3 = "; d3.showdist();  
   cout << endl;  
   return 0;  
}

+ is overloaded for three_d + three_d and for three_d + int.

  
#include <iostream>
using namespace std;
class three_d {
  int x, y, z;
public:
  three_d() { x = y = z = 0; }
  three_d(int i, int j, int k) { x = i; y = j; z = k; }
  // Add two three_d objects together.
  three_d operator+(three_d rh_op);
  // Add an integer to a three_d object.
  three_d operator+(int rh_op);
  // Subtract two three_d objects.
  three_d operator-(three_d rh_op);
  // Overload assignment.
  three_d operator=(three_d rh_op);
  // Overload ==.
  bool operator==(three_d rh_op);
  // Overload - for unary operation.
  three_d operator-();
  // Let the overloaded inserter be a friend.
  friend ostream &operator<<(ostream &strm, three_d op);
  // Let the overloaded + be a friend.
  friend three_d operator+(int lh_op, three_d rh_op);
};
// Overload binary + so that corresponding coordinates are added.
three_d three_d::operator+(three_d rh_op)
{
  three_d temp;
  temp.x = x + rh_op.x;
  temp.y = y + rh_op.y;
  temp.z = z + rh_op.z;
  return temp;
}
// Overload binary + so that an integer can be added to a three_d object.
three_d three_d::operator+(int rh_op)
{
  three_d temp;
  temp.x = x + rh_op;
  temp.y = y + rh_op;
  temp.z = z + rh_op;
  return temp;
}
// Overload binary - so that corresponding coordinates are subtracted.
three_d three_d::operator-(three_d rh_op)
{
  three_d temp;
  temp.x = x - rh_op.x;
  temp.y = y - rh_op.y;
  temp.z = z - rh_op.z;
  return temp;
}
// Overload unary - so that it negates the coordinates.
three_d three_d::operator-()
{
  three_d temp;
  temp.x = -x;
  temp.y = -y;
  temp.z = -z;
  return temp;
}
// Overload assignment for three_d.
three_d three_d::operator=(three_d rh_op)
{
  x = rh_op.x;
  y = rh_op.y;
  z = rh_op.z;
  return *this;
}
// Overload == for a three_d object.
bool three_d::operator==(three_d rh_op)
{
  if( (x == rh_op.x) && (y == rh_op.y) && (z == rh_op.z) )
    return true;
  return false;
}
// These are non-member operator functions.
//
// Overload << as a custom inserter for three_d objects.
ostream &operator<<(ostream &strm, three_d op) {
  strm << op.x << ", " << op.y << ", " << op.z << endl;
  return strm;
}
// Overload + for int + obj.
three_d operator+(int lh_op, three_d rh_op) {
  three_d temp;
  temp.x = lh_op + rh_op.x;
  temp.y = lh_op + rh_op.y;
  temp.z = lh_op + rh_op.z;
  return temp;
}
int main()
{
  three_d objA(1, 2, 3), objB(10, 10, 10), objC;
  cout << "This is objA: " << objA;
  cout << "This is objB: " << objB;
  // Obtain the negation of objA.
  objC = -objA;
  cout << "This is -objA: " << objC;
  // Add objA and objB together.
  objC = objA + objB;
  cout << "objA + objB: " << objC;
  // Subtract objB from objA.
  objC = objA - objB;
  cout << "objA - objB: " << objC;
  // Add obj + int.
  objC = objA + 10;
  cout << "objA + 10: " << objC;
  // Add int + obj.
  objC = 100 + objA;
  cout << "100 + objA: " << objC;
  // Compare two objects.
  if(objA == objB) cout << "objA is equal to objB.\n";
  else cout << "objA is not equal to objB.\n";
  return 0;
}

overloaded "+" operator adds two Distances

  
#include <iostream>
using namespace std;
class Distance
{
   private:
      int feet;
      float inches;
   public:
      Distance() : feet(0), inches(0.0){  }
      Distance(int ft, float in) : feet(ft), inches(in)  {  }
      void getdist(){
         cout << "\nEnter feet: ";  cin >> feet;
         cout << "Enter inches: ";  cin >> inches;
      }
      void showdist() const { cout << feet << "\"-" << inches << "\""; }
      Distance operator + ( Distance ) const;
};
Distance Distance::operator + (Distance d2) const{
   int f = feet + d2.feet;
   float i = inches + d2.inches;
   if(i >= 12.0){
      i -= 12.0;
      f++;
   }
   return Distance(f,i);
}
int main()  {
   Distance dist1, dist3, dist4;
   dist1.getdist();
   Distance dist2(11, 6.25);
   dist3 = dist1 + dist2;
   dist4 = dist1 + dist2 + dist3;
   cout << "dist1 = ";  dist1.showdist(); cout << endl;
   cout << "dist2 = ";  dist2.showdist(); cout << endl;
   cout << "dist3 = ";  dist3.showdist(); cout << endl;
   cout << "dist4 = ";  dist4.showdist(); cout << endl;
   return 0;
}

overloaded "+" operator concatenates strings

  
#include <iostream>
using namespace std;
#include <string.h>
#include <stdlib.h>
class String{
   private:
      enum { SZ=80 };
      char str[SZ];
   public:
      String() { strcpy(str, ""); }
      String( char s[] ) { strcpy(str, s); }
      void display() const { cout << str; }
      String operator + (String ss) const {
         String temp;
         if( strlen(str) + strlen(ss.str) < SZ ){
            strcpy(temp.str, str);
            strcat(temp.str, ss.str);
         }else{
            cout << "\nString overflow"; exit(1);
         }
         return temp;
      }
};
int main(){
   String s1 = "aaa ";
   String s2 = "bbb";
   String s3;
   s1.display();
   s2.display();
   s3.display();
   s3 = s1 + s2;
   s3.display();
   return 0;
}

Overload + for "ob + int" as well as "ob + ob".

  
#include <iostream>
using namespace std;
class MyClass {
  int x, y; 
public:
  MyClass() { 
     x=0; 
     y=0; 
  }
  MyClass(int i, int j) { 
     x=i; 
     y=j; 
  }
  void getXY(int &i, int &j) { 
     i=x; 
     j=y; 
  }
  MyClass operator+(MyClass object2); // ob + ob
  MyClass operator+(int i);         // ob + int
};
// Overload + relative to MyClass class.
MyClass MyClass::operator+(MyClass object2)
{
  MyClass temp;
  temp.x = x + object2.x;
  temp.y = y + object2.y;
  return temp;
}
// Overload + for ob + int
MyClass MyClass::operator+(int i)
{
  MyClass temp;
  temp.x = x + i;
  temp.y = y + i;
  return temp;
}
int main()
{
  MyClass object1(10, 10), object2(5, 3), object3;
  int x, y;
  object3 = object1 + object2;                // add two objects - this calls operator+(MyClass)
  object3.getXY(x, y);
  cout << "(object1+object2) X: " << x << ", Y: " << y << endl;
  object3 = object1 + 100;               // add object + int - this call  operator+(int)
  object3.getXY(x, y);
  cout << "(object1+100) X: " << x << ", Y: " << y << endl;
  return 0;
}

Overloading the + (or any other binary operator) using a friend allows a built-in type to occur on the left or right side of the operator.

  
#include <iostream>  
using namespace std;
class MyClass {  
public:  
  int count;  
  MyClass operator=(int i);  
  friend MyClass operator+(MyClass ob, int i);  
  friend MyClass operator+(int i, MyClass ob);  
};  
     
MyClass MyClass::operator=(int i)  
{  
  count = i;  
  return *this;  
}  
     
// This handles ob + int.  
MyClass operator+(MyClass ob, int i)  
{  
  MyClass temp;  
     
  temp.count = ob.count + i;  
  return temp;  
}  
     
// This handles int + ob.  
MyClass operator+(int i, MyClass ob)  
{  
  MyClass temp;  
     
  temp.count = ob.count + i;  
  return temp;  
}  
     
main(void)  
{  
  MyClass obj;  
  obj = 10;  
  cout << obj.count << " "; 
     
  obj = 10 + obj; 
  cout << obj.count << " "; 
     
  obj = obj + 12; 
  cout << obj.count;
     
  return 0;  
}

overload the "+" operator so that several angles, in the format degrees minutes seconds, can be added directly.

  
#include <iostream>
#include <stdlib.h>
#include <string.h>
using namespace std;
int totaldegrees, totalminutes, totalseconds;
class angle_value {
 int degrees, minutes, seconds;
 
 public:
 angle_value() {degrees=0,minutes=0, seconds=0;}  // constructor
 angle_value(char *);
 angle_value operator +(angle_value);
};
angle_value::angle_value(char *angle_sum)
{
 degrees=atoi(strtok(angle_sum,"d"));
 minutes=atoi(strtok(0,"m"));
 seconds=atoi(strtok(0,"s"));
}
  
angle_value angle_value::operator+(angle_value angle_sum){
 angle_value ang;
 ang.seconds=(seconds+angle_sum.seconds)%60;
 ang.minutes=((seconds+angle_sum.seconds)/60+ minutes+angle_sum.minutes)%60;
 ang.degrees=((seconds+angle_sum.seconds)/60+ minutes+angle_sum.minutes)/60;
 ang.degrees+=degrees+angle_sum.degrees;
 totaldegrees=ang.degrees;
 totalminutes=ang.minutes;
 totalseconds=ang.seconds;
 return ang;
}
main()
{
 char str1[] = "37d 15m 56s";
 angle_value angle1(str1);   
 
 char str2[] = "10d 44m 44s";
 angle_value angle2(str2);
 
 char str3[] = "75d 17m 59s";
 angle_value angle3(str3);
  
   char str4[] = "130d 32m 54s";
 angle_value angle4(str4);
 
 angle_value sum_of_angles;
 sum_of_angles=angle1+angle2+angle3+angle4;
 cout << "The sum of the angles is " << totaldegrees << "d "
      << totalminutes << "m " << totalseconds << "s"  << endl;
 return (0);
}

Overload the + relative to MyClass.

  
#include <iostream>
using namespace std;
class MyClass {
  int x, y; 
public:
  MyClass() { 
     x=0; 
     y=0; 
  }
  MyClass(int i, int j) { 
     x=i; 
     y=j; 
  }
  void getXY(int &i, int &j) { 
     i=x; 
     j=y; 
  }
  MyClass operator+(MyClass object2);
};
// Overload + 
MyClass MyClass::operator+(MyClass object2)
{
  MyClass temp;
  temp.x = x + object2.x;
  temp.y = y + object2.y;
  return temp;
}
int main()
{
  MyClass object1(10, 10), object2(5, 3), object3;
  int x, y;
  object3 = object1 + object2;     // add two objects - this calls operator+()
  object3.getXY(x, y);
  cout << "(object1+object2) X: " << x << ", Y: " << y << endl;
  return 0;
}

String class with custom +/- operator

   
#include <iostream>
#include <iomanip>
#include <string.h>
using namespace std;
class String 
{
  public: 
    char *operator +(char *append_str)
    { return(strcat(buffer, append_str)); };
   
    char *operator -(char letter);
    String(char *string) 
    { strcpy(buffer, string); 
        length = strlen(buffer); 
    }
    void show_string() { cout << buffer; };
  private:
    char buffer[256];
    int length;
};
int main(void){
   String title("A");
   title = title + "Programmer"s Bible\n";
   title.show_string();
}

C++/Overload/Plus

Содержание

additional meanings for the + and = operations

Define operator +(plus) and cast to double operator

Friendly operator+

friend overloaded + operator

+ is overloaded for three_d + three_d and for three_d + int.

overloaded "+" operator adds two Distances

overloaded "+" operator concatenates strings

Overload + for "ob + int" as well as "ob + ob".

Overloading the + (or any other binary operator) using a friend allows a built-in type to occur on the left or right side of the operator.

overload the "+" operator so that several angles, in the format degrees minutes seconds, can be added directly.

Overload the + relative to MyClass.

String class with custom +/- operator

Навигация

Персональные инструменты

Пространства имён

Варианты

Просмотры

Ещё

Поиск

С

С++

Навигация

Инструменты