guia teorica programacion ii (1)

Docentes Colaboradores

Recopilado por: Docentes del rea de Programacin / Trayecto I / Trimestre II Unidad Curricular: Algoritmia y Programacin Mdulo: Programacin I Pgina 2

Lcdo. Rubn Cova Lcdo. Luis Rigual

Lcda. Gladimar Serrano Lcda. Nakary Ortega. MSc

Ing. Leonardo Malav. MSc Lcdo. Franklin Mundaray

Lcda. Lisblein Arismendi TSU Rodolfo Ortz

Lcdo. Edinson Gonzlez

ndice


Pgina Objetivo 1.- Arreglos, Cadenas de Caracteres, Rutinas de Ordenamiento y Rutinas de Bsqueda

6

Introduccin 6

Arreglos 8

Unidimensionales 9

Cadenas 11

Bidimensionales 12

Arreglo de Cadenas 14

Multidimensionales 15

Operaciones con Arreglos Unidimensionales 15

Inicializacin 15

Lectura 17

Escritura 17

Asignacin 17

Operaciones con Arreglos Bidimensionales 18

Inicializacin 18

Lectura 20

Escritura 20

Asignacin 20

Rutinas de Ordenamiento 21

Intercambio 21

Seleccin 22

Insercin 24

Burbuja 25

Rutinas de Bsqueda 27

Secuencial 27

Binaria 28

Objetivo 2.- Funciones y Recursividad 30 Introduccin 30

Definicin 31

ndice


Declaracin 31

Tipos de Funciones 32

Llamadas a una Funcin 34

Salidas de una Funcin 35

Paso de parmetros a una Funcin 36

Por valor 36

Por referencia 37

Visibilidad de las Funciones 37

Recursividad 38

Ventajas 40

Inconvenientes 40

Consideraciones Generales 40

Solucin Iterativa vs Solucin Recursiva 41

Objetivo 3.- Punteros o Apuntadores 44

Introduccin 44

Definicin 45

Naturaleza de los Punteros 46

Declaracin 47

Inicializacin 49

Operaciones de Direccin e Indireccin 50

Aritmtica de Punteros 53

Relacin entre Arreglos y Punteros 55

Punteros y Funciones 57

Precauciones con el uso de Punteros 58

Objetivo 4.- Estructuras 61 Introduccin 61

Conceptos Bsicos 62

Acceso a los componentes de una estructura 63

Arreglos de Estructuras 65

Estructuras Anidadas 65

ndice


Apuntadores a estructuras 66

Paso de estructuras a las funciones 67

Objetivo 5.- Archivos 69 Introduccin 69

Tipos de archivos 71

Archivos de Texto. Operaciones que se realizan sobre ellos 76

Archivos Binarios. Operaciones que se realizan sobre ellos 80

Ejemplos de Programas de Archivos y manipulacin 83

Objetivo 1.- Arreglos, Cadenas de Caracteres, Rutinas de Ordenamiento y Rutinas de Bsqueda


Una estructura de datos es una coleccin de datos que pueden ser

caracterizados por su organizacin y las operaciones que definen en ella. Las

estructuras de datos son muy importantes en los sistemas de computadora. Los

tipos de datos ms frecuentes utilizados en los diferentes lenguajes de

programacin son:

Datos simples

Estndar Entero, real, carcter y lgico

Estructura de datos

Estticos Vectores y matrices, registro y archivos

Dinmicos Lineales: Lista, pilas y colas

No lineales: rboles y grafos

Las estructuras de datos estticas son aquellas en las que el tamao

ocupado en memoria se define antes que el programa se ejecute y el mismo no

puede ser modificado durante la ejecucin.

Los tipos de datos que vimos hasta hora son datos simples cuya

caracterstica comn es que cada variable representa a un elemento; en cambio

los tipos de datos estructurados tienen como particularidad que con un nombre o

identificador se puede representar mltiples datos individuales y a su vez cada

uno de estas puede ser referenciado independientemente.

Aqu desarrollaremos los siguientes tems:

Arreglos

Unidimensionales

Cadenas

Bidimensionales

Arreglo de Cadenas



Multidimensionales

Operaciones con Arreglos Unidimensionales

Inicializacin

Lectura

Escritura

Asignacin

Operaciones con Arreglos Bidimensionales

Inicializacin

Lectura

Escritura

Asignacin

Rutinas de Ordenamiento

Intercambio

Seleccin

Insercin

Burbuja

Rutinas de Bsqueda

Secuencial

Binaria



Arreglos

Se define como una coleccin finita, homognea y ordenada de

elementos.

Finita: todo arreglo tiene un lmite, es decir, debe determinarse cual ser el

nmero mximo de elementos que podrn formar parte del arreglo.

Homognea: Todos los elementos de un arreglo son del mismo tipo o

naturaleza (todos enteros, todos bolanos, etc.), pero nunca una combinacin

de distintos tipos.

Ordenada: Se debe determinar cul es el primer elemento, el segundo, el

tercero y el ensimo elemento.

ARREGLO

En C, todos los arreglos constan de posiciones de memoria contiguas. La

direccin ms baja corresponde al primer elemento y la direccin ms alta al

ltimo elemento. Los arreglos pueden tener de una a varias dimensiones. El

arreglo ms comn es la cadena, que simplemente es un arreglo de caracteres

terminado por un nulo.

1 ELEMENTO 2 ELEMENTO N- ELEMENTO



En cuanto a las dimensiones los arreglos se pueden clasificar:

Unidimensional o vectores: un solo ndice

Bidimensional o matriz: dos ndices

Multidimensional: ms de dos ndices

Arreglos Unidimensionales

Un arreglo unidimensional es un tipo de datos estructurado que est

formado de una coleccin finita y ordenada de datos del mismo tipo. Es la

estructura natural para modelar listas de elementos iguales.

El tipo de acceso a los arreglos unidimensionales es el acceso directo, es

decir, podemos acceder a cualquier elemento del arreglo sin tener que consultar

a elementos anteriores o posteriores, esto mediante el uso de un ndice para cada

elemento del arreglo que nos da su posicin relativa.

La forma general de declaracin de un arreglo unidimensional es:

tipo nombre_de_variable[tamao];

Los arreglos tienen que declararse explcitamente para que el compilador

pueda reservar espacio en memoria para ellos. En la declaracin tipo declara el

tipo base del arreglo, que es el tipo de cada elemento del arreglo. El valor de

tamao indica cuntos elementos mantendr el arreglo. Por ejemplo, para

declarar un arreglo de 100 elementos de tipo double denominado Notas se usa la

instruccin:

double Notas[100];



Un elemento se puede acceder indexando el nombre del arreglo. Esto se

hace colocando el ndice del elemento entre corchetes justo detrs del nombre

del arreglo. Por ejemplo,

Notas[3] = 12.23;

asigna al elemento nmero 3 de Notas el valor 12.23.

En C, todos los arreglos tienen el 0 como ndice de su primer elemento. Por

tanto, cuando se escribe char p[10];se est declarando un arreglo de caracteres que tiene diez elementos, desde p[0] hasta p[9]. Por ejemplo, el siguiente

programa carga un arreglo de enteros con los nmeros desde el 0 hasta el 99:

#include int main(void) {

