P t

Contenido

(apuntador)

a punteros a constantes

defunciones

… Punteros a punteros

… Direcciones en memoria … Aritmética de punteros… Concepto de puntero … Punteros constantes frente

… Puntero null y void … Punteros como argumento

… Punteros a Arrays … Punteros a funciones

… Arrays de punteros … Punteros a estructuras

… Punteros a cadenas …

Dirección

de memoria

†Int n;

†Asocia al nombre n, el tipoint

y la dirección dealgunaposición de memoria donde se almacena el valor de

n

… Cuando una variable se declara, se asociantres atributos fundamentales con la misma: sunombre, su tipo y su dirección de memoria

P i tf % )

Cont…

†Printf (“%d”,n);

… A la dirección de la variable se accede por mediodeloperador

dedirección &.

Por

ejemplo,

se

puedeimprimir la dirección de n

conla sentencia:†Printf (“%p”,&n);

… Al valor de la variable se accede por medio desu nombre. Por ejemplo, se puede imprimir elvalor de n con la sentencia;

l d

{

Ejemplo 10.1… Obtener el valor y la dirección de una variable

† #include <stdio.h>

† #include <stdlib.h>

† int main ()

† {

† int n=75;

† printf("n=%d\n",n);

† printf("&n=%p\n",&n);

† system("pause");

† return 0;

† }

En posición almacenan datos los apunta puntero

Concepto de puntero (apuntador)… El tipo de variable que almacena una dirección se denomina puntero

… Los punteros se rigen por estas reglas básicas:†Un puntero es una variable como cualquier otra;

enmemoria

†Una variable puntero contiene una dirección que apunta a otraposición

†En esa posición se almacenan los datos a los que apunta el puntero

†Un puntero apunta a una variable de memoria

… Un puntero es una variable que contiene una dirección de memoria

i l d dlib h

i

("& % " &

}

Ejemplo 10.2… #include <stdio.h>

… #include <stdlib.h>

… int main ()

… {

… int n=75;

… int*p=&n;

… printf("n=%d, &n=%p, p=%p\n",n,&n,p);

… printf("&p=%p\n",&p);

… system("PAUSE");

… return 0;

… }

asterisco

Fl t

Declaración de punteros

compilador el tipo de dato alque

apunta elpuntero;para ello s

ehace

preceder

a su

nombre

con

unasterisco

(*)… <tipo de dato apuntado>*<identificador de puntero>

… Float*f;

… Al igual que cualquier variable, las variablespunteros han de ser declaradas antes deutilizarlas. La declaración de una variablepuntero debe indicar al

Inicialización depunteros

dirección del

dato correspondiente.

Para asignar

unadirección de memoria a un puntero se utiliza el

operador de referencia &.

†Int *p;

†P=&i; /*asigna la dirección de i a p*/

†*p=50; /*asigna un valor a la dirección de memoria*/

… &valor†Int i;

… La inicialización de un puntero proporciona a ese punterola

}

Indireccion de punteros… El uso de un puntero

para obtener elvalor

… #include <stdlib.h>

…

char*pc;

…

for(c='A';c<='Z';c++)…

printf("\n");…

return0;

…

… #include <stdio.h>

charc;

… int main()

al que apunta, es decir, … {

su dato apuntado se … pc=&c;

denomina indireccionar …

printf("%c",*pc);

el puntero …

system("pause");

… }

lid

Punteros null y void

valido enmemoria

†Int *ptr=0;

… Los punteros nulos se utilizan confrecuencia punteros

en programas con arraysde

… En C se puede declarar un puntero de modo que apunte acualquier tipo de dato, es decir, no se asigna a un tipo de datoespecifico. El método es declarar el puntero como puntero void*denominado puntero genérico

†Void *prt

… Un puntero nulo no apunta a ninguna parte, no direcciona ningúndato

†#define NULL 0

… Otra forma de declarar un puntero nulo es asignar un valor de 0

Punteros a punteros… Un puntero puede apuntar a otra variable puntero.

Este

concepto se utiliza con mucha frecuencia enprogramas

complejos de C. para declarar un puntero a unpuntero

se hace preceder a la variable con dos asteriscos(**)

†Int valor_e=100;

†Int *ptr1=&valor_e;

