Computación I :: Prof. Yeniffer Peña Lenguaje C Presentación Computación I

Zona de memoria que contiene la dirección de otra zona de memoria. Un apuntador contiene la dirección de memoria de una variable que contiene un valor específico. En este sentido, un nombre de variable se refiere directamente a un valor y un apuntador se refiere indirectamente a un valor. Punteros

Computación I Proporciona medios por los cuales se pueden modificar los argumentos de llamada de las funciones. Esto es, simular llamadas por referencia. Se usan para soportar rutinas de asignación dinámica de C. Crear y manipular estructura de datos que puedan crecer o encogerse caso de estas listas enlazadas, colas, pilas y árboles. Pueden mejorar la eficiencia de ciertas rutinas. Punteros Ventajas:

Computación I Puede provocar fallo del sistema por no estar inicializados o mal uso (forma incorrecta) de los mismos. Punteros Desventajas: Formato: Pueden ser de cualquier tipo de datos. Hay punteros que contienen la dirección de variables de cualquier tipo. tipo_dato * Nombre_Variable; Indicador de puntero

Computación I & Se refiere a su dirección. * Indica el valor de la variable puntero. Punteros Operadores: int i, *ap, variable; i ap variable Memoria ABF0 ABF4 ABF8 150 variable=150; ap = &variable; i = *ap; ABF8150 Ejemplo: (*ap)++; ap++; 151ABFC

Computación I Punteros int i, *ap, variable; variable=150; ap = &variable; i = *ap; Archivo “Punteros.c” (*ap)++; #include “stdio.h” #include “conio.h” void main() { } ap++; printf(“\n i=%d”, i); printf(“\n ap=%p”, ap); printf(“\n *ap=%d”, *ap); printf(“\n ap=%p”, ap); printf(“\n *ap=%d”, *ap); getch();

Computación I Ejecute la corrida del programa anterior, pero antes añada las variables i, ap, *ap, variable y &variable con la opción de menú Run/Add Watch… Luego, ejecute paso a paso el programa, presionando F8 y luego F7…. Punteros Practica de Laboratorio:

