ESTRUCTURA DE DATOS Y

ALGORITMOS I
Apuntadores
Contexto
Lenguaje C es un lenguaje de alto nivel porque permite
programar a bajo nivel. La programación a bajo nivel se refiere a
la manipulación de los recursos físicos de un equipo
computacional. Los apuntadores manipulan de manera directa las
localidades de memoria RAM de la computadora.
Contexto
Los apuntadores permiten a los programadores simular las
llamadas por referencia, y crear y manipular estructuras de datos
dinámicas, es decir, estructuras de datos que pueden crecer y
encogerse en tiempo de ejecución.
Definición
Un apuntador es una variable cuyo valor es una dirección de
memoria de otra variable que contiene un valor específico.

anio ptrAnio anio

2019 0xAF41 2019
 Declaración Tipo de dato Nombre o
identificador
Asterisco
● Ejemplos:

○ int *ptrAnio = NULL; int *ptrAnio;

○ char *puntero = 0; ¿Cómo describirlo? R:
- “ptrAnio es un apuntador a un int
○ float *pointer = NULL; (entero)”.
- “ptrAnio apunta a un objeto de tipo
● Los apuntadores pueden definirse para apuntar a
objetos (variables o arreglos) de cualquier tipo int”.
de dato.
 Asignación
Nombre Valor Dirección
int anio = 2019;
int *ptrAnio = NULL; // declaración
ptrAnio = &anio; // asignación anio 2019 28ff19

Operador de dirección ( & ): 28ff19 a8dgg1

- Devuelve la dirección de su operando.
ptrAnio
 Indirección

int anio = 2019;

int *ptrAnio; // declaración
Operador de indirección o de ptrAnio = &anio; // asignación
desreferencia ( * ):
- Devuelve el valor al que apunta su operando. // obteniendo el valor de la variable a la que se está apuntando

printf(“%d”, *ptrAnio);
 Ejemplo Nota. Alguno especificadores de conversión:

%c - Carácter ASCII correspondiente

#include <stdio.h>
%d, %i - Decimal con signo de un entero

int main() { %x, %X - Hexadecimal sin signo

int anio = 2019; %p - Dirección de memoria (puntero)
int *ptrAnio = NULL; %e, %E - Coma flotante con signo en
ptrAnio = &anio; notación científica

%f, %F - Coma flotante con signo, usando

printf( "Valor de anio es: %d", anio ); punto decimal

printf( "\nDirección de anio es: %x", &anio ); %g, %G - Coma flotante, usando la notación
que requiera menor espacio
printf( "\nValor de ptrAnio es: %p", ptrAnio );
printf( "\nValor al que apunta ptrAnio es: %d", *ptrAnio ); %o - Octal sin signo de un entero

%u - Decimal sin signo de un entero

return 0; %s - Cadena de caracteres (terminada en '\0')
}
Llamada a funciones
Existen dos maneras de pasar argumentos a una función:
mediante llamadas por valor y mediante llamadas por referencia.
Ejemplo
#include<stdio.h>

int varGlobal = 5; // Variable Global

void miFuncion(); // Prototipo de funcion

void main(){
int varMain = 1; // Variable Local
miFuncion(); // Invocando la funcion
//printf("%d \n", varFuncion); // Error
}

void miFuncion(){
int varFuncion = 7; // Variable Local
printf("%d \n", varFuncion);
printf("%d \n", varGlobal);
//printf("%d \n", varMain); // Error
}
Llamada a funciones por referencia

Cuando se trabaja con “llamadas por valor” en realidad se envía

una copia del valor original a la función de tal manera que, si ésta
modifica el contenido de la variable, el valor original no se verá
afectado. Por otro lado, cuando se trabaja con “llamadas por
referencia” en realidad se envía un apuntador hacia el valor
original y, por ende, en realidad se está trabajando con dicho
valor todo el tiempo.
Ejemplo
#include<stdio.h>
void pasarValor( int );
void pasarReferencia( int * ); void pasarValor( int equis ){
printf("%d\n", equis);
int main(){ equis = 128;
int numero = 55; printf("%d\n", equis);
int *ap; }
ap = &numero;
void pasarReferencia( int *equis ){
printf("Pasar valor: %d\n", *ap); printf("%d\n", *equis);
pasarValor(*ap); *equis = 128;
printf("Pasar referencia de: %d\n", *ap); printf("%d\n", *equis);
pasarReferencia(ap); }
printf("Valor final: %d\n", *ap);
return 0;
}
Aritmética de apuntadores
Los apuntadores son operandos válidos dentro de las
expresiones aritméticas, expresiones de asignación y expresiones
de comparación.