†Int **ptr5=&ptr1;

ú i d

Punteros y Arrays

arrays, implica quesede datos enelementos

pueden almacenarcadenasde arrays. Sin punteroseso

no es

posible, yaque

noexiste

el tipo de datocadena

en C. no existen

variables

de cadena,únicamente constantes de cadena

… Se pueden direccionar arrays como sifueran punteros y punteros como si fueranarrays. La posibilidad de almacenar yacceder a punteros y

0

Nombres de arrays como

punteros

Supongamos

que se

tiene

la siguiente

declaración

de unarray:

… In lista[5]={10,20,30,40,50}

visualizar *lista. Como un nombre de un array es unpuntero,

primer elemento del array, se debe indireccionar elpuntero

… Si se manda a visualizar lista[0] se vera 10 y si se mandaa

también se vera 10

… Dado que un nombre de un array contiene ladirección del

para obtener el valor del elemento

… Un nombre de un array es simplemente un puntero.

siguiente un de variables a

Arrays de punteros

contiene

como elementos

punteros,

cada uno

de loscuale

sapunta

a untipo

de datoespecifico.

La lineasiguiente reserva un array de diez variablespuntero aenteros:

… Int *ptr[10];

… Si se necesita reservar muchos punteros amuchos valores diferentes, se puede declara unarray de punteros. Un array de punteros esun array que

* [12]={“ ” ”f b ” ” ” ”

b ” ” i b ” ”di i b ”}

Inicialización de un array de punteros a cadenas… La inicialización de un array de punteros acadenasse puede realizar con una declaración

similar a

esta;

… Char

*nombres_meses[12]={“enero”,”febrero”,”marzo”,”

abril”,”mayo”,”junio”,”julio”,”agosto”,”septiembre”,”

octubre”,”noviembre”,”diciembre”};

Punteros de cadenas

alfabeto;

… Char alfabeto[27]=“ABCDE….z”;… P=&alfabeto[0]

Printf(“%c\n”,*p);

… Los punteros se pueden utilizar en lugar deíndices de arrays. Considérese la siguientedeclaración de un array de caracteres quecontiene las letras del

d t d

A puntero le sumar restar entero ; hace apunte

Aritmética de punteros

se puede modificar, un puntero es una variable que se puedemodificar.

sobre punteros

n posiciones adelante, o atrás del actual. Las operaciones novalidas son;

… Al contrario que un nombre de un array, que es un puntero constante yno

Como consecuencia, se pueden realizar ciertas operacionesaritméticas

… A un puntero se le puede sumar o restar un entero n; esto hace

que apunte suma, multiplicación o división entre dos punteros

†Float m[20];

†Float *r;

†r=m;

†r++

Punteros constantes frente a punteros a constantes… Un puntero constante es un puntero que no sepuedecambiar, pero que los datos apuntados por el

puntero pueden ser cambiados. Por otra parte,un

puntero a una constante se puede modificarpara

apuntar a una constante diferente, pero losdatos

apuntados por el puntero no se puedencambiar

Punteros constantes

se debe utilizar el siguiente formato:†<Tipo de dato>*const<nombre puntero>=<dirección

de variable>;

†p1=&y , no es legal ya que se cambia el valor del puntero

†Int x;

†Int y;

†Int *const p1=&x;

†*p1=y, es legal ya que se cambia el contenido de memoria

… Para crear un puntero constante diferente de un array,

* 1 15 d il ió

Punteros a constantes

†Const

†Const

†Const

int

int

int

x=25;

y=50;

*p1=&x;

†P1=&y, p1 apunta a otra constante†*p1=15, crea un error de compilación

… El formato para definir un puntero a una constante es;

†Const<tipo de dato elemento>*<nombre puntero>=<dirección de constante>;

Punteros constantes a constantes

a constantes utilizando el formatosiguiente;†Const <tipo de dato elemento

>*const

<nombrepuntero>=<direccion de

constante>;

entera

x, cualquier

intento

de modificar

p1 o bien *p1

†Const int x=25;

†Const int *const p1=&x;

†P1 es un entero constante que apunta a una constante

producirá un error

… El ultimo caso a considerar es crear punterosconstantes

6 7

Punteros como argum

ntos de f

nciones