Computación I Se puede hacer de dos formas: la primera es asignando la dirección de una variable y la segunda es inicializarlo en el valor nulo. Ejemplo: Punteros Inicialización de Punteros: void main ( ) { int variable, *Ap1, *Ap2, *Ap3; Ap1=&variable; //Su contenido depende de la //dirección de variable Ap2=NULL; Ap3=0; } Si se usa un puntero antes de darle valor probablemente falle el programa y el sistema operativo, por eso es tan importante la inicialización de ellos.

Computación I 1 void main ( ) 2 { char k, *p; 3 k=’m’; 4 *p=k; 5 p=&k; 6 } Punteros Errores Comunes: 1 void main ( ) 2 { int n, *p; 3 n=10; 4 p=n; 5 printf(“%d”,*p); 6 p=&n; 7 } Puntero no inicializado Error en el uso del Puntero

Computación I Aunque & y * representa AND a nivel de bits y multiplicación cuando se usan como operadores punteros tienen mayor prioridad que todos los operadores aritméticos. Las variables punteros deben apuntar al tipo de dato correcto porque pueden dar resultados no deseados. El operador & y * son complementos, cuando se operan ambos de manera consecutiva en el apuntador, en cualquier orden, se imprimirá el mismo resultado. El especificador de conversión %p extrae la localización de memoria de un apuntador en formato hexadecimal. Punteros Notas Importantes:

Computación I void main( ) {int n, *p; n=5; p=&n printf(“%d”,n); printf(“\n%p”,p); printf (“\n%d”,*p); } Punteros Ejemplo: n p Memoria AC01 AD12 AC015 Pantalla 5 AC01 5

Computación I En lenguaje C existen dos tipos de parámetros al invocar funciones, estos son: por valor y por punteros. Cuando los argumentos se pasan en llamada por valor, se efectúa una copia del valor del argumento y ésta se pasa a la función invocada. Las modificaciones a la copia no afectan el valor original de la variable. La llamada de funciones donde intervienen parámetros por punteros debe ser utilizada sólo en llamadas confiables, que necesitan modificar la variable original. La palabra reservada return sólo se utiliza en las funciones en las cuales un parámetro por valor es devuelto hacia la función invocada. Funciones

Computación I Paso de argumentos a una función: Funciones Paso por valor #include int cuadrado_por_valor (int nx); void main( ) { int n, c; printf(“\nIntroduzca un numero: "; scanf(“%d”,&n); printf(“\nEl valor inicial de n es: %d“, n); c=cuadrado_por_valor(n); printf(“\nEl valor final de n es: %d y el cuadrado es %d“, n, c); getch( ); } int cuadrado_por_valor (int nx) { nx = nx * nx; return (nx); }

Computación I Funciones #include void cuadrado_por_punteros (int *); void main( ) { int n; printf(“\nIntroduzca un numero: "; scanf(“%d”,&n); printf(“\nEl valor inicial de n es: %d“, n); cuadrado_por_punteros (&n); printf(“\nEl valor final de n es: %d y el cuadrado es %d“, n, n); getch( ); } void cuadrado_por_punteros (int *nptr) { *nptr *= *nptr; } Paso de argumentos a una función: Paso por punteros o referencia

Computación I Se le conoce a este paso de punteros como paso por referencia. Cuando un argumento se pasa por referencia, la dirección del dato es pasada a la función. El contenido de esta dirección puede ser accedido libremente. Además, cualquier cambio que se realiza al dato (al contenido de la dirección) será reconocido en ambas, la función y rutina de llamada. Así, el uso de punteros como argumentos de funciones permite que el dato sea alterado globalmente desde dentro de la función. Los argumentos formales que sean punteros deben ir precedidos por un asterisco (*). Funciones

Computación I Para pasar todo un arreglo a una función, el nombre del arreglo debe aparecer solo, sin corchetes, ni índices, como un argumento real en la llamada a la función. El correspondiente argumento formal debe ser declarado como un arreglo. Si se trata de un arreglo unidimensional o vector que se desea declarar como un argumento formal, el arreglo se escribe con un par de corchetes vacíos. Los arreglos multidimensionales se definen prácticamente de la misma manera que los unidimensionales, excepto que se requiere un par separado de corchetes para cada índice. Pudiéndose dejar el primer par de corchetes vacíos. Si un elemento del arreglo es alterado dentro de una función, esta alteración será reconocida en la parte del programa desde la que se hizo la llamada. Funciones Paso de arreglos a una función:

Computación I Funciones #include void cargar (int nx, int vector[]); float promedio( int nx, int vector[ ] ); void main( ) { int i; int vec [5]; cargar(5,vec); printf(“\nEl promedio es %.2f”, promedio (5, vec)); getch(); } void cargar (int nx, int vector[ ]) { int i; for (i=0; i<nx; i++) scanf(“%d”,&vector[i]); } Paso de arreglos a una función: float promedio (int nx, int vector[ ]) { int i, acum=0; for (i=0; i<nx; i++) acum=acum+vector[i]; return( (float) acum/nx ); }

Computación I Es posible declarar el argumento formal vector como un puntero y no como un arreglo: En vez de int vector[ ] int *vector Entonces, el acceso a cada elemento cambia, debido a que vector apunta a la dirección del primer elemento del vector, por ende, al incrementar esta dirección, se apunta a la dirección del próximo elemento, y así, sucesivamente. Funciones Paso de arreglos a una función:

Computación I Funciones #include void cargar (int nx, int *vector); float promedio( int nx, int *vector ); void main( ) { int i; int vec [5]; cargar(5,vec); printf(“\nEl promedio es %.2f”, promedio (5, vec)); getch(); } void cargar (int nx, int *vector) { int i; for (i=0; i<nx; i++) scanf(“%d”, vector+i); } Paso de arreglos a una función: float promedio (int nx, int * vector) { int i, acum=0; for (i=0; i<nx; i++) acum = acum + *(vector+i); return( (float) acum/nx ); }

Computación I Funciones #include void cargar (int nx, int *vector); float promedio( int nx, int *vector ); void main( ) { int i,op; int vec [5]; do{ printf(“\n1. Cargar vector”); printf(“\n2. Promedio”); printf(“\n3. Salir”); printf(“\nOpcion: ”); scanf(“%d”,&op); switch(op){ 1: {cargar(5,vec); break;} 2: {printf(“\nEl promedio es %.2f”, promedio (5, vec)); break;} 3: {printf(“\nHasta Luego”); break;} } }while(op!=3); getch(); } Menú de Opciones void cargar (int nx, int *vector) { int i; for (i=0; i<nx; i++) scanf(“%d”, vector+i); } float promedio (int nx, int * vector) { int i, acum=0; for (i=0; i<nx; i++) acum = acum + *(vector+i); return( (float) acum/nx ); }