Disponible la nueva versión "donationware" 7.3 de OrganiZATOR
Descubre un nuevo concepto en el manejo de la información.
La mejor ayuda para sobrevivir en la moderna jungla de datos la tienes aquí.

Curso C++

[Home]  [Inicio]  [Índice]


4.5.5b  Manipular estructuras mediante funciones

§1  Sinopsis

Otro posible uso de las funciones es manipular estructuras. Lo ilustraremos con dos ejemplos en los que vemos estructuras como argumentos de funciones. Partimos de los datos del ejemplo anterior (4.5.5a) es decir, suponemos:

struct punto {int x; int y;}    // define tipo estructura punto
struct rect {                   // define tipo estructura rect
        struct punto p1;        // compuesta de dos estructuras  
        struct punto p2;        // tipo punto
    }

§2  Ejemplo-1

El primero es una función dist() para calcular y mostrar la distancia de una estructura tipo punto al origen de coordenadas:

double dis(struct punto p) {  // mide distancia de un punto al origen
   int temp = (p.x * p.x + p.y * p.y)
   double d = pow((double)temp, (double).5);
   printf("%3d,%3d, Distancia: %5.5f\n", p.x, p.y, d);
   return d;
}

Un ejemplo de utilización  (ver definición de screen.p2 en 4.5.5a):

dist(screen.p2);

salida:

80, 24, Distancia: 83.52245

§3  Ejemplo-2

Supongamos una función sumapunto() para sumar estructuras punto, conviniendo que de la suma resulta otra estructura tipo punto, de coordenadas iguales a la suma de las coordenadas de los sumandos. El prototipo de dicha función sería:

struct punto sumapunto( struct punto p1, struct punto p2);


La definición:

struct punto sumapunto( struct punto p1, struct punto p2) {
   struct punto presult;
   presult.x = p1.x + p2.x;
   presult.y = p1.y + p2.y;
   return presult;
}


Su utilización:

struct punto p1 = creast(1,2);
struct punto p2 = creast(1,2);
struct sump1p2 = sumapunto(p1, p2);


Hay que señalar que la definición podría modificarse, para no utilizar la estructura temporal result, en la siguiente forma:

struct punto sumapunto( struct punto p1, struct punto p2) {
   p1.x += p2.x;
   p1.y += p2.y;
   return p1;
}


En este último caso, el resultado struct sump1p2 = sumapunto(p1, p2); hubiera sido el mismo, sin que en realidad se hubiese modificado el valor de la estructura p1, lo que puede comprobarse volviendo a ejecutar dist(p1). La razón es que -por definición- los argumentos de funciones son variables locales automáticas, con ámbito del bloque en que se declara la función ( 4.1.3b Ámbito de bloque), lo que significa que al ejecutar sumpunto se vuelven a crear copias locales de las estructuras p1 y p2. Así mismo, se devuelve la copia local de p1. Esto tiene sus pros y sus contra, como el hecho de que hay dos copias en memoria, el original y la creada en la función. Además se requiere un tiempo para copiarlas y cargarlas en la pila (que puede ser importante cuando se manejan estructuras muy grandes). Por esta razón, es mejor y más rápido utilizar punteros, como se verá en los ejemplos que siguen.