no se puede cambiar el valor de esa variable. Sinembargo,si se pasa un puntero a una variable a una función(paso por dirección) se puede cambiar el valor de la variable†Void func1 (int *s, int t) int i, j;

†{ i=5;

†*s=6; j=7;

†t=25; func1 (&i, j);

†}

… Cuando se pasa una variable a una función (paso porvalor)

Caracteres Valor entero representado como caracter entre comillas simples. Por ejemplo: 'z' representa al

valor entero de z

Internamente se representa como un tipo de dato enumerado usando el código ASCII (código estándar americano para el intercambio de información).

Cadenas Es un arreglo de caracteres que:

Puede incluir letras, dígitos y caracteres especiales (*, /, $)

Tiene un puntero al primer caracter

Cuyo valor de la cadena es la dirección de memoria del primer elemento.

1. Los códigos para los caracteres que representan dígitos del 0 al 9 son consecutivos.

2. Las letras en el alfabeto están divididos en dos rangos: uno para las mayúsculas (A-Z) y otro para las minúsculas (a-z). Sin embargo dentro de cada rango los valores ASCII son consecutivos.

Es un estándar para referirse a un carácter específico en C.

Para referirse al código ASCII de la letra A, se especifica ‘A’, el cual es el 65.

Para referirse al código del carácter 9, de forma similar, ‘9’.

CUIDADO: El referirse al carácter, no es lo mismo que referirse al valor

entero. El 9 es diferente del ‘9’.

Se puede:

Sumar un entero a un carácter

Restar un entero de un caracter

Restar un caracter de otro

Comparar dos caracteres entre sí

CUIDADO: Al sumar o restar el resultado no debe salirse del rango

de representación ASCII

Definición Como un arreglo de caracteres o una variable de tipo char *

char color[] = "blue";char *colorPtr = "blue";

Recuerde que una cadena se representa como un arreglo de caracteres y termina con '\0' color tiene 5 elementos

Lectura Utilizando scanf

scanf("%s", cadena); Copia la entrada en el arreglo cadena[] No se necesita el & (porque una cadena es un puntero)

Recuerde dejar espacio en el arreglo para el fin de cadena'\0‘

Escritura Utilizando printf

printf(“%s”,cadena);

char RandomLetra(void){

return (RandomInteger (‘A’, ‘Z’));}

bool esMayuscula (char ch) {

return (ch >= ‘A’ && ch <=‘Z’);}

bool esDigito (char ch)

{

return (ch >= ‘0’ && ch <=‘9’);

}

bool esMinuscula (char ch)

{

return (ch >= ‘a’ && ch <=‘z’);

}

Contiene un gran número de funciones para determinar el tipo de carácter, entre las principales tenemos:

islower(ch) retorna TRUE si el carácter ch es minúscula

isupper(ch) retorna TRUE si el carácter ch es mayúscula

isalpha(ch) retorna TRUE si ch es un valor alfabético

isdigit(ch) retorna TRUE si ch es un dígito

isalnum(ch) retorna TRUE si ch es un valor alfanumérico

ispunct(ch) retorna TRUE si ch es un símbolo de puntuación

isspace(ch) retorna TRUE si ch es un carácter en blanco

Prototype Description

int isdigit( int c ); Returns true if c is a digit and false otherwise.

int isalpha( int c ); Returns true if c is a letter and false otherwise.

int isalnum( int c ); Returns true if c is a digit or a letter and false otherwise.

int isxdigit( int c ); Returns true if c is a hexadecimal digit character and false otherwise.

int islower( int c ); Returns true if c is a lowercase letter and false otherwise.

int isupper( int c ); Returns true if c is an uppercase letter; false otherwise.

int tolower( int c ); If c is an uppercase letter, tolower returns c as a lowercase letter. Otherwise, tolower

returns the argument unchanged. int toupper( int c );

If c is a lowercase letter, toupper returns c as an uppercase letter. Otherwise, toupper

returns the argument unchanged. int isspace( int c );

Returns true if c is a white-space character—newline ('\n'), space (' '), form feed

('\f'), carriage return ('\r'), horizontal tab ('\t'), or vertical tab ('\v')—and false

otherwise int iscntrl( int c );

Returns true if c is a control character and false otherwise. int ispunct( int c );