int x[100]; /* esto declara un arreglo de 100 elementos enteros / int t; /* mostrar el contenido de x */ for(t=0; C



Cadenas

El uso ms comn de los arreglos unidimensionales, es como cadenas de

caracteres. En C, una cadena es un arreglo de caracteres terminado en nulo. (Un

nulo es un cero.) Por tanto, una cadena contiene los caracteres que la

conforman seguidos de un nulo. La cadena terminada en nulo es el nico tipo de

cadena definido en C.

Cuando se declara un arreglo de caracteres para una cadena, es

necesario que se declare con un carcter ms que la cadena ms larga que

pueda contener, esto dejar sitio para el carcter nulo. Por ejemplo, para

declarar un arreglo Apellido que contenga una cadena de hasta 25 caracteres,

se escribir:

char Apellido[26] ;

C incluye una gran variedad de funciones de manipulacin de cadenas.

Las ms comunes son las siguientes:

Nombre Funcin

strcpy(c1, c2) Copia c2 en c1.

strcat(c1, c2) Concatena c2 al final de c1.

strlen(c1) Devuelve la longitud de c1.

strcmp(c1, c2) Devuelve 0 si c1 y c2 son iguales; menor que 0 si c1c2.

strchr(c1, car) Devuelve un puntero a la primera ocurrencia de car en c1.

strstr(c1, c2) Devuelve un puntero a la primera ocurrencia de c2 en c1.

Estas funciones usan el archivo de cabecera estndar . El

siguiente programa ilustra el uso de estas funciones de cadenas:



#include . #include int main(void) {

char c1[80],c2[80] ; gets(c1); gets(c2); printf("longitudes: %d %d\n", strlen(c1), strlen(c2)); if (strcmp(c1, c2)==0) printf("Las cadenas son iguales\n") ; strcat(c1, c1); printf("%s\n",c1) ; strcpy(c1, "sta es una prueba.\"); printf (c1) ; if(strchr("hola", 'o')) printf("o est en hola\n"); if(strstr("hola amigos", "hola")) printf("hola encontrado"); return 0;

}

Si se ejecuta este programa y se introducen las cadenas "hola" y "hola", la

salida es

longitudes: 4 4

Las cadenas son iguales

hola hola

sta es una prueba

o est en hola

hola encontrado

Arreglos Bidimensionales

Este tipo de arreglos al igual que los anteriores es un tipo de dato

estructurado, finito ordenado y homogneo. El acceso a ellos tambin es en

forma directa por medio de un par de ndices.

Los arreglos bidimensionales se usan para representar datos que pueden

verse como una tabla con filas y columnas. La primera dimensin del arreglo



representa las columnas, cada elemento contiene un valor y cada dimensin

representa una relacin.La representacin en memoria se realiza de dos formas:

almacenamiento por columnas o por renglones.

Para declarar un arreglo num de enteros bidimensional de tamao 10,20 se

escribir

int num[10] [20];

De forma similar, para acceder al punto 1,2 del arreglo d se escribir

num[1][2]

El siguiente ejemplo carga un arreglo bidimensional con los nmeros del 1

al 12 y luego los imprime fila a fila.

#include int main(void) {

int t, i, num [3][4]; for (t=0; t



En este ejemplo, num[0][0] tiene el valor 1, num[0][l] el valor 2, num[0][2] el

valor 3, y as sucesivamente. El valor de num[2][3] es 12. Se puede representar el

arreglo como sigue:

num [t] [i]

1 2 3 4 0 1 2 3 4 1 5 6 7 8 2 9 10 11 12

Los arreglos bidimensionales se almacenan en matrices fila-columna, en las

que el primer ndice indica la fila y el segundo indica la columna. Esto significa

que el ndice ms a la derecha cambia ms rpido que el de ms a la izquierda

cuando accedemos a elementos del arreglo en el orden en que realmente se

han almacenado en memoria.

Arreglos de Cadenas

Para crear un arreglo de cadenas se utiliza un arreglo de caracteres

bidimensional. El tamao del ndice izquierdo determina el nmero de cadenas y

el tamao del ndice derecho especifica la longitud mxima de las cadenas. El

cdigo que sigue declara un arreglo de 30 cadenas, cada una con una longitud

mxima de 79 caracteres.

char arreglo_cad[30][80];

Es bastante fcil acceder a una cadena individual: simplemente se

especifica slo el ndice izquierdo. Por ejemplo, la siguiente declaracin llama a

gets() con la tercera cadena de arreglo _cad.

gets (arreglo_cad[2]) ;



La declaracin anterior equivale funcionalmente a

gets(&arreglo_cad[2][0]);

Arreglos Multidimensionales

Este tambin es un tipo de dato estructurado, que est compuesto por n

dimensiones. Para hacer referencia a cada componente del arreglo es necesario

utilizar n ndices, uno para cada dimensin. C permite arreglos de ms de dos

dimensiones. La forma general de declaracin de un arreglo multidimensional es:

tipo nombre [Tamao1][Tamao2][Tamao3]...[TamaoN];

Operaciones con Arreglos Unidimensionales

Las operaciones en arreglos pueden clasificarse de la siguiente forma:

Inicializacin

Lectura

Escritura

Asignacin

Inicializacin

C permite la inicializacin de arreglos en el momento de declararlos. La

forma general de inicializacin de un arreglo, que aparece a continuacin, es

similar a la de otras variables:

especificador_de_tipo nombre_de_arreglo [tamao1 ]...[tamao N]= {lista_de_valores};

La lista_de_valores es una lista de constantes separadas por comas cuyo

tipo es compatible con el especificador_de_tipo. La primera constante se coloca



en la primera posicin del arreglo, la segunda constante en la segunda posicin,

y as sucesivamente. Obsrvese que un punto y coma sigue a }.

En el ejemplo que sigue se inicializa un arreglo de enteros de 10 elementos

con los nmeros del 1 al 10:

int i[10] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};

Inicializacin de arreglos no delimitados

Como se podr suponer, resulta tedioso contar los caracteres de cada

mensaje manualmente para determinar la dimensin correcta del arreglo. Se

puede hacer que el compilador calcule automticamente las dimensiones de los

arreglos. Si en una instruccin de inicializacin de un arreglo no se especifica el

tamao del arreglo, el compilador automticamente crea un arreglo

suficientemente grande para mantener todos los inicializadores presentes. Esto es

lo que se denomina arreglo no delimitado.

char mensaje[26] = Bienvenido al Sistema;

Adems de ser menos tedioso, el uso de la inicializacin de arreglos no

delimitados permite cambiar cualquiera de los mensajes sin temor a teclear una

cuenta incorrecta accidentalmente. El uso de inicializaciones de arreglos no

delimitados no est restringido a los arreglos unidimensionales.



Lectura

Este proceso consiste en leer un dato de un arreglo y asignar un valor a

cada uno de sus componentes. La lectura se realiza de la siguiente manera:

int n = 100; /* donde la variable n contiene la cantidad mxima que contendr el arreglo*/

for (i=0;i < n-1; i++) scanf(%d,&arreglo[i]);

Escritura

Consiste en imprimir o mostrar por pantalla el valor de cada posicin del

arreglo. La escritura se realiza de la siguiente manera:


for (i=0;i< n-1; i++) printf(%d,arreglo[i]);

Asignacin

No es posible asignar directamente un valor a todo el arreglo, por lo que se

realiza de la manera siguiente:


for (i=0;i < n-1; i++) arreglo[i]= 0;



Operaciones con Arreglos Bidimensionales

Las operaciones en arreglos bidimensionales pueden clasificarse de la

siguiente forma:

Inicializacin

Lectura

Escritura

Asignacin

Inicializacin

Los arreglos multidimensionales se inicializan del mismo modo que los

unidimensionales. Por ejemplo, lo siguiente inicializa cuads con los nmeros del 1

al 10 y sus cuadrados.

int cuads[10] [2] = { 1, 1, 2, 4, 3, 9, 4, 16, 5, 25, 6, 36, 7, 49, 8, 64, 9, 81, 10, 100,

};

Cuando se inicializan arreglos multidimensionales se pueden aadir llaves

para encerrar los inicializadores de cada dimensin. Esto se denomina

agrupamiento subagregado. Por ejemplo, la declaracin anterior se podra haber

escrito tambin como:

int cuads[10][2] = { {1, 1}, {2, 4}, {3, 9}, {4, 16}, {5, 25},



{6, 36}};

Cuando se utiliza agrupamiento subagregado, si no se proporcionan

suficientes inicializadores para un grupo dado, los restantes miembros se inicializan

a cero automticamente.

Inicializacin de arreglos no delimitados

Para los arreglos multidimensionales se deben especificar todas excepto la

dimensin ms a la izquierda. (Las otras dimensiones se necesitan permitir al

compilador de C indexar el arreglo adecuadamente.) De este modo se puede

construir tablas de longitudes variables, y el compilador asignar

automticamente suficiente espacio para ellas. Por ejemplo, a continuacin se

muestra la inicializacin del arreglo no delimitado cuads:

int cuads[] [2] = { 1, 1, 2, 4, 3, 9, 4, 16, 5, 25, 6, 36, 7, 49, 8, 64, 9, 81, 10, 100,

};

La ventaja de esta declaracin sobre la versin de tamao delimitado es

que la tabla puede alargarse o acortarse sin tener que cambiar las dimensiones

