1)

// Ejemplo sencillo de operador unario sobrecargado (++)

#include<iostream.h>
#include<iomanip.h>

class Reloj
 {   int hora;
      int minuto;
      int segundo;
   public:
     Reloj(int h=0, int m=0, int s=0);
     void DefineTiempo(int, int, int);
     void DefineHora(int);
     void DefineMinuto(int);
     void DefineSegundo(int);
     int Hora(void);
     int Minuto(void);
     int Segundo(void);
     void operator ++ (void);
 };

  Reloj::Reloj(int h, int m, int s)
   { hora=h;
     minuto=m;
     segundo=s;
   }


  void Reloj::DefineTiempo(int h, int m, int s)
   { hora=h;
     minuto=m;
     segundo=s;
   }

  void Reloj::DefineHora(int h)
   { hora = h; }

  void Reloj::DefineMinuto(int m)
   { minuto = m; }

  void Reloj::DefineSegundo(int s)
   { segundo = s; }

  int Reloj::Hora(void)
   { return hora; }

  int Reloj::Minuto(void)
   { return minuto; }

  int Reloj::Segundo(void)
   { return segundo; }

  void Reloj::operator ++(void)
   { segundo++;
     if (segundo > 59)
      { segundo -= 60;
        ++minuto;
      }

    if (minuto > 59)
      { minuto -= 60;
        ++hora;
      }

     if (hora > 23)  hora -= 24;
   }
 void main (void)
 { Reloj R(10,59,56);
   for (int i=0; i<10; i++, ++R)
     cout <<setw(4)<< R.Hora() <<setw(4)<< R.Minuto() <<setw(4)<< R.Segundo() << endl;
 }


/* Al ejecutar este programa se muestra:

     10  59  56
     10  59  57
     10  59  58
     10  59  59
     11   0   0
     11   0   1
     11   0   2
     11   0   3
     11   0   4
     11   0   5
*/


2)

// Ejemplo sencillo de operador sobrecargado binario (*)
// devuelve sólo un número real.

#include<iostream.h>
#include<iomanip.h>

class Vector
 {   float x;
      float y;
   public:
      Vector(float cx=0, float cy=0);
      void DefineX(float);
      void DefineY(float);
      float DameX(void);
      float DameY(void);
      float operator * (Vector);
 };

 Vector::Vector(float cx, float cy)
   { x=cx;   y=cy;}

 void Vector::DefineX(float cx)
   { x=cx; }

 void Vector::DefineY(float cy)
   { y=cy; }

 float Vector::DameX(void)
   { return x; }

 float Vector::DameY(void)
   { return y; }

 float Vector::operator * (Vector V)
   { return (x*V.DameX() + y*V.DameY()); }


 void main (void)
 { Vector V1(10,20), V2(5,5);
    float p;

   p = V1*V2;

   cout << "P = " << p<< endl;
 }

 /* Al ejecutar este programa se muestra:

    P = 150

 */

3)
/* Ejemplo sencillo de operador sobrecargado binario (+)
   permite concatenar una cadena atributo de un objeto
   no devuelve valor.
*/
#include<iostream.h>
#include<iomanip.h>
#include<string.h>

class Cadena
 {   char cad[40];
   public:
      Cadena(char *);
      char * DameCadena(void);
      void operator + (Cadena);
 };

  Cadena::Cadena(char *c)
   { strcpy(cad,c);
   }

  char *Cadena::DameCadena(void)
   { return cad; }

  void Cadena::operator +(Cadena C)
   { strcat(cad, C.DameCadena()); }

 void main (void)
 { Cadena C1("Juan ") , C2("López");

   C1+C2;
   cout << "Atributo de C1 = " << C1.DameCadena() << endl;
 }
/* Al ejecutar este programa se muestra:

    Atributo de C1 = Juan López

*/


4)

/* Ejemplo de operador sobrecargado binario (+ y -)
   devuelve un objeto y permite definir expresiones
*/
#include<iostream.h>
#include<iomanip.h>

class Complejo
 {   float real;
     float imag;
   public:
     Complejo(float r=0, float i=0);
     void DefineR(float);
     void DefineI(float);
     float DameR(void);
     float DameI(void);
     Complejo operator + (Complejo);
     Complejo operator - (Complejo);
 };

 Complejo::Complejo(float r, float i)
  { real=r;  imag=i; }

 void Complejo::DefineR(float r)
  { real=r; }

 void Complejo::DefineI(float i)
  {  imag=i; }

 float Complejo::DameR(void)
  { return real; }

 float Complejo::DameI(void)
  { return imag; }

 Complejo Complejo::operator + (Complejo C)
  { return Complejo(real+C.DameR() , imag+C.DameI());
  }

 Complejo Complejo::operator - (Complejo C)
  { return Complejo(real-C.DameR() , imag-C.DameI());
  }

 void main (void)
 { Complejo A(1.5,2.3), B(5.2,4.7), C(1.1,0.4), D;

   D= A + B - C;
   cout << "D = " << D.DameR()<<" + "<< D.DameI() << "i" 
           << endl;
 }

/* Al ejecutar este programa se muestra:

  D = 5.6 + 6.6i

*/