Returns true if c is a printing character other than a space, a digit, or a letter and false

otherwise. int isprint( int c );

Returns true value if c is a printing character including space (' ') and false otherwise.

int isgraph( int c ); Returns true if c is a printing character other than space (' ') and false otherwise.

Convierte cadenas de dígitos a enteros y valores de punto flotante.

Function prototype Function description double atof( const char *nPtr ); Converts the string nPtr to double.

int atoi( const char *nPtr ); Converts the string nPtr to int.

long atol( const char *nPtr ); Converts the string nPtr to long int.

double strtod( const char *nPtr, char **endPtr );

Converts the string nPtr to double.

long strtol( const char *nPtr, char **endPtr, int base );

Converts the string nPtr to long.

unsigned long strtoul( const char *nPtr, char **endPtr, int base );

Converts the string nPtr to unsigned long.

Function prototype Function description int getchar( void ); Inputs the next character from the standard input and re-

turns it as an integer.

char *gets( char *s ); Inputs characters from the standard input into the array s

until a newline or end-of-file character is encountered. A

terminating null character is appended to the array. int putchar( int c ); Prints the character stored in c. int puts( const char *s ); Prints the string s followed by a newline character. int sprintf( char *s, const char *format, ... );

Equivalent to printf, except the output is stored in the

array s instead of printing it on the screen. int sscanf( char *s, const char *format, ... );

Equivalent to scanf, except the input is read from the array

s instead of reading it from the keyboard.

Incluye funciones para: Manipular cadenas

Búsqueda en cadenas

Manejo de tokens

Determine la longitud de cadenas

Function prototype Function description char *strcpy( char *s1, const char *s2 )

Copies string s2 into array s1. The value of s1 is returned.

char *strncpy( char *s1, const char *s2, size_t n )

Copies at most n characters of string s2 into array s1. The value of s1

is returned.

char *strcat( char *s1, const char *s2 )

Appends string s2 to array s1. The first character of s2 overwrites the

terminating null character of s1. The value of s1 is returned. char *strncat( char *s1, const char *s2, size_t n )

Appends at most n characters of string s2 to array s1. The first

character of s2 overwrites the terminating null character of s1. The

value of s1 is returned.

int strcmp( const char *s1, const char *s2 );

Compara string s1 con s2 Retorna:

Un número negativo si s1 < s2

Cero,si s1 == s2

Un número positivo si s1 > s2

int strncmp(const char *s1,const char *s2,size_t n);

Compara n caracteres de s1 en s2 Retorna valores como los anteriores

Function prototype Function description

char *strchr( const char *s, int c );

Locates the first occurrence of character c in string s. If c is found, a

pointer to c in s is returned. Otherwise, a NULL pointer is returned.

size_t strcspn( const char *s1, const char *s2 );

Determines and returns the length of the initial segment of string s1

consisting of characters not contained in string s2.

size_t strspn( const char *s1, const char *s2 );

Determines and returns the length of the initial segment of string s1

consisting only of characters contained in string s2.

char *strpbrk( const char *s1, const char *s2 );

Locates the first occurrence in string s1 of any character in string s2.

If a character from string s2 is found, a pointer to the character in

string s1 is returned. Otherwise, a NULL pointer is returned.

char *strrchr( const char *s, int c );

Locates the last occurrence of c in string s. If c is found, a pointer to c

in string s is returned. Otherwise, a NULL pointer is returned.

char *strstr( const char *s1, const char *s2 );

Locates the first occurrence in string s1 of string s2. If the string is

found, a pointer to the string in s1 is returned. Otherwise, a NULL

pointer is returned.

char *strtok( char *s1, const char *s2 );

A sequence of calls to strtok breaks string s1 into “tokens”—logical

pieces such as words in a line of text—separated by characters

contained in string s2. The first call contains s1 as the first argument,

and subsequent calls to continue tokenizing the same string contain

NULL as the first argument. A pointer to the current token is returned

by each call. If there are no more tokens when the function is called,

NULL is returned.

Una estructura (también llamada registro) es un tipo de datos que agrupa

varios datos de tipo simple en un solo objeto.

Las estructuras se declaran con la palabra reservada struct.

struct nombre{

campos;

};

Cada campo esta formado por la declaración de una o más variables de algún

