REFERENCIAS

REFERENCIA

El C y el C++ por default pasan argumentos a una función con una llamada por medio del valor de dichos argumentos (call by value). De esta forma la función se sirve de una copia del argumento y no lo modifica. Como se ha visto en capítulos anteriores, para que una función pueda alterar el valor de la variable utilizada como argumento, es indispensable que los parámetros sean declarados explícitamente como punteros y que la función opere sobre los mismos por medio del operador puntero (pointer) *.

 

  • #include <stdio.h>
    void cambia(int *x,int *y);
    void main()
    • {

  • int x=10,y=20;
    printf("\n x inicial = %-d ,y inicial = %-d",x,y);
    cambia(&x,&y);
    printf("\n x final = %-d ,y final = %-d",x,y);
    • }
 
  • void cambia(int *x,int *y)
    • {

  • int temp;
    temp=*x;
    *x=*y;
    *y=temp;
    • }
 

Las variables utilizadas para llamar a la función cambia() deben estar precedidas por el operador de dirección & (address operator) para generar un puntero a cada argumento. Así se genera una llamada por referencia o dirección (call by reference). El C++, en cambio, preve un método más claro y transparente mediante el llamado parámetro de referencia.
En C++ es posible indicar al compilador que genere la llamada automática a una función por referencia en lugar de por valor. Para ello es suficiente anteponer al nombre del parámetro en la declaración de la función el operador de referencia &. El ejemplo anterior modificado sería:

 

  • #include <stdio.h>
    void cambia(int &x,int &y);
    void main()
    • {

  • int x=10,y=20;
    printf("\n x inicial = %-d ,y inicial = %-d",x,y);
    cambia(x,y);
    printf("\n x final = %-d ,y final = %-d",x,y);
    • }
 
  • void cambia(int &x,int &y)
    • {

  • int temp;
    temp=x;
    x=y;
    y=temp;
    • }
 

Variables de referencia

Aunque el objetivo principal del operador de referencia es el de permitir la transferencia de parámetros a la función por referencia, es posible también declarar variables de referencia.
Una variable de referencia debe apuntar a un objeto, y es indispensable inicializarla en el momento de la declaración. En general esto significa asignar a la variable la dirección de otra variable precedentemente declarada. De esta forma la variable referencia puede ser siempre utilizada allí donde se pudiera utilizar la variable a la que se refiere. Vamos un ejemplo:

 

  • #include <iostream>
    void main()
    • {

  • int i,j;
    int &r=i;
    i=10;
    cout << i; // visualiza 10
    r=20;
    cout << i; // visualiza 20
    i=15;
    cout << r; // visualiza 15
    j=r;
    cout << j; // visualiza 15
    • }
 

La referencia es un modo de identificar una variable con dos nombres diferentes.

ALOCACION DINAMICA A TRAVES DE new Y delete

El C se vale de las funciones malloc() y free() para reservar y liberar memoria respectivamente. Con tal propósito el C++ está provisto de dos operadores new y delete que efectúan esta operación de una manera más elegante.

Los operadores new y delete actúan en estrecha colaboración. Por esto motivo la liberación de memoria por medio de delete requiere que el puntero haya sido inicializado con new. La incorrecta utilización de delete puede originar serios problemas tanto el programa como en el sistema.

 

  • #include <iostream.h>
    char *newStr(char * str)
    • {

  • char *p;
    int len;
    len=strlen(str)+1;

    p=new char[strlen(str)+1]; /* reserva memoria para un vector de tipo char y de una longitud len */

    strcpy(p,str);
    return p;
    • }
 
  • void deleteStr(char *str)
    • {

  • int len;
    len=strlen(str)+1;
    delete [len]str;// libera len elementos de tipo char
    • }


void main()
{

  • char *msg;
    msg=newStr("Esto es un mensaje");// reserva de memoria
    cout << msg;
    deleteStr(msg); // libera la memoria ocupada por msg
    • }
 

SOBRECARGA DE FUNCIONES

El polimormismo en C++ se consigue además de con la sobrecarga de operadores con la sobrecarga de funciones.
En C++ dos o más funciones pueden tener el mismo nombre siempre que la declaración de parámetros sea diferente. En tales circunstancias el compilador distingue entre una u otra función por el tipo de sus parámetros.

 

  • #include <iostream.h>

    int cuadrado(int );
    double cuadrado(double );
    long cuadrado(long );

    void main(void)
    • {

  • cout << cuadrado(10) << "\n";
    cout << cuadrado(11.4) << "\n";
    cout << cuadrado(1234L) << "\n";
    • }
 
  • int cuadrado(int x)
    • {

  • cout << " cuadrado de tipo entero \n";
    return x*x;
    • }
 
  • duble cuadrado(double x)
    • {

  • cout << " cuadrado de tipo double \n";
    return x*x;
    • }
 

  • long cuadrado(long x)
    • {

  • cout << " cuadrado de tipo long \n";
    return x*x;
    • }
 

El programa crea tres funciones cuadrado() similares donde cada una de ellas retorna el cuadrado del argumento. Como se demuestra en el ejemplo el compilador llama a la función apropiada según el tipo de parámetro conque sea efectuada la llamada.

ARGUMENTOS POR DEFECTO

El C++ admite que una función asigne a un parámetro un valor por defecto si dicho parámetro no viene especificado en la llamada. La sintaxis utilizada para indicar el valor de defecto es análoga a la de la inicialización de una variable.

 

  • #include <iostream.h>
    void strxy(char *str,int x=1,int y=1);
    void main()
    • {

  • strxy("Salve gente");
    strxy("Hola muchachos",5,6);
    • }

 
  • void strxy(char *str,int x,int y)
    • {

  • if (x<1) x=1;
    if (y<1) y=1;
    gotoxy(x,y);
    cout << str
    • }
 

Se puede observar que la llamada a strxy() dentro de main() se puede hacer con uno o con dos argumentos. En presencia de un único argumento x e y son sustituidos por el valor por defecto. Si el número de argumentos fuera dos el valor por defecto le sería asignado sólo a la y.

  •