# include <iostream.h> int cuadrado (int x) {return x * x; }

SOBRECARGA DE FUNCIONES C++ permite definir varias funciones con el mismo nombre, siempre y cuando tengan diferentes grupos de parámetros (cuando menos en lo que concierne a sus tipos). Esta capacidad se llama sobrecarga de funciones. Cuando se llama a una función sobrecargada, el compilador de C++ selecciona la función adecuada examinando el número, tipos y orden de los argumentos de la llamada. La sobrecarga de funciones se utiliza para crear varias funciones con el mismo nombre que realicen tareas similares, pero sobre distintos tipos [Deitel]. # include <iostream.h> int cuadrado (int x) {return x * x; } double cuadrado (double y) { return y * y;} int main () { cout<< "el cuadrado del número 7 tipo integer es "<< cuadrado (7) << "\n el cuadrado del número 7.5 tipo double es " << cuadrado (7.5) << endl; return 0; }

SOBRECARGA DE CONSTRUCTORES Aunque realicen un único servicio, las funciones constructoras no son muy diferentes de otros tipos de funciones; también pueden sobrecargarse. Para sobrecargar una función constructora de una clase, simplemente hay que declarar las diferentes formas que tendrá y definir cada acción relativa a estas formas. temporizador (char *t) {segundos=atoi(t);} class temporizador temporizador (int t) { segundos=t; } temporizador (int min , int seg) { segundos=min*60+seg;}

SOBRECARGA DE CONSTRUCTORES void temporizador::ejecutar(void) { clock_t t1, t2; t1=t2=clock()/CLK_TCK; while (segundos) { if (t1/CLK_TCK+1<=(t2=clock())/CLK_TCK) { segundos--; t1=t2; } } cout<<"\a"; } class temporizador { int segundos; public: temporizador (char *t) { segundos = atoi (t); } temporizador (int t) { segundos = t; } temporizador (int min, int seg) { segundos=min*60 + seg; } void ejecutar (void); }; main (void) { temporizador a(1), b("2"), c(0,10); a.ejecutar(); b.ejecutar(); c.ejecutar(); return 0; } Como se puede observar, cuando se crean a, b y c dentro de main() se le dan valores iniciales usando los tres métodos diferentes soportados por las funciones constructor sobrecargadas. Cada enfoque produce el uso del constructor adecuado, e inicializa cada una de las tres variables de la forma correcta.

VARIABLES LOCALES EN C++ En C++ es posible que al principio de un bloque todas las variables locales que se usan dentro de un bloque. En C++ se puede declarar una variable en un bloque después de haber utilizado otro tipo de sentencia. # include <iostream.h> # include <string.h> main (void) { int i; i=10; int j=100; cout<<i*j<<"\n"; cout<<"Introducir una cadena: "; char cad[80]; cin>>cad; int k; k=strlen(cad); k--; while (k>=0) { cout<<cad[k]; k--; } return 0; } Como se puede observar el programa muestra que en C++ se pueden declarar variables locales en cualquier parte dentro de un bloque de código. Como gran parte de la filosofía de C++ es la encapsulación de código y datos, lo que hace que tenga sentido poder declarar variables cerca de donde se van a usar y no sólo al principio del bloque.

INICIALIZACIÓN DINÁMICA // inicialización dinámica # include <iostream.h> # include <string.h> main (void) { int i; i=10; int j=100; cout<<i*j<<"\n"; cout<<"Introducir una cadena: "; char cad[80]; cin>>cad; // inicializando k de forma dinámica en tiempo de //ejecución int k=strlen(cad)-1; while (k>=0) { cout<<cad[k]; k--; } return 0; } En C++, las variables locales y las variables globales pueden inicializarse en tiempo de ejecución. Al usar inicialización dinámica, una variable puede ser inicializada en tiempo de ejecución usando cualquier expresión válida de C++, a la vez que se declara la variable. Esto significa que puede inicializar una variable usando otras variables o llamadas a funciones.