del arreglo.



Lectura

Este proceso consiste en leer un dato de un arreglo y asignar un valor a

cada uno de sus componentes. La lectura se realiza de la siguiente manera:


for (i=0;i < n-1; i++) { for (j=0;j < n-1; j++) { scanf(%d,&arreglo[i][j]); } }

Escritura

Consiste en imprimir o mostrar por pantalla el valor de cada posicin del

arreglo. La escritura se realiza de la siguiente manera:


for (i=0;i < n-1; i++) { for (j=0;j < n-1; j++) { printf(%d,arreglo[i][j]); } }

Asignacin

No es posible asignar directamente un valor a todo el arreglo, por lo que se

realiza de la manera siguiente:


for (i=0;i < n-1; i++) { for (j=0;j < n-1; j++) { arreglo[i][j]= 0; } }



Ordenacin y Bsqueda

La ordenacin y bsqueda de elementos son tareas que se realizan

frecuentemente en el procesamiento de datos, esto debido a que muchas

actividades humanas requieren que a diferentes colecciones de datos utilizados

se pongan en un orden especfico y se localicen de manera rpida; ejemplos

claros son las oficinas de correos y las empresas de mensajera que ordenan el

correo y los paquetes por cdigos postales, con el fin de conseguir una entrega

eficiente. Lo que supone un rea interesante e intrnseca desde el punto de vista

terico y prctico en la programacin. Por tal motivo esta unidad est dedicada

a estudiar los mtodos de ordenamiento y bsqueda, as como su

implementacin en el lenguaje C.

Rutinas de Ordenamiento

1. Ordenacin por intercambio: es el mtodo ms sencillo, ordena los elementos de una lista en orden ascendente. La tcnica se basa en la

lectura sucesiva de la lista a ordenar, comparando el elemento inferior de

la lista con los restantes y efectuando intercambio de posiciones cuando el

orden resultante de la comparacin no sea correcto. El funcionamiento de

este mtodo se puede observar grficamente a continuacin:

Se tiene el siguiente arreglo a:

En la iteracin 0 ocurrira lo siguiente:

8 4 6 2

Se realiza intercambio 4 8 6 2

4 8 6 2

No se realiza intercambio 4 8 6 2

4 8 6 2


8 4 6 2



Vector inicial Vector resultante

En la iteracin 1 pasara lo siguiente:

2 8 6 4


2 6 8 4



En la iteracin 2 se tendra:

2 4 8 6



Implementacin del mtodo en C:

void intercambio( int a[], int n ) { int i, j , aux; for (i=0;i < n-1; i++) for (j=i+1;j < n; j++) if( a[i] > a[j] ) { aux=a[i]; a[i] = a[j]; a[j] = aux; } }

2. Ordenacin por seleccin: El funcionamiento de este mtodo se puede observar grficamente a continuacin: considrese un arreglo a con 5

valores enteros:

51 21 39 80 35



51 21 39 80 35

Iteracin 0 Seleccionar 21 e intercambiar 21 y a[0]

21 51 39 80 35


21 35 39 80 51


21 35 39 80 51


21 35 39 51 80

Iteracin 4 Lista ordenada

Despus de observar grficamente el mtodo se puede deducir lo siguiente:

El mtodo selecciona el elemento ms pequeo de la lista a. Lo

intercambia con el primer elemento a[0]. Ahora el valor ms pequeo est

en la primera posicin del vector.

Considerar las posiciones de la lista a[1], a[2], a[3],, seleccionar el

elemento ms pequeo e intercambiarlo con a[1]. Ahora los dos valores

ms pequeos de a estn en orden.

Continuar este proceso encontrando o seleccionando el elemento ms

pequeo de los restantes intercambiarlos adecuadamente.


void seleccion( int a[], int n ) {

int i, j ,aux, indicemenor; for (i=0;i < n-1; i++) { indicemenor = i; for (j=i+1;j < n; j++) { if( a[j] < a[indicemenor] ) { aux=a[j]; a[j] = a[indicemenor]; a[indicemenor] = aux; } } } }



3. Ordenacin por insercin: El funcionamiento de este mtodo se puede

observar grficamente a continuacin:

50

Comienzo con 50

20 50

Se inserta 20 en la posicin 0 y 50 se mueve a la

posicin 1

20 40 50

Se inserta 40 en la posicin 1 y 50 se mueve a la

posicin 2

20 40 50 80

Se inserta 80 en la posicin 3

20 30 40 50 80

Se inserta 30 en la posicin 1 y se desplaza a la

derecha la sublista derecha

Despus de observar grficamente el mtodo se puede deducir lo siguiente:

El primer elemento a[0] se considera ordenado; es decir, la lista inicial

consta de un elemento.

Se inserta a[1] en la posicin correcta; delante o detrs de a[0],

dependiendo de que sea menor o mayor. Es decir, se explora la lista desde

a[i] hasta a[n] buscando la posicin correcta de destino; esto es la posicin

a insertar dentro de la lista ordenada.

Por cada iteracin se mueve hacia a la derecha del vector todos los

elementos mayores que la posicin a insertar, para dejar vaca esa

posicin.

Insertar ele elemento en la posicin correcta.




