Algoritmo y Lógica de Programación

Ing. Alexandra Varela Tapia, Msig. Mdges.

 Repaso de la clase anterior
1. Estructura es un espacio de memoria donde se
agrupan datos de diferentes tipos de datos
2. Las partes de la estructura
• campo
• registro
3. Operaciones básicas sobre la estructura
• Llenado de datos
• Extracción de datos
4. El modelado de los problemas permite
identificar
• Requerimientos del usuario
• Identificar las entidades y sus características
• Diseñar las estructuras con sus campos
Capítulo 3
Tipos de datos estructurados y
punteros
 Contenido

•3.5. Punteros: definición y operadores

Objetivo de la clase:
Identificar el funcionamiento de la variable
puntero en la referencia a los datos
3.5. Punteros
 Punteros

1. Punteros y direcciones
2. Aritmética de direcciones
3. Usos del puntero
3.1 apuntar a una variable simple (tipos de datos básicos)
3.2 apuntar a un arreglo
3.3 apuntar a una estructura
3.4 apuntar a un arreglo de estructura
3.5 con funciones propias del programador (envío e
parámetros por referencia mediante punteros) Capítulo 4
 Introducción

• La computadora guarda las variables en la memoria

y cada espacio de memoria tiene una dirección.

• Normalmente no necesitamos saber la dirección en

la que está guardada una variable, ya que nos
referimos a ella por su nombre.

• Pero en ciertas ocasiones es necesario conocer la

dirección de la variable para manipular su
contenido mediante otra variable, este es el
puntero.
 Punteros o apuntadores

• Definición
• Es una variable que guarda una dirección de memoria de
otra variable

• Sintaxis
tipo_dato *nombre_puntero;

• Ejemplo
int *p1; double *p3;
float *p2; char *p4;
 Consideraciones generales

• En la siguiente declaración:
int *p, n;
p=&n; //guarda la dirección de memoria de n
p es una variable de tipo puntero a un entero
n es una variable de tipo entero

• Otro ejemplo
int *p; float m; p=&m; ERROR

NOTA: Puntero debe ser del mismo tipo de dato de la variable

 Operador dirección &

• Se utiliza para obtener la dirección de una variable y

se puede usar con el siguiente formato:
&nombreVar;

• Ejemplo:
int *p, n;
p=&n; //asigna dirección variable n al puntero p
 Operador indirección *

• El operador * aplicado a una variable de tipo apuntador,

genera el valor de la variable a la cual apunta.

• Ejemplo:
int *p,n, x;
p=&n;
n = 8;
x = *p; // *p se refiere al contenido de la variable n

printf(“%d”,x); //imprime 8
 Veamos ejemplo gráfico

/*Dirección que guarda

de la variable */

/*indirección: valor de la
variable que apunta */
printf(“%d”, *p); //saldrá 10
 El valor NULL (nulo)

• Para indicar que una variable no apunta a nada se

utiliza el valor Nulo (NULL).

• Ejemplo
int *p;
p=NULL; //puntero está encerado
 Ejemplo 1

Si ejecutamos:
b: 5
p: 23000 //asumiendo
p: 5
 Ejemplo 2

Si ejecutamos:
b: 5
p: 23000 //asumiendo
p: 5
resultado: 15
 Ejemplo 3

Si ejecutamos:
b: 5
p: 23000 //asumiendo
p: 5
resultado: 15
resultado: 13
Ejemplo 4
21FF0 23FF7

28FX0
 Aritmética de punteros

• Operaciones básicas
• Incremento

p = p + 1;
p++;

• decremento

p = p – 1;
p--;
 Operador +
•Cada vez que un apuntador se incrementa,
apunta a la localidad de memoria del siguiente
elemento de su tipo base.

3501
3500

p = p + 1;

p p
p ++;
 Operador +

• Por ejemplo, suponer la siguiente declaración:

int *p1, *p2; int x; p1=&x;

Suponer que p1 contiene la dirección de memoria 2500.

p1 2500
Al ejecutar la operación:
p2 = p1 + 4; 2501

2502

queda de la siguiente manera: 2503