otro tipo. Ejemplo:

struct persona{

char nombre[30];

int edad;

};

nombre (cadena) edad (int)

persona

Campos

Una vez definida la estructura se pueden declarar variables de ese tipo:

struct persona{

char nombre[30];

int edad;

};

persona juan, maria; o

struct persona juan, maria;

La asignación se hace mediante el operador “.”

gets(juan.nombre);

juan.edad = 23;

gets(maria.nombre);

maria.edad = 17;

TAMBIEN

struct persona{

char nombre[30];

int edad;

}juan, maria;

#include <stdio.h>

#include <conio.h>

#include <string.h>

struct persona{

char nombre[30];

int edad;

};

main(){

persona per1,per2;

strcpy(per1.nombre,"pedro");

strcpy(per2.nombre,"maria");

per1.edad = 23;

per2.edad = 17;

printf("nombre: %s\nedad: %d\n",per1.nombre,per1.edad);

printf("nombre: %s\nedad: %d\n",per2.nombre,per2.edad);

getch();

}

struct carta{

int numero;

char palo;

}

numero palo

Carta de baraja

struct libro{

char titulo[40];

char autor[30];

char editorial[20];

int anyo;

}

titulo autor

Libro

editorial anyo

struct poligono{

char nombre[20];

int lados;

float longitudLado,

area;

}

nombre lados

Polígono regular

longitudLado

area

struct carta c1;

c1.numero = 3;

c1.palo = ‘D’;

struct libro L1;

strcpy(L1.titulo,”Piensa en C”);

strcpy(L1.autor,”Osvaldo Cairó”);

strcpy(L1.editorial,”Pearson”);

L.anyo = 2006;

struct poligono p;

strcpy(p.nombre,”hexagono”);

p.lados = 6;

p.longitudLado = 5;

p.area = p.lados*p.longitudLado*p.longitudLado/2.0/

tan(PI/p.lados);

struct alumno{

int matricula;

char nombre[20];

char carrera[20];

float promedio;

char direccion[20];

};

matricula nombre carrera direccionpromedio

alumno

main(){

struct alumno a1={120,"Maria","Contabilidad",8.9,"Queretaro"},a2;

printf("\nIngrese la matricula del alumno 2:");

scanf("%d",&a2.matricula);

fflush(stdin);

printf("\nIngrese el nombre del alumno 2:");

gets(a2.nombre);

printf("\nIngrese la carrera del alumno 2:");

gets(a2.carrera);

printf("\nIngrese el promedio del alumno 2:");

scanf("%f",&a2.promedio);

fflush(stdin);

printf("\nIngrese la direccion del alumno 2:");

gets(a2.direccion);

printf("\nDatos del alumno 1\n");

printf("%d\n",a1.matricula);

puts(a1.nombre);

puts(a1.carrera);

printf("%.2f\n",a1.promedio);

puts(a1.direccion);

printf("\nDatos del alumno 2\n");

printf("%d\n",a2.matricula);

puts(a2.nombre);

puts(a2.carrera);

printf("%.2f\n",a2.promedio);

puts(a2.direccion);

getch();

}

CURP marca modelo anyo placa

Defina estructuras para los siguientes datos y escriba un ejemplo de inicialización

de una variable con llaves y campo por campo.

Registro de automóviles

Cliente de videoclub

nombre direccion telefono

Licencia de manejo

nombres apellidoPaterno apellidoMaterno fechaDesde fechaVencimiento

nacionalidad grupoSanguineo CURPoRFC restricciones donaOrganos

clave direccion

adeuda

Tarjeta de crédito

nombre fechaVencimiento numeroTarjeta saldo limite

El operador = se puede utilizar para asignar todos los campos de una estructura

a otra.

Ejemplo:

struct libro{

char titulo[30], autor[30], editorial[15];

int anyo,edicion;

};

main(){

libro a = {“El Quijote”,”Cervantes”,”Limusa”,1987,2},b;

b = a;//copia todos los datos de a en b

}

Para acceder a una estructura mediante un apuntador se utiliza la siguiente notación:

(*estructura).campo o estructura->campo

Es necesario crear mediante new la estructura antes de usarla.

Ejemplo:struct alumno{

int matricula;

char nombre[20];

char carrera[20];

float promedio;

char direccion[20];

};