APLICANDO LA INICIALIZACIÓN DINÁMICA A LOS CONSTRUCTORES // inicialización dinámica a los constructores # include <iostream.h> # include <stdlib.h> # include <time.h> class temporizador { int segundos; public: temporizador (char *t) {segundos=atoi(t);} temporizador (int t) {segundos = t;} temporizador (int min, int seg) { segundos=min*60+seg;} void ejecutar(void); }; void temporizador::ejecutar(void) { clock_t t1,t2; t1=t2=clock()/CLK_TCK; while (segundos) { if (t1/CLK_TCK+1<=(t2=clock())/CLK_TCK) { segundos--; t1=t2; } } cout<<"\a"; } Un objeto, como las variables simples, puede inicializarse dinámicamente cuando se crea. Esto significa que se puede crear exactamente el tipo de objeto que se necesite usando información que sólo se conoce en tiempo de ejecución. Para ilustrar cómo funciona la inicialización dinámica. Esto permite al programador la flexibilidad de usar el constructor que más se ajuste al formato de los datos disponibles en ese momento.

APLICANDO LA INICIALIZACIÓN DINÁMICA A LOS CONSTRUCTORES main (void) { temporizador a(10); a.ejecutar(); cout<<"introducir número de segundos: "; char cad[80]; cin>>cad; temporizador b(cad); b.ejecutar(); cout<<"Introducir minutos y segundos "; int min, seg; cin>>min>>seg; temporizador c(min,seg); c.ejecutar(); return 0; } Como se puede ver, el objeto a se construye usando una constante entera. Sin embargo, b y c se construyen usando información introducida por el usuario. Como el usuario introduce una cadena para b, tiene sentido sobrecargar temporizador() para que acepte una cadena. De la misma forma, el objeto c también se construye en tiempo de ejecución con información introducida por el usuario.

EL OPERADOR this # include <iostream.h> class cl { int i; public: void carga_i (int val) {this->i=val;} int poner_i(void) {return this->i;} }; main (void) { cl o; o.carga_i(100); cout<<o.poner_i(); return 0; } Antes de pasar a la sobrecarga de operadores es necesario aprender otra palabra clave de C++, this, que es un ingrediente esencial para muchas de las sobrecargas de operadores. Cada vez que se invoca una función miembro, se pasa automáticamente un puntero al objeto que la invoca. Se puede acceder a este puntero automáticamente usando this. El puntero this es un parámetro impícito para todas las funciones miembro.

+ elementos a una lista enlazada + sobrecargado + sigue realizando las operaciones de adición en enteros SOBRECARGA DE OPERADORES Una característica de C++ que está relacionada con la sobrecarga de funciones es la sobrecarga de operadores. Por ejemplo, una clase que defina una lista enlazada podría usar el operador + para añadir un objeto a la lista. Otra clase puede usar el operador + de otra forma completamente diferente. Cuando se sobrecarga un operador significa que se ha definido una nueva operación con relación a una clase específica. Por tanto, sobrecargar el + para manejar listas enlazadas no modifica su significado con relación a los enteros (es decir, suma de ellos).

SOBRECARGA DE OPERADORES Para sobrecargar un operador se debe definir qué operación significa con relación a la clase a la que se aplica. Para hacer esto, hay que crear una función operador que defina su acción. La forma general de una función operador es: tipo nombreclase::operator# (lista_argumento) { //operación definida con relación a la clase } Aquí, el operador que se quiere sobrecargar se sustituye por el # y tipo es el tipo de valor devuelto por la operación especificada. Las funciones operador pueden ser miembros o amigas de la clase para la cual se usan. Aunque sean muy similares, hay varias diferencias entre la forma en la que se sobrecarga una función operador miembro y una función amiga.

CONCLUSIONES La sobrecarga de funciones constructoras le permite al programador gestionar una complejidad mayor, permitiendo que los objetos se construyan de la forma más natural posible con relación a su uso específico.

# include <iostream.h> int cuadrado (int x) {return x * x; }