p2 2504
 Operador -

• Cada vez que se decrementa, apunta a la localidad de

memoria del elemento anterior.
• Esta forma de trabajar asegura que siempre un apuntador
apunta a un elemento apropiado de su tipo base.

• Ejemplo p2 2496
int *p1, *p2; int x; p1=&x;
2497
p2 = p1 - 4;
2498

2499

p1 2500
 Funciones para punteros

•De la librería stdio.h las funciones para

manejo de punteros son
• sizeof
• malloc
• free
Función sizeof

Sizeof.- Extrae el
tamaño en bytes
 malloc .- Reserva memoria
para un dato
Función malloc y free

free .- libera espacio de

memoria
return 0; }
 Relación entre punteros y arreglos

m[0]

//porque m es un puntero por defecto

Tercer elemento
 Por lo tanto…

• En la expresión *(p+2)
• al sumar 2 al apuntador p, no se está sumando el número
2 sino que se está avanzando 2 posiciones en la memoria;
• es decir, p es un apuntador a entero, por lo que al sumarle
2 se avanza el espacio de memoria necesario para avanzar
2 posiciones enteras.

• El paréntesis es necesario porque el operador *

tiene una prioridad más alta que el operador +.
 Ejemplo 1

Suponer que se tiene declarado el siguiente arreglo:

int array[10] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 0};
que muestra en la pantalla el siguiente segmento de código:

int *p;

p = array;
*p = 20;
*(p + 2) = 40;
*(array + 5) = 60;

for (int i =0; i<10; i++)

printf(“%d ”,arreglo[i]);
Ejemplo 2
int main() {
int vector[5] = {1, 2, 3, 4, 5};
Ejemplo 3
int *p1;
int *p2;

//guardando posiciones de memoria

p1=&vector[0];
p2=&vector[2];
printf("p1 apunta a: %d\n",*p1);
printf("p2 apunta a: %d\n",*p2);

//operaciones con punteros

p1++;
printf("se le suma 1, p1 apunta a: %d\n",*p1);

p2--;
printf("se le resta 1, p2 apunta a: %d\n",*p2);

p1=p1+2;
printf("se le suma 2, p1 apunta a: %d\n",*p1);

p1=p1-3;
printf("se le resta 3, p1 apunta a: %d\n",*p1);
getch();
return 0; }
 Ejemplo 4
#include <conio.h>
#include <stdio.h>
int main() {
int notas[5] = {0, 0, 0, 0, 0};
int *p;

p = notas;

printf("\n\nIngresando las notas\n\n");

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

printf("Nota %d: ",i+1);
scanf("%d",&notas[i]);
}

printf("\n\nMostrando las notas\n\n");

for(int i =0; i<5; i++){
printf("%d ",*(p+i));
//printf("%d ",*p); otra forma
//p++; otra forma
}
 Operadores para acceder a los campos
- estructura
- arreglo de estructura
• Para acceder a los campos de la estructura, sea
para guardar o recuperar datos, se utilizan los
operadores:

Operador punto .
(para una variable struct)

Operador puntero ->

(para un puntero struct)
 Ejemplo Una estructura estudiante
struct estudiante {
char nombre[40];
int matricula;
float nota;
};
struct estudiante est, *ptrE;
Accediendo a los campos
ptrE=&est; con el puntero struct
…….
printf(“\n Estudiante %s”, prtE->nombre);
printf(“\n Matricula $ %.2f”, prtE->matricula);
printf(“\n Nota %.2f”, prtE->nota);
 Ejemplo
un arreglo de estructura categoria

Accediendo a los campos

con el puntero struct
 Repaso de lo aprendido

• Puntero es una variable que almacena direcciones de

memoria de otra variable.
• El puntero debe ser del mismo tipo de la variable que
almacena su dirección.
• Mediante el puntero se puede acceder a manipular los datos
de la variable que apunta.
• La aritmética de punteros se relaciona con el
desplazamiento en memoria sea para avanzar a una
siguiente posición o retroceder a una posición de memoria.
• Otro uso del puntero permite acceder a los elementos de un
vector tradicional y un vector de estructura.