Apuntadores en C 1.

-Un Apuntador es una variable que contiene una direccin de memoria, la cual corresponder a un dato o a una variable que contiene el dato. Los apuntadores tambin deben de seguir las mismas reglas que se aplican a las dems variables, deben tener nombre nicos y deben de declararse antes de usarse. Cada variable que se utiliza en una aplicacin ocupa una o varias posiciones de memoria. Estas posiciones de memoria se accesan por medio de una direccin.

En la figura el texto Hello sta guardado en memoria, comenzando en la direccin 1000. Cada carcter ocupa un espacio de direccin nico en memoria. Los apuntadores proporcionan un mtodo para conservar y llegar a estas direcciones en memoria. Los apuntadores facilitan el manejo de datos, debido a que conservan la direccin de otra variable o ubicacin de datos.

1.1-Por qu son Importantes los Apuntadores?Los apuntadores dan flexibilidad a los programas en C++ y permiten que estos crezcan dinmicamente. Utilizando un apuntador hacia un bloque de memoria que se asigna al momento de ejecucin, un programa puede ser ms flexible que uno que asigna toda su memoria de una sola vez. Tambin, un apuntador es ms fcil de guardar que una estructura grande o un objeto de una clase. Debido a que un apuntador slo guarda una direccin, puede fcilmente pasarse a una funcin. Uno de las desventajas que pueden presentar los apuntadores es que un apuntador sin control o no inicializado puede provocar fallas en el sistema, adems de que su uso incorrecto puede generar fallas muy complejas de hallar. 1.2 Operadores de Indireccin y Direccin. Hay 2 operadores que se usan cuando trabajan con direcciones en un programa C; el Operador de Indireccin ( * ) y el de Direccin (&). Estos operadores son diferentes de los tratados anteriormente. El Operador de Direccin ( &) regresa la direccin de una variable. Este operador est asociado con la variable a su derecha: &h; Esta lnea regresa la direccin de la variable h. El Operador de Indireccin ( * ) trabaja a la inversa del operador de Direccin. Tambin esta asociado con la variable a su derecha, toma la direccin y regresa el dato que contiene esa direccin. Por ejemplo, la siguiente lnea determina la direccin de la variable h y luego usa el operador de Indireccin para accesar la variable y darle un valor de 42: *(&h)=42;

La declaracin de un puntero de manera general es: tipo *nombre de apuntador; Tipo : Especifica el tipo de objeto apuntado y puede ser cualquier tipo. Nombre de apuntador: Es el identificador del apuntador.

El espacio de memoria requerido para un apuntador, es el nmero de bytes necesarios para especificar una direccin de memoria, debiendo apuntar siempre al tipo de dato correcto. Considere el siguiente programa y observe a las variables de direccin e Indireccin trabajar:

1.3-La Aritmtica de Apuntadores. Solamente se pueden realizar operaciones de incremento y decremento, y estos es deacuerdo a la longitud de su tipo de base. Por ejemplo supngase que una mquina particular utiliza direccionamiento de byte, un entero requiere 4 bytes y el valor de la variable pi (declarada asi: int *pi) es 100, es decir, se apunta al entero *pi en la localidad 100. Entonces el valor de pi-1 es 96, el de pi+1 es 104 y el de pi+2 es 108. El valor de *(pi-1) es el de los contenidos de los 4 bytes 96,97,98, y 99 , el de *(pi+1) es el del contenido de los byte 104, 105,106 y 107, y el de *(pi+2) es el entero que esta en los bytes 108,109,110 y 111. De manera parecida, si el valor de la variable pc (declarada asi: char *pc; ) es igual a 100, y un carcter tiene un byte de longitud, pc-1 refiere a la localidad 99, pc+1 a la 101 y pc+2 a la 102. 1.4 Apuntadores a Funciones.Un rea en la cual desempean un papel prominente los apuntadores es el lenguaje C es la transmisin de parmetros a funciones. Por lo comn, los parmetros se transmiten por valor a una funcin en C, es decir, se copian los valores transmitidos en los parmetros de la funcin llamada en el momento en que se invoca. Si cambia el valor de un parmetro dentro de la funcin, no cambia su valor en el programa que la llama. Por ejemplo considrese el siguiente fragmento y funcin de programa (el numero de lnea es solo una gua en el ejemplo):