main(){

alumno *a;

a = new(struct alumno);

(*a).matricula = 234; a->matricula = 234;

strcpy((*a).nombre,"Juan Perez"); strcpy(a->nombre,"Juan Perez");

strcpy((*a).carrera,"Mate"); strcpy(a->carrera,"Mate");

(*a).promedio = 6.7; a->promedio = 6.7;

strcpy((*a).direccion,"Lomas 34"); strcpy(a->direccion,"Lomas 34");

}

#include <stdio.h>

#include <conio.h>

#include <string.h>

struct dir{

char calle[20];

int numero;

char colonia[20];

int cp;

};

dir dameDir(){

dir a={"alamo",43,"lomas",78000};

return a;

}

main(){

dir b;

b = dameDir();

printf("calle: %s %d\n",b.calle,b.numero);

printf("colonia: %s\n",b.colonia);

printf("CP: %d\n",b.cp);

getch();

}

Una función puede regresar una

estructura

Las estructuras se pasan como parámetros a las funciones de la

misma forma que las variables de tipo simple.

Función para escribir datos de un alumno:

void escribeAlumno(struct alumno a){

printf("\nDatos del alumno\n");

printf("%d\n",a.matricula);

puts(a.nombre);

puts(a.carrera);

printf("%.2f\n",a.promedio);

puts(a.direccion);

}

Función para leer un alumno:

void lectura(struct alumno *a){

printf("\nIngrese la matricula del alumno:");

scanf("%d",&(*a).matricula);

fflush(stdin);

printf("\nIngrese el nombre del alumno:");

gets(a->nombre);

printf("\nIngrese la carrera del alumno:");

gets((*a).carrera);

printf("\nIngrese el promedio del alumno:");

scanf("%f",&a->promedio);

fflush(stdin);

printf("\nIngrese la direccion del alumno:");

gets(a->direccion);

}

(*estructura).campo estructura->campo

Un número racional se define como el cociente de dos enteros, por ejemplo:

3/4, 5/6, 32/40, 7=7/1, etc.

Podemos representarlos mediante una estructura como sigue:

struct racional{

int num,den;

};

Note que no basta con comparar numerador y denominador para determinar

la igualdad de dos racionales. Es decir, 4/6 es igual a 2/3, pero 4 2 y 6 3.

Para establecer la igualdad de dos racionales debemos asegurar que estén

en su forma reducida. Es decir, que numerador y denominador sean primos

entre sí.

El algoritmo de Euclides permite reducir un número racional.

1. Sea a el mayor y b el menor entre numerador y denominador.

2. Divídase a entre b y sea q el cociente y r el residuo.

3. Hágase a = b y b = r

4. Repítase desde el paso 2 hasta que b sea 0.

5. Divídase numerador y denominador entre a.

a b q r

340 45 7 25

45 25 1 20

25 20 1 5

20 5 4 0

5 0

num=340, den=45

num=340/5 = 68

den=45/5 = 9

num=140, den=26 num=380, den=44 num=830, den=675

void reduce(racional *r){

int a,b,t;

if(r->num>r->den){

a = r->num;

b = r->den;

}else{

a = r->num;

b = r->den;

}

while(b){

t = a % b;

a = b;

b = t;

}

r->num = r->num/a;

r->den = r->den/a;

}

bd

cbad

d

c

b

a

racional suma(racional a, racional b){

racional c;

c.num = (a.num*b.den+b.num*a.den);

c.den = a.den*b.den;

reduce(&c);

return c;

}

void imprime(racional a){

printf("%d/%d\n",a.num,a.den);

}

Las estructuras pueden contener a otras estructuras como

componentes.

Una estructura que tiene componentes de tipo estructura se llama

estructura anidada.

Ejemplo de estructuras anidadas

struct fecha{

int dia,mes,anyo;

};

struct persona{

char nombre[20];

char apellido[20];

fecha nacimiento;

int edad;

int sexo;

char CURP[19];

char telefono[20];

};

nombre apellido nacimiento edad sexo CURP telefono

dia mes anyo