void insercion( int a[], int n ) {

int i, j ,aux; for (i=1;i < n; i++) {

j = i; aux=a[i]; while(j>0 && aux



20 40 50 80 30

Intercambio 80 y 30

20 40 50 30 80

Elemento mayor es 80

En la iteracin 1 se tiene:

20 40 50 30 80

20 y 40 ordenados

20 40 50 30 80

40 y 50 ordenados

20 40 50 30 80

Intercambio 50 y 30

20 40 30 50 80

50 y 80 elementos mayores ordenados


20 40 30 50 80

20 y 40 ordenados

20 40 30 50 80

Intercambio 40 y 30

20 30 40 50 80

40, 50 y 80 elementos mayores ordenados


20 30 40 50 80

20 y 30 ordenados

20 30 40 50 80

Lista ordenada




void burbuja( int a[], int n ) {

int j , aux, pasada, interruptor=0; for (pasada=0; pasada < n-1 && interruptor==0; pasada++) {

interruptor=1; for (j=0;j < n-pasada-1; j++) {

if( a[j] > a[j+1] ) {

interruptor=0; aux=a[j];

a[j] = a[j+1]; a[j+1] = aux;

} }

} }

Rutinas de Bsqueda

1. Bsqueda secuencial: esta bsqueda trata de buscar un elemento de un

arreglo utilizando un valor destino llamado clave. En una bsqueda

secuencial, los elementos de una lista o vector se exploran en secuencia, es

decir uno despus del otro. Este mtodo compara cada elemento del

arreglo con la clave de bsqueda. Dado que el vector no est en un orden

prefijado, es probable que el elemento a buscar pueda ser el primero, el

ltimo o cualquier otro.

El siguiente ejemplo especifica grficamente el mtodo, en la cual

se trata de buscar el elemento 6 en el siguiente arreglo a:



10 05 31 22 06

6 valor devuelto ndice 4


int busqueda_secuencial(int a[], int n, int clave) { int i; for(i=0; i



120 275 325 510

El ltimo valor de la primera mitad es

275, la bsqueda contina con la

primera mitad de elementos.

120 275

El ltimo valor de la primera mitad es

120, que es ms pequeo que el valor

que se est buscando, la bsqueda

contina con la segunda mitad de

elementos.

275

Se observa por ltimo que no ha

habido xito en la bsqueda ya que

228 es distinto a 275


int busquedabinaria (int a[], int bajo, int alto, int clave) { int central, valorcentral; while(bajo

Objetivo 2.- Funciones y Recursividad


Cuando se habla de modularidad en Lenguaje C se emplea el trmino

funcin que no es ms que una seccin de cdigo independiente que genera un

conjunto de eventos derivados de una posterior llamada en una parte de la

seccin principal del programa, lo que conlleva que se pueda trabajar en una

forma ms ordenada y generando aplicaciones ms robustas y poderosas

combinando ejecuciones iterativas y/o recursivas.


Introduccin

Definicin

Declaracin

Tipos de Funciones

Llamadas a una Funcin

Salidas de una Funcin

Paso de parmetros a una Funcin

Por valor

Por referencia

Visibilidad de las Funciones

Recursividad

Ventajas

Inconvenientes

Solucin Iterativa vs Solucin Recursiva



Definicin

Una funcin es una parte de cdigo independiente del programa principal

y de otras funciones, que puede ser llamada envindole unos datos (o sin enviarle

nada), para que realice una determinada tarea y/o proporcione unos resultados.

La forma general de definicin de una funcin es:

tipo nombre(lista de parmetros) { cuerpo de la funcin

}

El tipo especifica el tipo de valor que devuelve la sentencia return de la

funcin. El valor puede ser cualquier tipo vlido; si no se especifica ninguno, se

asume un resultado entero. La lista de parmetros es la lista de nombres de

variables separados por comas con sus tipos asociados que reciben los valores de

los argumentos cuando se llama a la funcin. Una funcin puede no tener

parmetros, en cuyo caso la lista de parmetros est vaca; sin embargo, los

parntesis son necesarios.

Declaracin

Cada funcin debe ser declarada. Su forma general es: tipo

nombre_funcin (lista de tipos (y nombres) de los argumentos); si una funcin va

usar argumentos, debe declarar variables que acepten los valores de los

argumentos. Estas variables se llaman parmetros formales de la funcin y se

comportan como variables locales dentro de la funcin, crendose al entrar en la

funcin y destruyndose al salir. La declaracin de parmetros aparece despus

del nombre de la funcin al definirla. Los parmetros formales tienen que ser del

mismo tipo que los argumentos usados al llamar una funcin (el compilador no

dar error pero los resultados sern inesperados).



Al igual que con variables locales, se pueden hacer asignaciones a los

parmetros de una funcin o usarlos en cualquier expresin vlida. Se pueden

usar como cualquier otra variable.

Una funcin es visible para ella misma y otras funciones desde el momento

en que se define. Es visible para el propio cuerpo de la funcin, es decir, la

recursividad est permitida. El cdigo de una funcin es privado a esa funcin y

slo se puede acceder a l mediante una llamada a esa funcin. Las variables

definidas dentro de una funcin son locales (a no ser que las definamos globales)

por lo que no conservan su valor de una llamada a otra (excepto si se declaran

como static, entonces el compilador no las destruye y almacena su valor para la

prxima llamada, aunque la variable tiene limitado el mbito al interior de la

funcin).

En C, todas las funciones estn al mismo nivel, es decir, no se puede definir

una funcin dentro de otra funcin. Esto es por lo que C no es tcnicamente un

lenguaje estructurado por bloques.

El cdigo de una funcin es privado a esa funcin y slo se puede acceder

a l mediante una llamada a esa funcin. Las variables definidas dentro de una

funcin son locales (a no ser que las definamos globales) por lo que no conservan

su valor de una llamada a otra (excepto si se declaran como static, entonces el

compilador no las destruye y almacena su valor para la prxima llamada, aunque

la variable tiene limitado el mbito al interior de la funcin).

Tipos de Funciones

Muchos autores establecen la siguiente clasificacin a la hora de tipificar

las funciones en Lenguaje C:

a. Funciones que no tienen parmetros y que no devuelven ningn

valor: Son aquellas que no tienen parmetros de entrada, realizan

acciones en su cuerpo de programa y no devuelven ningn valor.

Utilizan la palabra reservada void como tipificador de datos



Ejemplo:

void mostrar(void) { printf("Despliegue de datos"); return; }

b. Funciones que tienen parmetros y que no devuelven ningn valor:

Son aquellas que tienen parmetros de entrada, realizan acciones

en su cuerpo de programa y no devuelven ningn valor. Utilizan

cualquiera de las palabras reservadas como tipificadores de datos

a nivel de los parmetros de entrada en cuanto a la funcin su

tipificador es void

Ejemplo:

void mostrar_suma(int a, int b) { int suma; suma= a+b; printf("La Suma de A y B es:%d, suma); return; }

c. Funciones que no tienen parmetros y que devuelven valor: Son

aquellas que no tienen parmetros de entrada, realizan acciones en

su cuerpo de programa y devuelven algn valor. Utilizan cualquiera

de las palabras reservadas como tipificadores de datos a nivel de

funcin.

Ejemplo:

int suma(void) { int a=10, b=20, suma; suma = a+b; return suma; }

d. Funciones que tienen parmetros y que devuelven valor: Son

aquellas que tienen parmetros de entrada, realizan acciones en su



cuerpo de programa y devuelven algn valor. Utilizan cualquiera de

las palabras reservadas como tipificadores de datos a nivel de los

parmetros de entrada y de funcin

Ejemplo:

int suma(int a, int b) { int sumando; sumando = a+b; return sumando; }

Llamadas a Funciones

Las funciones son llamadas para su ejecucin desde cualquier parte del

cdigo, teniendo en cuenta que antes deben haber sido declaradas (y por

supuesto definidas).

La llamada de una funcin se produce mediante el uso de su nombre en

una sentencia, pasando una lista de argumentos que deben coincidir en nmero

y tipo con los especificados en la declaracin (en otro caso se producira una

conversin de tipos o resultados inesperados).

En general, se pueden pasar argumentos a las funciones de dos formas, por

valor y por referencia.

La llamada por valor copia el valor de un argumento en el parmetro

formal de la funcin. De esta forma, los cambios en los parmetros de la funcin

no afectan a las variables que se usan en la llamada (es la llamada ms usual, es

decir, en general no se pueden alterar las variables usadas para llamar a la

funcin).

La llamada por referencia copia la direccin del argumento en el

parmetro. Dentro de la funcin se usa la direccin para acceder al argumento

usado, significando que los cambios hechos a los parmetros afectan a la

variable usada en la llamada.



Es posible simular una llamada por referencia pasando un puntero al

argumento, entonces, al pasar la direccin, es posible cambiar el valor de la

variable usada en la llamada.

Ejemplo:

#include

void holamundo(void) /*Funcin donde se ejecuta la lgica del programa*/ { printf("Hola Mundo\n"); /*imprime la cadena*/ return; /*sale de la funcin*/ }

int main(void) /*Funcin principal del programa*/ { holamundo(); /*llamada a la funcin que lleva el peso*/ return 0; /*sale del programa: correcto*/ }

Salidas de Funciones

Para salir de un funcin se utiliza la sentencia return que produce la salida

inmediata de la funcin hacia el cdigo que la invoc. La sentencia puede

devolver un valor acorde con el tipo usado al declarar la funcin que puede ser

una constante, una variable o una expresin. En caso de obviarse la sentencia

return, la funcin terminar con se ejecucin de la ltima instruccin. En este caso

la funcin devuelve el valor cero a excepcin de las funciones de tipo void, que

no devuelve ningn valor.

Ejemplo:

void holamundo(void) /*Funcin donde se ejecuta la lgica del programa*/ { printf("Hola Mundo\n"); /*imprime la cadena*/ return; /*sale de la funcin*/ }

int suma(int a, int b) /*Funcin donde se ejecuta la lgica del programa*/



{ int sum; sum = a+b; return sum; /*sale de la funcin*/ }

Paso de parmetros a una Funcin

Los parmetros formales de una funcin son variables locales que se crean

al comenzar la funcin y se destruyen cuando termina. El tipo de dato de cada

parmetro formal debe ser el mismo que el tipo de los argumentos se utilicen al

llamar a la funcin. Este error no se detecta en la compilacin y para remediarlo,

se deben usar los prototipos de funciones. El nico caso en el que los tipos pueden

no coincidir los parmetros formales y los argumentos es cuando el argumento es

de tipo char y el parmetros formal es de tipo int; la conversin, en este caso, se

hace a int. Los parmetros de una funcin pueden ser valores (llamada por valor)

o direcciones (llamada por referencia)

Por valor: El parmetro de la funcin recibe el valor de la variable que

se utiliza como argumento. Cualquier modificacin sobre estos

parmetros no afecta a las variables que se utilizan para llamar a la

funcin, puesto que el parmetro en estos casos es una copia de la

variable. Solo se pueden pasar por valor los tipos atmicos, es decir no

son arrays ni estructuras.

Ejm:

int suma(int a, int b); main() { int x = 1, y = 2, z;

z = suma(x, y);

}

int suma(int a, int b) { return(a + b); }



Por referencia: Cuando un argumento es una direccin, el parmetro

recibe la direccin de la variable que se ha pasado como argumento

al invocar a la funcin. Por lo tanto, el parmetro deber declararse

como un puntero y de esta forma se puede modificar el contenido de

las variables. Si una funcin tiene que devolver ms de un valor, lo har

utilizando sus parmetros y necesariamente los argumentos deben

pasarse por referencia.

Ejm:

a)

void cursor(int *x, int *y); main() { int fila, columna;

cursor(&fila, &columna);

}

void cursor(int *x, int *y) { ....

*x =20; .....

}

b)

void alternar int *px, int *py); main() { int x = 10, y = 20; alternar(&x, &y); printf("x = %d, y = %d", x,y); }

void alternar(int *px, int *py) { int temp; temp = *px; *px = *py; *py = temp; }



Visibilidad de una Funcin

Una funcin declarada en un archivo tiene un alcance global; es

decir, se puede invocarla desde cualquier punto dentro este archivo.

Cuando se quiere acceder a ella desde otro archivo, hay que incluir

en este ltimo la declaracin de dicha funcin. A diferencia de las

variables externas, donde es necesario modificar el tipo de

almacenamiento mediante la palabra reservada extern, las funciones no

necesitan de este modificador: una funcin puede ser invocada desde

cualquier mdulo. El uso de la palabra extern se usa para facilitar la

compresin del cdigo. Si quiere restringir el uso de la funcin a un solo

mdulo, se usa el modificador static en su declaracin. Esta caracterstica

permite disear mdulos con informacin y herramientas privadas.

Recursividad

Hasta ahora se ha trabajado en lenguaje C dando soluciones

iterativas a nuestros algoritmos. Con este estudio de la recursividad se

pretende que se entienda la diferencia entre una solucin iterativa y su

versin recursiva viendo las ventajas e inconvenientes que la utilizacin de

una u otra aportan. Ejm: Cmo disear una funcin que calcule la

potencia de X? Se puede llegar al siguiente planteamiento:

Se podra pensar en la frmula de la potencia de la manera siguiente:

pot(X,n) = X pot(X, n-1)



pot(X,n-1) = X pot(X, n-2)

.

.

pot(X,0) = 1

Se dice que es recursiva ya que la definicin se da en trminos de

una versin ms pequea de s misma. Un algoritmo recursivo es un

algoritmo que expresa la solucin de un problema en trminos de una

llamada a s mismo. La llamada a s mismo se conoce como llamada

recursiva.

Ejemplo:

void funcionRecursiva(int a) {

funcionRecursiva(a+1);

}

Para que un algoritmo recursivo no se convierta en infinito debe

contener una condicin que garantice la terminacin del algoritmo

recursivo en un tiempo finito. Es lo que se conoce como CONDICIN DE

PARADA, que debe hacer que no se generen ms llamadas recursivas.

Tambin debe contener un PASO DE LA RECURSIVIDAD, que

garantice que al ejecutar el algoritmo recursivo se tiende a la condicin de

parada. Una funcin declarada en un archivo tiene un alcance global; es

decir, se puede invocarla desde cualquier punto dentro este archivo.

Cuando se quiere acceder a ella desde otro archivo, hay que incluir en

este ltimo la declaracin de dicha funcin. A diferencia de las variables

externas, donde es necesario modificar el tipo de almacenamiento

mediante la palabra reservada extern, las funciones no necesitan de este



modificador: una funcin puede ser invocada desde cualquier mdulo. El

uso de la palabra extern se usa para facilitar la compresin del cdigo. Si

quiere restringir el uso de la funcin a un solo mdulo, se usa el modificador

static en su declaracin. Esta caracterstica permite disear mdulos con

informacin y herramientas privadas.

Ventajas

Proporciona simplicidad en la comprensin de los problemas.

Es un mtodo natural de resolver problemas.

Permite una gran potencia de clculo.

La correccin de los algoritmos se comprueba fcilmente.

Inconvenientes

Aumenta el consumo de recursos de la mquina (sobre todo de la

pila).

Es ms lenta que las soluciones iterativas equivalentes (siempre que

exista la solucin iterativa equivalente).

Se recomienda aplicar una solucin iterativa cuando el

nmero de clculos que se repiten sea grande o exista

una solucin iterativa que sea sencilla de codificar.

Consideraciones Generales

En las llamadas a funciones:

Los parmetros que se pasan

Las variables locales de las funciones

La direccin de retorno de esa llamada (la instruccin del algoritmo

llamante a ejecutar cuando finalice la ejecucin del algoritmo

llamado)



Se almacenan en la pila del programa.

Solucin Iterativa vs Solucin Recursiva

Algoritmo que dado un nmero imprime su valor y todos los anteriores a

l en orden decreciente.

Solucin iterativa: void decrementa(int a) {

int i; for (i=a;i>0;i--)

printf(%d ,i); printf(Fin del algoritmo iterativo \n);

}

Informacin que aparece por pantalla si se hace la llamada a la

funcin decrementa (5):

5 4 3 2 1 Fin del algoritmo iterativo

Solucin recursiva void decrementa(int a) {

if (a>0) //CONDICIN DE PARADA: a==0 {

printf(%d ,a); decrementa(a-1); /*PASO DE LA RECURSIVIDAD*/

} else printf(Fin del algoritmo recursivo \n);

}

Informacin que aparece por pantalla si se hace la llamada a la

funcin decrementa (5):

5 4 3 2 1 Fin del algoritmo recursivo

La siguiente figura ilustra la ejecucin paso a paso del algoritmo recursivo:

A la vuelta de la recursividad no se ejecuta ninguna sentencia.



Dado el siguiente ejemplo analice el caso e indique la secuencia de

valores que se imprimen.

void main(void) {

P7(5); } void P7(int a) {

printf(%d \t,a); if (a>0) //CONDICIN DE PARADA, a==0 {

a--; P7(a); //PASO DE LA RECURSIVIDAD

} printf(%d \t,a);/*Cundo se ejecuta esta sentencia */

}

La siguiente figura muestra la ejecucin paso a paso del algoritmo anterior:

A la vuelta de la recursividad se ejecuta la sentencia:

printf(%d \t,a); /* (2) */

Informacin que aparece por pantalla

5 4 3 2 1 0 0 0 1 2 3 4

Calcule la funcin factorial de forma iterativa y recursiva.



Solucin Iterativa Solucin Recursiva

int factorial(int n)

{

int i;

int fact=1;

for (i= n; i>0 ;i--)

fact=fact*(i);

return(fact);

}

int factorial(int n)

{

int fact;

if (n == 0) /* CONDICIN DE PARADA */

fact = 1;

else

fact = n * factorial (n - 1); /* PASO DE LA RECURSIVIDAD */

return(fact);

}

Seguimiento de la versin recursiva de la funcin factorial:

Objetivo 3.- Punteros o Apuntadores


En los cursos de programacin el estudio de los punteros siempre se ha

considerado un reto para los alumnos, tanto en el aprendizaje como en su

aplicacin. En el lenguaje de programacin C, los apuntadores son una de las

caractersticas ms poderosas y tiles, en el desarrollo de programas. El manejo

de punteros requiere que el alumno modifique su forma de pensar con respecto

al uso de los identificadores. Los punteros son variables que almacenan como

valor la direccin de memoria que ocupa otro dato (una variable, constante,

elementos de arreglos, funciones, entre otras); en otras palabras, los punteros

hacen referencia a un tipo de dato almacenado en memoria.

Esta capacidad de los punteros permite que referencias a funciones,

puedan ser utilizadas como argumentos en el llamado a otra funcin.

Los punteros guardan una relacin muy estrecha con los arreglos y

cadenas, proporcionando una va alternativa para acceder a los elementos

individuales del arreglo. Los punteros son el elemento fundamental en la creacin

de estructuras de datos dinmicas (listas, pilas, colas, listas enlazadas, rboles y

grafos), a travs de la asignacin dinmica de memoria.


Definicin

Naturaleza de los Punteros

Declaracin

Inicializacin

Operaciones de Direccin e Indireccin

Aritmtica de Punteros

Relacin entre Arreglos y Punteros

Punteros y Funciones

Precauciones con el uso de Punteros



Definicin

Un puntero o un apuntador es una variable que almacena como dato la

direccin de memoria de otro identificador como puede ser un arreglo, una

funcin u otra variable. Los punteros son variables que almacenan como valor la

direccin de memoria que ocupa otro dato (una variable, constante, elementos

de arreglos, funciones, entre otras); en otras palabras, los punteros hacen

referencia a un tipo de dato almacenado en memoria. Esta capacidad de los

punteros permite que referencias a funciones, puedan ser utilizadas como

argumentos en el llamado a otra funcin.

Hasta los momentos habamos visto variables cuyos datos podan ser

valores de tipo numrico, alfanumrico y lgico o booleanos, ahora estamos

conociendo otro tipo de dato, como lo son las direcciones de memoria, que son

capaces de almacenarlas en una variable especial conocida como apuntador.

Los punteros pueden ser usados para:

Fundamentalmente son usados para el manejo de memoria en

forma dinmica, permitiendo un uso ms eficiente de este recurso.

Comunicar informacin entre una funcin y sus puntos de llamada.

Permite devolver varios datos desde una funcin mediante los

argumentos de la funcin.

Permiten que referencias a otras funciones puedan ser especificadas

como argumentos de otra funcin. (pasar funciones como

argumentos).

Los punteros, son identificadores (variables) que poseen como valor la direccin de memoria que ocupa un dato especfico. El nombre de un puntero hace referencia directa a la posicin de memoria que ocupa un tipo de dato, e indirecta al valor de ese dato.



Representan de una forma ms conveniente los arreglos

multidimensionales, permitiendo que un arreglo multidimensional sea

reemplazado por un array de punteros de menor dimensin.

Son el soporte de enlace que utilizan estructuras avanzadas de

datos en memoria dinmica como las listas, pilas, colas y rboles.

Naturaleza de los Punteros

Entender cmo trabajan los punteros requiere un repaso de cmo se

almacenan los datos en memoria. Primero debemos recordar que la memoria

est compuesta por celdas de memoria y cada celda posee dos reas, una que

es la direccin (valor fijo permite identificar la posicin de dicha celda) y la otra es

la informacin (dato almacenado en la celda). Al momento de declarar una

variable, por ejemplo int x, el compilador le asigna a x una direccin de memoria,

fija, donde almacenar su valor. Los valores almacenados en memoria ocupan

una o ms celdas contiguas de memoria (palabras o bytes adyacentes). El

nmero de celdas de memoria requeridas para almacenar un valor depende del

tipo de dato. Por ejemplo, un carcter ser almacenado en 1 byte (8 bits) de

memoria; un entero normalmente necesita 2 bytes continuos. Un valor punto

flotante puede necesitar 4 u 8 bytes. Para acceder a un valor de una variable,

almacenado en memoria, se hace mencin al nombre de la variable.

int x; x = 4; printf("%d",x);

Hay dos operadores de apuntadores: & y *. & es un operador monario que

devuelve la direccin de memoria de su operando. (Recurdese que un

operador monario slo necesita un operando.)

Celda de Memoria Direccin x Valor x

F8E 4



El segundo operador de apuntadores, *, es el complemento de &. Es un

operador monario que devuelve el valor que se encuentra en la direccin que le

sigue.

Ejemplo:

Supongamos que v es una variable que representa un determinado dato.

El compilador automticamente asignar celdas de memoria para este

dato. Podemos acceder a los datos si conocemos su localizacin (la direccin)

de la primera celda de memoria. La direccin de memoria de v puede se

determinada mediante la expresin &v. Ahora vamos asignar la direccin de v a

otra variable llamada, pv. As, pv = &v

Esta nueva variable (pv) es un puntero a v, puesto que a la

posicin de memoria donde se almacena v, pv representa la direccin de v y no

su valor, pv es referida como una variable apuntadora, La relacin entre v y pv

est ilustrada en la figura siguiente

Direccin de v Valor de v

pv v

El dato representado por v (es decir, el dato almacenado en las celdas de

memoria de v) puede ser accedido mediante la expresin *pv, donde * es el

operador indireccin, que opera slo sobre una variable puntero. Por tanto; *pv y

v representa el mismo dato (el contenido de las mismas celdas de memoria).

Declaracin

Cuando se declara un puntero, como es una variable, el compilador

tambin le asigna celdas de memoria fija, pero el dato que almacena es la

direccin de memoria de otro identificador, que posee el mismo tipo de dato que

el puntero. Los punteros, como son identificadores, al ser declarados deben tener

un tipo de dato asociado (numrico, alfanumrico o lgico), y este tipo de dato



debe ser igual al tipo de dato de la variable que ocupa la direccin de memoria

que el puntero almacena. Para declarar un puntero se realiza igual que el resto

de las variables, pero al nombre del puntero le precede el smbolo * (asterisco),

que leeremos puntero a. Entonces se dice que un puntero apunta a un tipo de

datos especfico.

Sintaxis:

* ;

equivale a

*;

Donde:

Tipo_dato: Es el tipo de dato del puntero.

Nombre_puntero: Es el nombre del puntero

Ejemplo:

int* : es un tipo de dato puntero a enteros.

float *: es un tipo de dato puntero a datos tipo float.

float* ptry; ptry, es un puntero que apunta a tipos de datos float.

int *ptrx; ptrx, es un puntero que apunta a tipos de datos enteros.

Tambin se puede decir:

*ptrx, es una variable que almacena direcciones de memoria que

contienen tipos de datos int (enteros).

*ptry, es una variable que almacena direcciones de memoria que

contienen tipos de datos float.

Se debe tener muy claro que "ptrx" es una variable del tipo "puntero a int",

que "*ptrx" NO es una variable de tipo "int".



Declaraciones de Punteros

int *PuntAInt; // Tipo puntero a enteros (int)

char *PuntACar; // Tipo puntero a caracteres (char)

double *punto; // Tipo puntero a double

Un puntero, puede apuntar a cualquier tipo de dato definido por el usuario,

no slo a tipos simples. Es muy importante tener en cuenta que primero debe

declararse el tipo de datos al que apunta (un array, clase, funcin, etc.) y

despus el tipo de datos puntero.

Inicializacin

Como pasa con todas las variables en C, cuando se declara un puntero

slo se reserva el espacio de memoria para almacenarlo, pero no se asigna

ningn valor inicial, el contenido de la variable puntero permanecer sin cambios,

de modo que el valor inicial del puntero ser aleatorio e indeterminado

(denominado comnmente como basura). Debemos suponer que contiene una

direccin no vlida de memoria. Al intentar realizar operaciones con punteros NO

INICIALIZADOS, ocurrir un error no slo en el programa, sino tambin en el

sistema operativo, porque se intenta acceder a una direccin de memoria NO

EXISTENTE o NO VLIDA. Todos los punteros deben ser inicializados antes de ser

utilizados.

A las variables de tipo punteros slo pueden asignrseles:

el valor cero (0 o la constante NULL ),

otro puntero con el mismo tipo de dato,

una direccin de memoria de una variable que posea el mismo tipo

de dato que el puntero. Las direcciones de memoria deben ser

asignadas slo con el operador de direccin & (ampersand).

Punteros Nulos:

int *ptrx = 0;



float *ptry = NULL;

int *ptrz;

Es posible realizar la asignacin de un puntero a otro, si ambos son del

mismo tipo de datos.

ptrz = ptrx; //el puntero ptrz recibe la direccin de memoria que tiene

almacenada el puntero ptrx.

Operadores de Direccin e Indireccin

Operador de Direccin o Referencia. (Operador &). Es un operador monario

(slo requiere un operando) que devuelve la direccin de memoria del

operando, es decir, lo que hace es devolver la direccin que en memoria ocupa

el objeto sobre el que se aplica. Literalmente significa la direccin de.

Un ejemplo de su uso para inicializar un puntero es:

int x =10;

int *ptrx = &x;

ptrx, posee como valor la direccin de memoria que ocupa la

variable x.

Entonces se dice que ptrx apunta a x

Celda de Memoria ptrx Direccin Valor 0xF8E 0xF8A

Celda de Memoria x Direccin Valor 0xF8A 10



La representacin grfica

Este operador NO es aplicable a expresiones constantes, pues stas no se

almacenan en ninguna direccin de memoria especfica sino que se incrustan en

las instrucciones. Por ello, no es vlido hacer directamente:

int px = &10; // Error 10 no es una variable con direccin propia

Tampoco es vlido aplicar & a variables declaradas con la clase de

almacenamiento register, ni campos de slo lectura (readonly), pues si stos

pudiesen ser apuntados por punteros se correra el riesgo de poderlos modificar

ya que a travs de un puntero se accede a memoria directamente, sin tenerse en

cuenta si en la posicin accedida hay algn objeto, por lo que mucho menos se

considerar si ste es de slo lectura.

NOTA: El operador & puede aplicarse slo a operandos lvalue (algo a lo

que se puede asignar un valor, como una variable).

Operador de Indireccin o Desreferencia de memoria. (Operador *): Es un

operador monario que acta slo sobre operandos de tipo puntero. Este

operador devuelve el valor de la variable a la que apunta el puntero. Es decir,

devuelve el valor almacenado en la direccin de memoria apuntada por el

puntero. Literalmente significa el valor de.

Ejemplo:

int x = 10;

int *ptrx = &x;

int z ;

z = *ptrx ; // se asigna a la variable z el valor 10.

Puntero Variable

ptrx x

10

x ptrx



Con el operador de Indireccin (*), tambin se pueden asignar valores a

una direccin de memoria apuntada por un puntero, es decir, se puede alterar el

valor de la variable a la que apunta un puntero.

Ejemplo:

int x = 10;

int *ptrx = &x;

*ptrx = 30; // se asigna a la variable x el valor 30.

NOTA: No debemos confundir el operador * en la declaracin

del puntero (int *p), con el operador * (asterisco) en las

instrucciones (*p=10 o z=*p).

No se puede desreferenciar un puntero NULL, produce un error en tiempo

de ejecucin.

Ejemplo referenciando:

#include

int main(void) { int x = 99; int *p1, *p2;

p1 = &x; p2 = p1;

/* imprimir el valor de x dos veces */ printf(Valores apuntados por p1 y p2: %d %d\n, *p1, *p2);

/* imprimir la direccin de x dos veces */ printf(Direcciones en p1 y p2: %p %p\n, p1, p2);

return 0; }

Tras la secuencia de asignaciones

p1 = &x;

p2 = p1;



tanto p1 como p2 apuntan a x. Por tanto, tanto p1 como p2 se refieren al

mismo objeto. A continuacin se muestra un ejemplo de salida del programa,

confirmando esto.

Valores apuntados por p1 y p2: 99 99

Direcciones en p1 y p2: 0063FE00 0063FE00

Obsrvese que las direcciones se muestran usando el modificador de

formato de printf( ) %p. que hace que printf( ) muestre una direccin en el

formato utilizado por la computadora en cuestin.

Ejemplo desreferenciando:

{ int* puntero; int variable;

puntero = &variable; *puntero = 33; /* mismo efecto que variable=33 */ }

Varios apuntadores pueden apuntar a la misma variable:

int* puntero1; int* puntero2; int var;

puntero1 = &var; puntero2 = &var; *puntero1 = 50; /* mismo efecto que var=50 */ var = *puntero2 + 13; /* var=50+13 */

Aritmtica de Punteros

Los Apuntadores pueden ser utilizados como operandos vlidos en los

siguientes tipos de expresiones:

Aritmticas.

Relacionales.



Los apuntadores no pueden ser utilizados como operandos vlidos con

todos los operadores. Los apuntadores slo pueden realizar:

Operaciones Aritmticas:

o Sumarle o restarle un valor entero: Incremento/Decremento.

Ejemplo:

ptrx++; ptrx--; ++ptrx; --ptrx;

ptrx=ptrx+5 ; ptrx=ptrx-4; ptrx+=3; ptrx-=2;

o Restar un apuntador de otro. Resta de direcciones de

memoria.

Ejemplo:

ptrx = ptrx ptry;

Operaciones Relacionales: Es posible comparar dos variables de tipo

puntero en una expresin relacional, usando operaciones

relacionales de igualdad (= =), desigualdad (!=) y comparacin (, ==).

La aritmtica de punteros, tiene sentido slo cuando el puntero posee

asignado varias direcciones continuas de memoria, es decir, cuando se ejecuta

sobre un arreglo. Es muy poco probable que dos variables de un mismo tipo de

datos posean direcciones contiguas de memoria a no ser que sean elementos

adyacentes que formen parte de un arreglo.

Ejemplo

# include void main() { int *px, *py; static int a[6]= { 1, 2, 3, 4, 5, 6]; px=&a[0]: py=&a[5]:



printf (px=%x py%x, px, py); printf (\n\npy- px=%x, py - px); }

La ejecucin del programa produce la siguientes salida: px=52 py=5c py px=5

Relacin entre Arreglos y Punteros

Los nombres de los arreglos, son un tipo especial de punteros, que apuntan

a la direccin de memoria del primer elemento del arreglo. Recordemos que los

arreglos poseen elementos almacenados en direcciones contiguas de memoria.

Cada elemento del arreglo posee una direccin de memoria.

Ejemplo:

int v[10] = {0,1,2,3,4,5,6,7,8,9,}; int *ptrv; ptrv = &v[0]; //se le asigna al puntero ptrv, la direccin de memoria del primer elemento del arreglo v; //equivale a ptrv = v; ptrv = v; //se asigna la direccin de v a ptrv.

Como dijimos anteriormente, el nombre del arreglo (v) es un puntero, que

apunta, a la primera direccin de memoria del arreglo. Por lo tanto se est

realizando una asignacin de punteros. Cualquier posicin de un elemento en el

arreglo se puede obtener con el operador de direccin.

ptrv = &v[4]; //ptrv apunta a la posicin 4 del arreglo.

ptrv = &v[7]; //ptrv apunta a la posicin 7 del arreglo.

Con aritmtica de punteros, es posible acceder a la direccin de cada

elemento del arreglo.

Ejemplo: int v[10] = {0,1,2,3,4,5,6,7,8,9,}; int *ptrv; ptrv = &v[0];// equivale a ptrv=v; //Aritmtica ptrv + 2; //equivale a &v[2] ptrv + 6; //equivale a &v[6]



En ambos casos, ptrv no modifica la direccin de memoria a la que

apunta.

En la aritmtica de punteros la sumatoria de enteros a memorias (ptrv + n)

se realiza en base a la cantidad de bytes del tipo de datos del puntero (ptrv + n*

t_bytes).

Tipos Datos Tamao Byte (mquina 16 bits) Tamao Byte (mquina 32 bits)

char 1 byte 1 byte

int 2 bytes 4 bytes

long 4 bytes 4 bytes

float 4 bytes 4 bytes

Si el arreglo es de tipo int, cada posicin del arreglo ocupa 2 bytes de

memoria (mquinas de 16 bits), por lo tanto avanza (ptrv + (2 * 2))

En el siguiente ejemplo se inicia en la primera posicin

int *ptrv, v[3] = {15, 18, 20, 46};

ptrv = v;//ptrv apunta a la direccin 2000

printf(%d, *ptrv); //valor 15 ptrv = ptrv + 1;//avanza a la posicin de direccin 2002 //ptrv = 2000 + (1 * 2) = 2000 + 2 = 2002 printf(%d, *ptrv); //valor 18 ptrv+=2; //avanza a la posicin de direccin 2006 //ptrv = 2000 + (2 * 2) = 2000 + 4 = 2006 printf(%d, *ptrv); //valor 46

Resumen de las Operaciones con Punteros

1. A una variable puntero se le puede asignar la direccin de memoria

de una variable ordinaria (pv=&p).

2. A una variable puntero se le puede asignar el valor de otra variable

puntero (pv=py), siempre y cuando ambos punteros apunten al

1 5 1 8 2 0 4 6

200 200 200200200200 200200200



mismo tipo de datos o que el puntero pv sea un puntero genrico

(puntero a void).

3. A una variable puntero se le puede asignar un valor nulo (cero)

(pv=NULL, NULL es una constante simblica con valor cero).

4. Una cantidad entera puede ser sumada o restada a una variable

puntero (px+3, pv++).

5. Una variable puntero puede ser restada de otra siempre y cuando

ambas apunten a elementos del mismo arreglo.

6. Dos variables punteros pueden ser comparadas siempre que ambas

apunten a datos del mismo tipo de datos.

Punteros y Funciones

Un rea en la cual desempean un papel prominente los apuntadores, en

el lenguaje C, es en 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:

...

X=5; printf (%d\n, x); funct(x); printf(%d\n, x); ...

void funct (int y) { ++y; printf(%d\n,y); return; }

La ejecucin del programa sera: 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, imprime el nmero 6 y regresa funct. Sin embargo, cuando se



incrementa el valor de "y", el valor de "x" permanece invariable. As, 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:

...

X=5; printf (%d\n, x); funct(&x); printf(%d\n, x); ...

void funct (int *py) { ++(*py); printf(%d\n, *py); return; }

La ejecucin del programa sera: Imprime nuevamente el nmero 5, y la

lnea 4 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 9 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. Luego se imprime 6 y cuando

regresa funct, 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.

Precauciones con los Apuntadores

Apuntadores No Inicializados:

Si se altera el valor al que apunta un puntero no inicializado, se

estar modificando cualquier posicin de la memoria.



main() { int* puntero; *puntero = 1200; /* Se machaca una zona cualquiera de la memoria */ }

Confusin De Tipos:

Un puntero a un tipo determinado puede apuntar a una variable de

cualquier otro tipo. Aunque el compilador lo puede advertir, no es un error.

(Afortunadamente, esto no ocurre en C++).

main() { int p; double numero; int* puntero;

p = &numero; /* incorrecto, pero el compilador no aborta */ *p = 33; /* Un desastre */ }

Apuntadores a variables locales fuera de mbito:

Si un puntero apunta a una variable local, cuando la variable

desaparezca el puntero apuntar a una zona de memoria que se estar

usando para otros fines. Si se des-referencia el puntero, los resultados son

imprevisibles y a menudo catastrficos.

main() { int* puntero;

while (...) { int local; puntero = &local; /* puntero apunta a una variable local */ ...

*puntero = 33; /* correcto */ } ...

/* ahora puntero apunta a una zona de memoria invlida */



puntero = 50; /* catstrofe */ }

Objetivo 4.- Estructuras


El uso de estructuras como una representacin o aproximacin de

registros de datos, ha sido una de las herramientas ms idneas usada en

la Programacin Estructurada para poder agrupar varios tipos de datos

primitivos en un solo a la final.


Conceptos Bsicos

Acceso a los componentes de una estructura.

Arreglos de Estructuras

Estructuras Anidadas

Apuntadores a estructuras.

Paso de estructuras a las funciones.



Conceptos Bsicos

Una Estructura es una coleccin de variables simples, que pueden contener

diferentes tipos de datos. Es un tipo de dato definido por el usuario. Son tambin

conocidas como Registros.

Ayudan a organizar y manejar datos complicados en programas debido a

que agrupan diferentes tipos de datos a las que se les trata como una sola

unidad en lugar de ser vistas como unidades separadas.

En 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. Algunos de los ejemplos usan la estructura:

struct stbarco{ char tipo[15]; char modelo[15]; char titular[20]; int anno; long int horas_motor; float precioventa; };

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 tipo[15]; char modelo[15]; char titular[20]; int anno; long int horas_motor; float precioventa; };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 tipo[15]; char modelo[15]; char titular[20]; int anno; long int horas_motor; float precioventa; };stbarco_usado;

Acceso a los Componentes de una Estructura

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.modelo);