La lnea 2 imprime el nmero 5 y despus llama a funct. El valor de "x", que es 5, se copia en "y" y comienza la ejecucin de funct. Despus, la lnea 9 imprime el nmero 6 y regresa funct. Sin embargo, cuando la lnea 8 incrementa el valor de "y", el valor de "x" permanece invariable. As, la lnea 4 imprime el nmero 5, "x" y "y" refieren a 2 variables diferentes. Si deseamos usar funct para modificar el valor de "x", debemos de transmitir la direccin de "x" de la siguiente manera:

La lnea 2 imprime nuevamente el nmero 5, y la lnea 3 llama a funct. Ahora, sin embargo, el valor transferido no es el valor entero de "x" sino el valor apuntador "&x". Este es la direccin de "x". El parmetro de funct no es ms y de tipo int, sino py de tipo int * . (Es conveniente nombrar a las variables apuntadores comenzando con la letra p para recordar tanto que se trata de un apuntador) la lnea 8 ahora aumenta al entero en la localidad py; py, sin embargo, no cambia y conserva su valor inicial "&x". As, py apunta al entero "x" de tal manera que cuando *py, aumenta x. La lnea 9 imprime 6 y cuando regresa funct, la lnea 4 imprime tambin 6. Los apuntadores son el mecanismo usado en el lenguaje C para permitir a una funcin llamada modificar las variables de la funcin que llama.

Struct Una estructura es una agrupacin, bajo un mismo nombre de variable, distintos datos que pueden ser de diferente tipo. Las estructuras vienen a salvar la limitacin de los arrays, que solo almacenan un nico tipo de dato. Una estructura tambin es llamada registro y cabe su analoga con los registros de una tabla, donde un registro tiene varios datos (campos) y estos pueden diferir en su tipo: Ejemplo:

struct usuarios_t { int dni; char nombres[50]; char apellido[30]; time_t nacimiento; }; //un registro usuarios: struct usuarios_t usuario; usuario.dni=27651109 strcpy(usuario.nombres,"Jose Maria"); ... //un array de registros: struct usuarios_t usuarios[10]; usuario[0].dni=27651109 strcpy(usuario[0].nombres,"Jose Maria"); usuario[1].dni=26852789 strcpy(usuario[1].nombres,"Juan Carlos"); ... No es mi intencin sumar complejidad a este resumen, solo quiero agregar que se pueden declarar punteros a estructuras, que los elementos de una estructura pueden ser punteros, que se pueden anidar estructuras, pasar estructuras (como punteros a estructuras) como parmetro de funciones, etc. Union Una union se declara de la misma forma que una estructura, reemplazando struct por union. La diferencia est en que todos los miembros de la union comparten el mismo espacio en memoria, por lo que solo se puede tener almacenado un miembro de ellos en cada momento. El tamao de la union estar dado por el miembro ms largo de la misma. Ejemplo: struct usuarios_t { int dni; char nombres[50]; char apellido[30]; time_t nacimiento; }; union usuario_t usuario; Enum

/* Declaracin de la variable */