void despliegaFecha(fecha f){

printf("%d de ",f.dia);

switch(f.mes){

case 1:printf("ene");break;

case 2:printf("feb");break;

case 3:printf("mar");break;

case 4:printf("abr");break;

case 5:printf("may");break;

case 6:printf("jun");break;

case 7:printf("jul");break;

case 8:printf("ago");break;

case 9:printf("sep");break;

case 10:printf("oct");break;

case 11:printf("nov");break;

case 12:printf("dic");break;

}

printf(" de %d\n",f.anyo);

}

void despliegaPersona(persona p){

printf("Nombre: %s\n",p.nombre);

printf("Apellidos: %s\n",p.apellido);

printf("Fecha de nacimiento: ");

despliegaFecha(p.nacimiento);

printf("Edad: %d\n",p.edad);

if(p.sexo)

printf("Sexo: masculino\n");

else

printf("Sexo: femenino\n");

printf("CURP: %s\n",p.CURP);

printf("Telefono: %s\n",p.telefono);

}

void leerFecha(fecha *f){

printf("Dia? ");

scanf("%d",&(f->dia));

printf("Mes? ");

scanf("%d",&(f->mes));

printf("Anyo? ");

scanf("%d",&(f->anyo));

}

void leerPersona(persona *p){

fflush(stdin);

printf("Nombre? ");

gets(p->nombre);

printf("Apellidos? ");

gets(p->apellido);

printf("Fecha de nacimiento:\n");

leerFecha(&p->nacimiento);

printf("Edad? ");

scanf("%d",&p->edad);

printf("Sexo (1-Hombre, 0-Mujer)? ");

scanf("%d",&p->sexo);

fflush(stdin);

printf("CURP? ");

gets(p->CURP);

printf("Telefono? ");

gets(p->telefono);

}

Se puede acceder a los campos de una estructura anidada mediante el

operador “.”. Por ejemplo:

persona per,*per2;

per.nacimiento.dia = 5;

per.nacimiento.mes = 7;

per.nacimiento.anyo = 1998;

per2->nacimiento.dia = 1;

per2->nacimiento.mes = 8;

per2->nacimiento.anyo = 2005;

Note que el campo anidado se accede mediante el operador “.” y el no

anidado mediante “->”.

struct fecha{

int dia,mes,anyo;

};

struct direccionStruct{

char

calle[30],colonia[20],ciudad[30],estado[15],pais[20];

int numero,cp;

};

struct nombreStruct{

char nombre[20],apellidos[20];

};

struct nomdir{

nombreStruct nom;

direccionStruct dir;

};

struct posicion{

char depto[5];

char trabajo[20];

};

struct empleado{

nomdir nombreDireccion;

posicion trabajo;

float salario;

int numDepto;

fecha fechaIngreso;

};

struct estudiante{

nomdir nombreDireccion;

char carrera[20];

float promedio;

int creditos;

};

dia mes anyo

calle colonia ciudad estado pais num cp

nombre apellidos

dirnom

nombre apellidos calle colonia ciudad estado pais num cp

fecha

direccionStruct

nombreStruct

nomdir

depto trabajo

posicion

empleado

dirnom

nombre apellidos calle colonia ciudad estado pais num cp

nombredireccion

depto trabajo

trabajo salario numDepto fechaIngreso

dia mesanyo

estudiante

dirnom

nombre apellidos calle colonia ciudad estado pais num cp

nombredireccion carrera promedio creditos

main(){

nomdir per = {{"juan","perez lopez"},

{"olmo","lomas","SLP","SLP","Mexico",32,78000}};

estudiante est = {{},"fisica",7.5,210};

empleado emp = {{},{"dep1","afanador"},30000,2,{5,5,2003}};

est.nombreDireccion = per;

emp.nombreDireccion = per;

printf("nombre: %s\n",per.nom.nombre);

printf("apellidos: %s\n",per.nom.apellidos);

printf("nombre: %s\n",est.nombreDireccion.nom.nombre);

printf("apellidos: %s\n",est.nombreDireccion.nom.apellidos);

printf("nombre: %s\n",emp.nombreDireccion.nom.nombre);

printf("apellidos: %s\n",emp.nombreDireccion.nom.apellidos);

printf("Fecha ingreso: %d/%d/%d\n", emp.fechaIngreso.dia,

emp.fechaIngreso.mes, emp.fechaIngreso.anyo);

getch();

}