Sobrecargando el operador de llamada a funciones ( )

Uno de los operadores más usuales es el operador de llamada a función y puede ser sobrecargado. La llamada a función se considera como un operador binario expresión principal (lista de expresiones) donde expresión principal es un operando y lista de expresiones (que puede ser vacía) es el otro operando.

La función operador correspondiente es operator() y puede ser definida por el usuario para una clase c sólo mediante una función miembro no estática.
x(i) equivale a x.operator() (i)
x(i,j) equivale a x.operator()(x,y)

Sobrecargando el operador subíndice [ ]

El operador [] se utiliza normalmente como índice de arrays. En realidad este operador realiza una función útil; ocultar la aritmética de punteros. Por ejemplo, si se tiene el siguiente array: char nombre[30]; y se ejecuta una sentencia tal como car = nombre[15]; el operador [] dirige la sentencia de asignación para sumar 15 a la dirección base del array nombre para localizar los datos almacenados en esta posición de memoria.

En C++ se puede sobrecargar este operador y proporciona muchas extensiones útiles al concepto de subíndices de arrays. [] se considera un operador binario porque tiene dos argumentos. En el ejemplo p=x[i]

Los argumentos son x e i. La función operador correspondiente es operator []; ésta puede ser definida para una clase x sólo mediante un función miembro. La expresión x[i] donde x es un objeto de una determinada clase, se interpreta como x.operator[](y).

Sobrecarga de operadores de flujo

Las sentencias de flujos se utilizan para entradas y salidas. Los flujos no son parte de C++, pero se implementan como clases en la biblioteca de C++. Las declaraciones para estas clases se almacenan en el archivo de cabecera iostream.h. En C++ es posible sobrecargar los operadores de flujo de entrada y salida de modo que pueda manipular cualquier sentencia de flujo que incluya cualquier tipo de clase. Como se definen en el archivo de cabecera iostream.h, estos operadores trabajan con todos los tipos predefinidos, tales como int, long, double,char. Sobrecargando estos los operadores de flujo de entrada y salida, estos pueden además manipular cualquier tipo de objetos de clases.

Ejemplo de sobrecarga de los flujos << y >>
class punto
{
int x,y;
public:punto() {x=y=0;}
punto (int xx,int yy) { x=xx;y=yy;}
void fijarx(int xx) { x=xx;}
void fijary(int yy) {y=yy;}
int leerx() {return x;}
int leery() {return y;}
friend ostream& operator << (ostream& os,const punto &p);
friend istream& operator >> (istream& is,const punto &p);
};
void main()
{
punto p;
cout<<p<<endl;
p.fijarx(50);
p.fijary(100);
cout<<p<<endl;
cout <<"introducir los valores de x e y\n";
cin>>p;
cout<<"se ha introducido"<<p;
}
ostream& operator<<(ostream &os,punto &p)
{
os <<"x= "<<p.x<<",y= "<<p.y;
return os;
}
istream& operator>>(istream &is,punto &p)
{
is >>p.x>>p.y;
return is;
}

Es posible poner en cascada múltiples objetos en una sentencia de flujo de salida:
punto p1,p2,p3;
cout<<p1<<":"<<p2<<":"<<p3;