Una enumeracin es un conjunto de constantes enteras. A la enumeracin se le puede asignar un nombre, que se comportar como un nuevo tipo de dato que solo podr contener los valores especificados en la enumeracin. Ejemplo: enum dias_semana {LUNES=1, MARTES=2, MIERCOLES=3, JUEVES=4, VIERNES=5, SBADO=6, DOMINGO=7 }; dias_semana dia; dia = LUNES; dia = 1; /* Ambas asignaciones son equivalentes */ Las estructuras son el segundo tipo de datos estructurados que veremos (valga la redundancia). Al contrario que los arrays, las estructuras nos permiten agrupar varios datos, que mantengan algn tipo de relacin, aunque sean de distinto tipo, permitiendo manipularlos todos juntos, usando un mismo identificador, o cada uno por separado. Las estructuras son llamadas tambin muy a menudo registros, o en ingls records. Tienen muchos aspectos en comn con los registros usados en bases de datos. Y siguiendo la misma analoga, cada objeto de una estructura se denomina a menudo campo, o field. Sintaxis:
struct [<identificador>] \{ [<tipo> <nombre_objeto>[,<nombre_objeto>,...]]; } [<objeto_estructura>[,<objeto_estructura>,...];

El identificador de la estructura es un nombre opcional para referirse a la estructura. Los objetos de estructura son objetos declarados del tipo de la estructura, y su inclusin tambin es opcional. Sin bien, an siendo ambos opcionales, al menos uno de estos elementos debe existir. En el interior de una estructura, entre las llaves, se pueden definir todos los elementos que consideremos necesarios, del mismo modo que se declaran los objetos. Las estructuras pueden referenciarse completas, usando su nombre, como hacemos con los objetos que ya conocemos, y tambin se puede acceder a los elementos definidos en el interior de la estructura, usando el operador de seleccin (.), un punto. Una vez definida una estructura, es decir, si hemos especificado un nombre para ella, se puede usar igual que cualquier otro tipo de C++. Esto significa que se pueden declarar ms objetos del tipo de estructura en cualquier parte del programa. Para ello usaremos la forma normal de declaracin de objetos, es decir:

[struct] <identificador> <objeto_estructura> [,<objeto_estructura>...];

En C++ la palabra struct es opcional en la declaracin de objetos, al contrario de lo que sucede en C, en el que es obligatorio usarla. Ejemplo:
struct Persona \{ char Nombre[65]; char Direccion[65]; int AnyoNacimiento; } Fulanito;

Este ejemplo define la estructura Persona y declara a Fulanito como un objeto de ese tipo. Para acceder al nombre de Fulanito, por ejemplo para visualizarlo, usaremos la forma:
cout << Fulanito.Nombre;

Funciones en el interior de estructuras

^ C++, permite incluir funciones en el interior de las estructuras. Normalmente estas funciones tienen la misin de manipular los datos incluidos en la estructura, y su uso est muy relacionado con la programacin orientada a objetos. Aunque esta caracterstica se usa casi exclusivamente con las clases, como veremos ms adelante, tambin puede usarse en las estructuras. De hecho, en C++, las diferencias entre estructuras y clases son muy tenues. Dos funciones muy particulares son las de inicializacin, o constructor, y el destructor. Veremos con ms detalle estas funciones cuando asociemos las estructuras y los punteros. El constructor es una funcin sin tipo de retorno y con el mismo nombre que la estructura. El destructor tiene la misma forma, salvo que el nombre va precedido el smbolo "~". Nota: para aquellos que usen un teclado espaol, el smbolo "~" se obtiene pulsando las teclas del teclado numrico 1, 2, 6, mientras se mantiene pulsada la tecla ALT, ([ALT]+126). Tambin mediante la combinacin [Atl Gr]+[4] y un espacio (la tecla [4] de la zona de las letras, no del teclado numrico). Veamos un ejemplo sencillo para ilustrar el uso de constructores: Forma 1:
struct Punto \{ int x, y;

Punto() \ // Constructor } Punto1, Punto2;

Forma 2:
struct Punto \{ int x, y; Punto(); // Declaracin del constructor } Punto1, Punto2; // Definicin del constructor, fuera de la estructura Punto::Punto() \{ x = 0; y = 0; }

Si no usramos un constructor, los valores de x e y para Punto1 y Punto2 estaran indeterminados, contendran la "basura" que hubiese en la memoria asignada a estas estructuras durante la ejecucin. Con las estructuras ste ser el caso ms habitual, ya que si necesitamos usar constructores para asignar valores iniciales, ser mucho ms lgico usar clases que estructuras. Mencionar aqu, slo a ttulo de informacin, que el constructor no tiene por qu ser nico. Se pueden definir varios constructores, pero veremos esto mucho mejor y con ms detalle cuando veamos las clases. Usando constructores nos aseguramos los valores iniciales para los elementos de la estructura. Veremos que esto puede ser una gran ventaja, sobre todo cuando combinemos estructuras con punteros, en captulos posteriores. Tambin podemos incluir otras funciones, que se declaran y definen como las funciones que ya conocemos. Otro ejemplo:
#include <iostream> using namespace std; struct stPareja \{ int A, B; int LeeA() \ A;} int LeeB() \ B;} void GuardaA(int void GuardaB(int } Par;

// // n) n)

Devuelve el Devuelve el \ // Asigna \ // Asigna

valor de valor de un nuevo un nuevo

A B valor a A valor a B

int main() \{ Par.GuardaA(15); Par.GuardaB(63); cout << Par.LeeA() << endl; cout << Par.LeeB() << endl;

return 0; }

En este ejemplo podemos ver cmo se define una estructura con dos campos enteros, y dos funciones para modificar y leer sus valores. El ejemplo es muy simple, pero las funciones de guardar valores se pueden elaborar para que no permitan determinados valores, o para que hagan algn tratamiento de los datos. Por supuesto se pueden definir otras funciones y tambin constructores ms elaborados e incluso, redefinir operadores. Y en general, las estructuras admiten cualquiera de las caractersticas de las clases, siendo en muchos aspectos equivalentes. Veremos estas caractersticas cuando estudiemos las clases, y recordaremos cmo aplicarlas a las estructuras.

Inicializacin de estructuras
^ De un modo parecido al que se inicializan los arrays, se pueden inicializar estructuras, tan slo hay que tener cuidado con las estructuras anidadas. Por ejemplo:
struct int int int }; A \{ i; j; k;

struct B \{ int x; struct C \{ char c; char d; } y; int z; }; A ejemploA = \; B ejemploB = \, 20};

Cada nueva estructura anidada deber inicializarse usando la pareja correspondiente de llaves "\{}", tantas veces como sea necesario.

Asignacin de estructuras
^

La asignacin de estructuras est permitida, pero slo entre objetos del mismo tipo de estructura, (salvo que se usen constructores), y funciona como la intuicin nos dice que debe hacerlo. Veamos un ejemplo:
struct Punto \{ int x, y; Punto() \ } Punto1, Punto2; int main() \{ Punto1.x = 10; Punto1.y = 12; Punto2 = Punto1; }

La lnea Punto2 = Punto1; equivale a Punto2.x = Punto1.x; Punto2.y = Punto1.y;. Quizs te hayas quedado intrigado por el comentario anterior, que adelantaba que se pueden asignar estructuras diferentes, siempre que se usen los constructores adecuados. Esto, en realidad, se puede extender a cualquier tipo, no slo a estructuras. Por ejemplo, definiendo el constructor adecuado, podemos asignar un entero a una estructura. Veamos cmo hacer esto. Hasta ahora, los constructores que hemos visto no usaban argumentos, pero eso no significa que no puedan tenerlos. Crearemos como ejemplo, una estructura para manejar nmeros complejos. Un nmero complejo est compuesto por dos valores reales, el primero contiene lo que se llama la parte real y el segundo la parte imaginaria.
struct complejo \{ double real; double imaginario; };

Esta estructura es suficiente para muchas de las cosas que podemos hacer con nmeros imaginarios, pero aprovechando que podemos crear funciones, podemos aadir algunas que hagan de una forma ms directa cosas que de otro modo requieren aadir cdigo externo. Por ahora nos limitaremos a aadir unos cuantos constructores. El primero es el ms lgico: un constructor por defecto:
struct complejo \{ complejo() \ double real; double imaginario;

};

Este construtor se usar, por ejemplo, si declaramos un array:

complejo array[10];

El constructor por defecto ser llamado para cada elemento del array, aunque no aparezca tal llamada en ningn punto del programa. Otro constructor nos puede servir para asignar un valor a partir de dos nmeros:
struct complejo \{ complejo() \ complejo(double r, double i) \ double real; double imaginario; };

Mediante este constructor podemos asignar valores inciales en la declaracin:

complejo c1(10.23, 213.22);

Los nmeros reales se consideran un subconjunto de los imaginarios, en los que la parte imaginaria vale cero. Esto nos permite crear otro constructor que slo admita un valor real:
struct complejo \{ complejo() \ complejo(double r, double i) \ complejo(double r) \ double real; double imaginario; };

Este constructor nos permite, como en el caso anterior, inicializar un valor de un complejo en la declaracin, pero tambin nos permite asignar un valor double a un complejo, y por el sistema de promocin automtico, tambin podemos asignar valores enteros o en coma flotante:
complejo c1(19.232); complejo c2 = 1299.212; int x = 10; complejo c3 = x;

Este tipo de constructores se comportan como conversores de tipo, nada nos impide crear constructores con cualquier tipo de parmetro, y tales constructores se podrn usar para convertir cualquier tipo al de nuestra estructura.

Arrays de estructuras
^

La combinacin de las estructuras con los arrays proporciona una potente herramienta para el almacenamiento y manipulacin de datos. Ejemplo:
struct Persona \{ char Nombre[65]; char Direccion[65]; int AnyoNacimiento; } Plantilla[200];

Vemos en este ejemplo lo fcil que podemos declarar el array Plantilla que contiene los datos relativos a doscientas personas. Podemos acceder a los datos de cada uno de ellos:
cout << Plantilla[43].Direccion;

O asignar los datos de un elemento de la plantilla a otro:

Plantilla[0] = Plantilla[99];

Estructuras anidadas
^ Tambin est permitido anidar estructuras, con lo cual se pueden conseguir superestructuras muy elaboradas. Ejemplo:
struct stDireccion \{ char Calle[64]; int Portal; int Piso; char Puerta[3]; char CodigoPostal[6]; char Poblacion[32]; }; struct stPersona \{ struct stNombre \{ char Nombre[32]; char Apellidos[64]; } NombreCompleto; stDireccion Direccion; char Telefono[10]; }; ...

En general, no es una prctica corriente definir estructuras dentro de estructuras, ya que tienen un mbito local, y para acceder a ellas se necesita hacer referencia a la estructura ms externa. Por ejemplo para declarar un objeto del tipo stNombre hay que utilizar el operador de acceso (::):
stPersona::stNombre NombreAuxiliar;

Sin embargo para declarar un objeto de tipo stDireccion basta con declararla:
stDireccion DireccionAuxiliar;

STRUCTURAS EN LENGUAJE C
Las estructuras ya estaban presentes en C. Hay quien las ve como una clase, pero sin mtodos (solo almacena datos). Supongamos que queremos hacer una agenda con los nmeros de telfono de nuestros amigos. Necesitaramos un array de Cadenas para almacenar sus nombres, otro para sus apellidos y otro para sus nmeros de telfono. Esto puede hacer que el programa quede desordenado y difcil de seguir. Y aqu es donde vienen en nuestro auxilio las estructuras. Para definir una estructura usamos el siguiente formato:
struct nombre_de_la_estructura { campos de estructura; };

NOTA: Es importante no olvidar el ';' del final. Vamos a crear una declaracion de estructura llamada amigo:
struct estructura_amigo { char nombre[30]; char apellido[40]; char telefono[10]; char edad; };

A cada elemento de esta estructura (nombre, apellido, telfono) se le llama campo o miembro.

Una vez definida la estructura, podemos usarla declarando una variable con esa estructura:
struct estructura_amigo amigo;

Ahora la variable amigo es de tipo estructura_amigo. Para acceder al nombre de amigo usamos: amigo.nombre. Arrays de estructuras Supongamos ahora que queremos guardar la informacion de varios amigos. Con una variable de estructura solo podemos guardar los datos de uno. Necesitamos declarar arrays de estructuras:
struct estructura_amigo amigo[10];

Ahora necesitamos saber como acceder a cada elemento del array. La variable definida es amigo, por lo tanto para acceder al primer elemento usaremos amigo[0] y a su miembro nombre: amigo[0].nombre. Inicializar una estructura Primero se define la estructura y luego al declarar una variable como estructura le damos el valor inicial que queramos. Ejemplo:
struct estructura_amigo amigo = { 'Juanjo', 'Lopez', '592-0483', 30 };

Por supuesto hemos de meter en cada campo el tipo de datos correcto. Punteros a estructuras Primero hay que definir la estructura igual que antes, pero al declarar la variable de tipo estructura debemos ponerle el operador '*' para indicarle que es un puntero. Es importante recordar que un puntero no debe apuntar a un lugar cualquiera, debemos darle una direccion valida donde apuntar. No podemos por ejemplo crear un puntero a estructura y meter los datos directamente mediante ese puntero, no sabemos donde apunta el puntero y los datos se almacenaran en un lugar cualquiera. Y para comprender como funcionan nada mejor que un ejemplo. Este programa utiliza un puntero para acceder a la informacion de la estructura:
#include <stdio.h>

struct estructura_amigo { char nombre[30]; char apellido[40]; char telefono[10]; int edad; }; struct estructura_amigo amigo = { 'Juanjo', 'Lopez', '592-0483', 30 }; struct estructura_amigo *p_amigo; int main() { p_amigo = &amigo; printf( '%s tiene ', p_amigo->apellido ); printf( '%i aos ', p_amigo->edad ); printf( 'y su telfono es el %s.\n' , p_amigo->telefono ); }

p_amigo es un puntero a la estructura estructura_amigo. Dado que es un puntero tenemos que indicarle donde debe apuntar, en este caso vamos a hacer que apunte a la variable amigo:
p_amigo = &amigo;

El operador & que significa 'dame la direccion donde esta almacenado...'. Para acceder a cada campo de la estructura antes lo hacamos usando el operador '.', pero, como muestra el ejemplo, si se trabaja con punteros se debe usar el operador '>'. Punteros a arrays de estructuras Por supuesto tambin podemos usar punteros con arrays de estructuras. Paso de estructuras a funciones Las estructuras se pueden pasar directamente a una funcion igual que hacamos con las variables. Ejemplo: int suma( struct estructura_amigo arg_amigo ) { return arg_amigo.edad+20;

Estructuras C/C++
Definicin 3 Una estructura es un grupo de variables las cuales pueden ser de diferentes tipos sostenidas o mantenidas juntas en una sola unidad. La unidad es la estructura.

Sintaxis y reglas para estructuras en C/C++

En C/C++ se forma una estructura utilizando la palabra reservada struct, seguida por un campo etiqueta opcional, y luego una lista de miembros dentro de la estructura. La etiqueta opcional se utiliza para crear otras variables del tipo particular de la estructura:
struct campo_etiqueta{ tipo_miembro miembro_1; tipo_miembro miembro_2; tipo_miembro miembro_3; : : tipo_miembro miembro_n; };

Un punto y coma finaliza la definicin de una estructura puesto que sta es realmente una sentencia C/C++ . Algunos de los ejemplos usan la estructura:
struct stbarco{ char sztipo[iString15+iNull_char]; char szmodelo[iString15+iNull_char]; char sztitular[iString20+iNull_char]; int ianio; long int lhoras_motor; float fprecioventa; };

En un programa, podemos asociar una variable con una estructura utilizando una sentencia similar a la siguiente:
struct stbarco stbarco_usado;

La sentencia define stbarco_usado de tipo struct stbarco. La declaracin requiere el uso del campo etiqueta de la estructura. Si esta sentencia est contenida dentro de una funcin, entonces la estructura, llamada stbarco_usado, tiene un mbito local a esa funcin. Si la sentencia est contenida fuera de todas las funciones de programa, la estructura tendr un mbito global. Es posible declarar una variable usando esta sintaxis:
struct stbarco{ char sztipo[iString15+iNull_char]; char szmodelo[iString15+iNull_char]; char sztitular[iString20+iNull_char]; int ianio; long int lhoras_motor; float fprecioventa; } stbarco_usado;

Aqu la declaracin de variable va antes del punto y coma final. Cuando se asocia slo una variable con el tipo estructura, el campo etiqueta puede ser eliminado, por lo que sera posible escribir:

struct { char sztipo[iString15+iNull_char]; char szmodelo[iString15+iNull_char]; char sztitular[iString20+iNull_char]; int ianio; long int lhoras_motor; float fprecioventa; } stbarco_usado;

Utilizacin de miembros de estructuras

Para accesar a los miembros de las estructuras se usa el punto u operador miembro (.). La sintaxis es:
estructuraNombre.miembroNombre

Por ejemplo en:

gets(stbarco_usado.szmodelo);

Aqu, stbarco_usado es el nombre asociado con la estructura, y szmodelo es una variable miembro de la estructura, otro ejemplo:
std::cin>> stbarco_usado.sztipo;

Esta sentencia leer la marca del stbarco_usado en el arreglo de caracteres, mientras la prxima sentencia imprimir el precio de venta de stbarco_usado en la pantalla.
srd::cout<< stbarco_usado.fprecioventa;

Ejemplo de estructuras:
/* fractionStruct.cpp -

Programa para demostrar el uso de los tipos Struct en C++, este tipo de datos es util para los programadores para crear sus propias estructuras de tipos. */ #include <iostream> using namespace std; // Definimos un nuevo tipo de estructura llamada Fraction // como la definicion se puso antes del "main" // los tipos Fraction se pueden usar como prototipos struct Fraction { // declaramos sus dos miembros int numerator; int denominator; }; // Note el punto y coma al final

// funciones prototipos void getFraction(Fraction &f); void printFraction(const Fraction &f); int main (int argc, char * const argv[]) { // declaramos variables de tipo Fraction Fraction f1, f2; // obtenemos dos fracciones y las desplegamos getFraction(f1); cout << "\nf1 = "; printFraction(f1); getFraction(f2); cout << "\nf2 = "; printFraction(f2); cout << endl; return 0; } // pedimos al usuario los valores del denominador y numerador // los almacenamos en su adecuado lugar en la estrcututra; checamos si // el valor del denominador es valido y lo ponemos en 1 si no lo es. void getFraction(Fraction &f) { cout << "\nEnter the numerator: "; cin >> f.numerator; cout << "Enter the denominator: "; cin >> f.denominator; if (f.denominator == 0) { cout << "\nIllegal denominator! Denominator is being set to 1.\n"; f.denominator = 1; } } // imprimimos la fraccion void printFraction(const Fraction &f) { cout << f.numerator << "/" << f.denominator << "\n"; }

Nota sobre las funciones prototipos: Las funciones prototipo tienen los siguientes usos importantes:

Establecen el tipo devuelto para las funciones que devuelven otros tipos diferentes que int. Aunque las funciones que devuelven valores enteris no necesitan prototipos, se recomienda tener prototipos. Sin prototipos completos, se hacen las conversiones estndares, pero no se checan los tipos o los nmeros de argumentos con el nmero de parmetros.

Los prototipos se usan para inicializar apuntadores a funciones, antes de que las funciones sean definidas. La lista de parmetros se usa para checar la correspondencia de los argumentos en la llamada a la funcin con los parmetros en la definicin de la funcin

const

en parmetros de funciones

El especificador const puede ser utilizado en la definicin de parmetros de funciones. Esto resulta de especial utilidad en tres casos. En los tres el fin que se persigue es el mismo: indicar que la funcin no podr cambiar dichos argumentos:

Con parmetros de funciones que sean de tipo matriz (que se pasan por referencia). Ejemplo: int strlen(const char[]); Cuando los parmetros son punteros (a fin de que desde dentro de la funcin no puedan ser modificados los objetos referenciados). Ejemplo: int printf (const char
*format, ...);

Cuando el argumento de la funcin sea una referencia, previniendo as que la funcin pueda modificar el valor referenciado. Ejemplo: int dimen(const X &x2);