Se puede realizar un conjunto limitado de operaciones con los

apuntadores. Un apuntador se puede incrementar(++) o
decrementar(--), se puede sumar un entero a un apuntador (+ o
+=), se puede restar un entero a un apuntador (- o -=) y se puede
restar un apuntador a otro.
 printf( "La cadena es:\n" );
Ejemplo imprimeCaracteres( cadena );
printf( "\n" );
#include <stdio.h>
return 0;
void }
imprimeCaracteres( ch
ar *ptrLaCadena ); // Recorre un arreglo hasta encontrar el caracter nulo
void imprimeCaracteres(char *ptrLaCadena ) {
int main() { while ( *ptrLaCadena != '\0' ) {
char cadena[] = printf( "%c", *ptrLaCadena );
"CARACTERES DE ptrLaCadena++;
UNA CADENA"; }
}

NOTA. \0 Secuencia de escape para caracter nulo (fin de cadena).

Arreglos de apuntadores
Los arreglos pueden contener apuntadores. Uno de los usos
comunes de los arreglos de apuntadores es el de formar un arreglo
de cadenas, llamado también arreglo cadena. Cada elemento en el
arreglo es una cadena, pero en C una cadena es, en esencia, un
apuntador a su primer carácter.
 ‘F’ 0xA00

Ejemplo ‘a’ 0xA01

#include <stdio.h> ... ---------

‘\0’ 0xA08
void main() {
‘d’
int i = 0; 0xA09
char *ptrArrCadenas[ 3 ] = ‘e’
0xA0A
{ "Facultad", "de", "Ingenieria" };
‘\0’
0xA0B
while( i < 3 ) { ‘I’
0xA0C
printf( "%x = ", ptrArrCadenas[ i ] );
printf( "%s - ", *( ptrArrCadenas +
i ) ); ptrArrCadenas[ 0 ] 0xA00
printf( "%s\n", ptrArrCadenas [ i ] ); ptrArrCadenas[ 1 ] 0xA09
i++;
ptrArrCadenas[ 2 ] 0xA0C
}
Ejemplo
#include <stdio.h>

void main () {
char cadena0[] = "elNombre";
char cadena1[] = "elApellidoPat";
char cadena2[] = "elApellidoMat";
char *arrPtrs[3];
int i;
arrPtrs[0] = cadena0;
arrPtrs[1] = cadena1;
arrPtrs[2] = cadena2;

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

printf( "%s ", *(arrPtrs + i) );
}
 Apuntador a
apuntador Nombre Valor Dirección
#include <stdio.h>

int main () { anio

2020 28ff19
int anio;
int *ptrAnio; ptrAnio
28ff19
int **pPtrAnio; a8dgg1
anio= 2020;
ptrAnio= &anio; pPrtAnio
pPtrAnio = &ptrAnio;
a8dgg1 93dega
printf( "Valor de anio = %d\n", anio );
printf( "Valor disponible en *ptrAnio = %d\n", *ptrAnio );
printf( "Valor disponible en **pPtrAnio = %d\n", **pPtrAnio);

return 0;
}
 Tipo de dato
#include <stdio.h> que devuelve
Tema extra: Apuntadores
int suma (int, int);
a funciones Nombre o
Tipo de
Parámetro(s)
identificador
void main() {
int (*apFuncion) (int, int) = NULL;
- Los apuntadores pueden definirse para apuntar a apFuncion = suma;
objetos -incluyendo funciones- de cualquier
tipo de dato. printf( "Ej ::: %d", apFuncion( 4, 3 ) );
printf( "\nLa direccion de suma es:
%p\n", apFuncion );
- Por lo tanto el apuntador guardará la dirección }
de memoria donde está la función.
int suma (int a, int b){
return a + b;
}