En C++ dos o más funciones pueden compartir el mismo nombre en tanto en cuanto difiera el tipo de sus argumentos o el número de sus argumentos o ambos. Cuando comparten el mismo nombre y realizan operaciones distintas se dice que están sobrecargadas. Para conseguir la sobrecarga  simplemente hay que declarar y definir todas las versiones requeridas.

También es posible y es muy común sobrecargar las funciones constructoras. Hay 3 razones por las que sobrecargar las funciones constructoras. Primero ganar flexibilidad, permitir arrays y construir copias de constructores.

EJEMPLO:
#include <iostream.h>
#include <conio.h>
#include <stdio.h>
int abs(int numero);
long abs(long numero);
double abs(double numero);

void main()
{
     clrscr();
     cout <<"Valor absoluto de -10 "<< abs(-10) <<"\n";
     cout <<"Valor absoluto de -10L "<< abs(-10L) <<"\n";
     cout <<"Valor absoluto de -10.01 "<< abs(-10.01) <<"\n";
     getch();
}

int abs(int numero)
{
     return numero<0 ? -numero:numero;
}
long abs(long numero)
{
     return numero<0 ? -numero:numero;
}
double abs(double numero)
{
     return numero<0 ? -numero:numero;
}

EJEMPLO:
#include <iostream.h>
#include <stdio.h>
#include <conio.h>
void fecha(char *fecha);
void fecha(int anno, int mes, int dia);
void main()
{
     clrscr();
     fecha("23/8/98");
     fecha(98,8,23);
     getch();
}
void fecha(char *fecha)
{
     cout<<"Fecha: "<<fecha<<"\n";
}
void fecha(int anno,int mes,int dia)
{
     cout<<"Fecha: "<<dia<<"/"<<mes<<"/"<<anno;
}

ARGUMENTOS IMPLICITOS: Otra característica relacionada con la sobrecarga es la utilización de argumentos implícitos que permite dar un valor a un parámetro cuando no se especifica el argumento correspondiente en la llamada a la función.

PROTOTIPO:
tipo_devuelto(var1=valor,var2=valor,varN=valor);

EJEMPLO:
#include<iostream.h>
#include<stdio.h>
#include<conio.h>
void funcion(int a=0, int b=0)
{
     cout<<"a: "<< a <<" b: "<< b <<"\n";
}

void main()
{
     clrscr();
     funcion();
     funcion(10);
     funcion(20,30);
     getch();
}

Es muy similar a la sobrecarga de funciones, un operador siempre se sobrecarga  con relación a una clase. Cuando se sobrecarga un operador no pierde su contenido original, gana un contenido relacionado con la clase. Para sobrecargar un operador se crea una función operadora que normalmente será una función amiga a la clase.

PROTOTIPO:
tipo_devuelto nombre_clase::operator operador(parametros)
     {
         cuerpo;
     }

Se pueden realizar cualquier actividad al sobrecargar los operadores pero es mejor que las acciones de un operador sobrecargado se ajusten al uso normal de ese operador. La sobrecarga tiene dos restricciones, no puede cambiar la precedencia del operador y que el numero de operadores no puede modificarse. También hay operadores que no pueden sobrecargarse.

OPERADORES
.
::
¿??
.*

Existen 3 tipos de sobrecarga de operadores. Operadores binarios, operadores logicos-relacionales y operadores unarios. Cada uno de ellos deben tratarse de una manera especifica para cada  uno de ellos.

BINARIOS: La función solo tendrá un parametro. Este parámetro contendrá al objeto que este en el lado derecho del operador. El objeto del lado izquierdo es el que genera la llamada a la función operadora y se pasa implícitamente a través de this.

EJEMPLO:
#include <iostream.h>
#include <stdio.h>
#include <conio.h>
class opera{
     int x, y;
public:
     opera() {x=0;y=0;}
     opera(int i, int j) {x=i; y=j;}
     void obtenxy(int &i,int &j) {i=x; j=y;}
     opera operator+(opera obj);
};

opera opera::operator+(opera obj)
{
     opera temp;
     temp.x=x+obj.x;
     temp.y=y+obj.y;
     return temp;
}

void main()
{
     opera obj1(10,10), obj2(5,3),obj3;
     int x,y;
     obj3=obj1+obj2;
     obj3.obtenxy(x,y);
     cout << "Suma de obj1 mas obj2\n ";
     cout << "Valor de x: "<< x << "  Valor de y: " << y;
     getch();
}

LÓGICOS Y RELACIONALES: Cuando se sobrecargan dichos operadores no se deseará que las funciones operadoras devuelvan un objeto, en lugar de ello, devolverán un entero que indique verdadero o falso. Esto permite que los operadores se integren en expresiones lógicas y relacionales más extensas que admitan otros tipos de datos.

EJEMPLO:
#include <iostream.h>
#include <stdio.h>
#include <conio.h>
class opera{
     int x,y;
public:
     opera() {x=0;y=0;}
     opera(int i,int j) {x=i; y=j;}
     void obtenerxy(int &i, int &j) {i=x; j=y;}
     int operator==(opera obj);
};

int opera::operator==(opera obj)
{
     if(x==obj.x && y==obj.y)
         return 1;
     else
         return 0;
}

void main()
{
     clrscr();
     opera obj1(10,10), obj2(5,3);
     if(obj1==obj2)
         cout << "Objeto 1 y Objeto 2 son iguales";
     else
         cout << " Objeto 1 y objeto 2 son diferentes";
     getch();
}

UNARIOS: El miembro no tiene parámetro. Es el operando el que genera la llamada a la función operadora. Los operadores unarios pueden preceder o seguir a su operando, con lo que hay que tener en cuenta como se realiza la llamada.

EJEMPLO:
#include <iostream.h>
#include <stdio.h>
#include <conio.h>
class opera{
     int x, y;
public:
     opera() {x=0;y=0;}
     opera(int i, int j) {x=i;y=j;}
     void obtenxy(int &i, int &j) {i=x; j=y;}
     opera operator++();
};

opera opera::operator++()
{
     x++;
     y++;
}

void main()
{
     clrscr();
     opera objeto(10,7);
     int x,y;
     objeto++;
     objeto.obtenxy(x,y);
     cout<< "Valor de x: " << x <<"  Valor de y: "<< y << "\n";
     getch();
}