Programación I (2.

5)
Nombre: Cristian Pineida

NRC: 2838

Tema: Recursividad en C++

Marco Teórico
Estructuras
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 algún tipo de relación, aunque sean de distinto tipo, permitiendo
manipularlos todos juntos, usando un mismo identificador, o cada uno por
separado.
Las estructuras son llamadas también muy a menudo registros, o en inglés records.
Tienen muchos aspectos en común con los registros usados en bases de datos. Y
siguiendo la misma analogía, 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
inclusión también es opcional. Sin bien, aún 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 también se puede acceder a los elementos
definidos en el interior de la estructura, usando el operador de selección (.), 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 más objetos del tipo de estructura en cualquier parte del programa.
Para ello usaremos la forma normal de declaración de objetos, es decir:

[struct] <identificador> <objeto_estructura>

[,<objeto_estructura>...];

En C++ la palabra struct es opcional en la declaración 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;

De un modo parecido al que se inicializan los arrays, se pueden inicializar

estructuras, tan sólo hay que tener cuidado con las estructuras anidadas. Por
ejemplo:

struct A {
int i;
int j;
int k;
};

struct B {
int x;
struct C {
char c;
char d;
} y;
int z;
};

A ejemploA = {10, 20, 30};

B ejemploB = {10, {'a', 'b'}, 20};
 Marco practico
Ejercicio propuesto
1.-Elaborar una estructura de tipo fecha que lea la cedula, un
nombre respectivo y su sueldo y que al final sume los sueldos de
los tres empleados usando estructuras.
Código Fuente
#include <stdio.h>
#include <iostream>
#include <math.h>

using namespace std;

struct fecha{
int dia;
int mes;
int anio;
};

struct empleado{

int cedula[10];
char nombre[20];
int sueldo;
fecha fn;
};

void leer(struct empleado a1,struct fecha fn);

int main(){

empleado a1[3];
fecha fn[3];

for(int i=0;i<3;i++){

printf("Ingrese la cedula ==>");

fflush(stdin);
scanf("%d",&a1[i].cedula);
puts("Ingrese Nombre");
fflush(stdin);
 gets(a1[i].nombre);
puts("Ingrese su sueldo");
fflush(stdin);
scanf("%d",&a1[i].sueldo);
puts("Ingrese dia nacimiento");
fflush(stdin);
scanf("%d",&fn[i].dia);
puts("Ingrese mes nacimiento");
fflush(stdin);
scanf("%d",&fn[i].mes);
puts("Ingrese anio nacimiento");
scanf("%d",&fn[i].anio);
}

printf("\nRESULTADOS:\n\n");

for(int i=0;i<3;i++){

printf("Cedula: %d\n",a1[i].cedula);
printf("Nombre: ");
puts(a1[i].nombre);
printf("Sueldo:");
printf("%d\n",a1[i].sueldo);
printf("Fecha de nacimiento:");
printf("%d/",fn[i].dia);
printf("%d/",fn[i].mes);
printf("%d\n",fn[i].anio);
}

printf("\n");

int acum=0;

for(int i=0;i<3;i++){

acum=acum+a1[i].sueldo;
}
printf("El sueldo de las personas enlistadas es %d",acum);

}
Captura de pantalla de la ejecución del código:
Conclusiones:
 Al contrario que los arrays, las estructuras nos permiten agrupar varios
datos, que mantengan algún tipo de relación, aunque sean de distinto tipo,
permitiendo manipularlos todos juntos, usando un mismo identificador, o
cada uno por separado.
 Las estructuras son llamadas también muy a menudo registros. Tienen
muchos aspectos en común con los registros usados en bases de datos. Y
siguiendo la misma analogía, cada objeto de una estructura se denomina a
menudo campo, o field.Toda función recursiva
 El identificador de la estructura es un nombre opcional para referirse a la
estructura.

Recomendaciones:
Para leer datos de tipo char e imprimirlos es muy eficiente utilizar el
comando gets(leer) y puts(imprimir).
Es aconsejable realizar los prototipos de la función
Para evitar inconvenientes es mejor leer e imprimir los datos de la
estructura desde el main aunque no es una manera eficiente de procesar
datos en una estructura

Bibliografía:
http://c.conclase.net/curso/?cap=011

https://es.wikibooks.org/wiki/Programaci%C3%B3n_en_C%2B%2B/Estructuras