Aqu, stbarco_usado es el nombre asociado con la estructura, y modelo es

una variable miembro de la estructura, otro ejemplo:



gets(stbarco_usado.tipo);

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.

printf(%f, stbarco_usado.precioventa);

Ejemplo de estructuras:

#include #include struct datos { char num_control[9];

char nombre[30]; int edad; char sexo; char domicilio[30];

};

struct datos alumno; void main ( ) { clrscr( ); printf(\nIntroduce los datos del alumno:); printf(\nNmero de Control:); gets(alumno.num_control); printf(\nNombre:); gets(alumno.nombre);

printf(\nEdad:); scanf(%d,&alumno.edad);

printf(\nSexo:); alumno.sexo=getchar( );

printf(\nDireccin:); gets(alumno.domicilio);

printf(\nLos datos capturados fueron:); printf(\nNmero de Control:); puts(alumno.num_control); printf(\nNombre:); puts(alumno.nombre);

printf(\nEdad:); printnf(%d,alumno.edad);

printf(\nSexo:); putchar(alumno.sexo); printf(\nDireccin:); puts(alumno.domicilio); getch ( ); }



Arreglos de Estructuras

Pueden ser construidas, es decir, conceptuar a los elementos de un arreglo

como estructuras, esto se puede hacer de la siguiente manera:

struct datos { char num_control[9];

char nombre[30]; int edad; char sexo; char domicilio[30];

};

struct datos alumnos[35]; /*Esta es la variable arreglo de estructura*/

Para tener acceso a una determinada estructura, se indexa el nombre de

la estructura de la siguiente manera: alumnos[i].nombre; aqu sabemos el nombre

del alumno que se encuentra en la posicin i del arreglo, y de esta manera para

todos los datos.

Estructuras Anidadas

Una estructura puede contener otras estructuras llamadas estructuras

anidadas. Las estructuras anidadas ahorran tiempo en la escritura de programas

que utilizan estructuras similares. Se han de definir los miembros comunes solo una

vez en su propia estructura y a continuacin utilizar es estructura como un

miembro de estructura. Consideremos las siguientes dos definiciones de

estructuras:

struct empleado { char nombre_emp[30];

char direccion[25]; char ciudad[20]; char provincia[20]; long int cod_postal; double salario;

};

struct clientes {



char nombre_cliente[30]; char direccion[25]; char ciudad[20]; char provincia[20]; long int cod_postal; double saldo;

};

Estas estructuras contienen muchos datos diferentes, aunque hay

datos que estn solapados. As, se podra disponer de una estructura,

info_dir que contuviera los miembros comunes. struct info_dir { char direccion[25];

char ciudad[20]; char provincia[20]; long int cod_postal;

}; Esta estructura se puede utilizar como miembro de las otras

estructuras, es decir anidarse.

struct empleado { char nombre_emp[30];

struct info_dir direccion_emp; double salario;

};

struct clientes { char nombre_cliente[30];

struct info_dir direccion_clien; double saldo;

};

Apuntadores a Estructuras

Un puntero tambin puede apuntarse a una estructura. Se puede

declarar un puntero a una estructura tal como se declara un puntero a

cualquier otro objeto y se declara un puntero estructura tal como se

declara cualquier otra variable estructura: especificando un puntero en

lugar del nombre de la variable estructura.

struct persona {



char nombre[30]; int edad; int altura; int peso;

}; struct persona empleado; struct persona persona *p; p = &empleado;

Cuando se referencia un miembro de la estructura utilizando el

nombre de la estructura, se especifica la estructura y el nombre del

miembro separado por un punto (.). Para referenciar el nombre de una

persona, utilice empleado.nombre. Se referencia una estructura utilizando el puntero estructura. Se utiliza el operador -> para acceder a un miembro de

ella.

Paso de Estructuras a las Funciones

C permite pasar estructuras a funciones, bien por valor o bien por

referencia utilizando el operador &. Si la estructura es grande, el tiempo

necesario para copiar un parmetro struct a la pila puede ser prohibitivo.

En tales casos, se debe considerar el mtodo de pasar la direccin

de la estructura. El siguiente programa muestra el pase de la direccin de

una estructura a una funcin para entrada de datos.

La misma variable la pasa por valor a otra funcin para salida de los

campos.

#include /*Define el tipo de estructura info_persona*/ struct info_persona { char nombre[30]; char calle[30]; char ciudad[25]; char provincia[25];

char codigopostal[6]; }; /*Prototipos de funciones*/



void entrad_pna(struct info_persona *pp); void ver_info(struct info_persona p); void main ( ) { struct info_persona reg_dat; entrad_pna(&reg_dat); /*Pasa por referencia la variable*/ ver_info(reg_dat); /*Pasa por valor*/ clrscr( ); printf(\nPulsa cualquier carcter para continuar\n); getchar( );

} void entrad_pna (struct info_persona *pp)

{ clrscr( ); puts(\nEntrada de datos de la Persona\n); /*Para acceder a los campos se utiliza el selector -> */ printf(\nNombre:); gets(pp->nombre); printf(\nCalle

guia teorica programacion ii (1)

Documents