INSTITUTO POLITÉCNICO NACIONAL
PORTADA
ESIME - Escuela Superior de Ingeniería Mecánica y
Eléctrica Unidad Culhuacán
Materia:
Fundamentos de la programación
Tarea:
UNIDAD 4
Grupo:
1CM45
Alumno:
García Servín Diego
pág. 1
Contenido
PORTADA ...................................................................................................................................... 1
INTRODUCCIÓN ............................................................................................................................ 3
ARREGLOS .................................................................................................................................... 4
¿QUÉ SON? ................................................................................................................................................................................... 4
ARREGLOS UNIDIMENCIONALES:............................................................................................... 4
ARREGLOS BIDIMENCIONAL: ...................................................................................................... 6
ARREGLOS NUMERICOS UNIDIMENCIONALES ............................................................................................................ 7
CARACTERES UNIDIMENCIONALES ................................................................................................................................. 8
ARREGLOS NUMERICOS BIDIMENCIONALES ............................................................................................................... 8
CARACTERES BIDIMENSIONALES ..................................................................................................................................... 9
APUNTADORES........................................................................................................................... 11
REFERENCIACIÓN.................................................................................................................................................................. 11
TIPOS DE APUNTADORES ......................................................................................................... 11
BÁSICO ........................................................................................................................................................................................ 11
ESTRUCTURAS......................................................................................................................................................................... 11
DECLARACIÓN DE APUNTADORES ................................................................................................................................ 12
DESREFERENCIACIÓN DE APUNTADORES ................................................................................................................. 12
OPERADOR DE ACCESO A MIEMBROS -> ..................................................................................................................... 12
VERIFICACIÓN DE TIPOS DE APUNTADORES............................................................................................................ 13
APUNTADORES NULOS........................................................................................................................................................ 13
APUNTADORES A APUNTADORES.................................................................................................................................. 13
APUNTADORES CONSTANTES Y APUNTADORES A CONSTANTES .................................................................. 14
APUNTADORES, ARREGLOS Y ARITMÉTICA DE APUNTADORES...................................................................... 14
ASIGNACIÓN DINÁMICA DE MEMORIA ........................................................................................................................ 15
RELACIÓN DE APUNTADORES CON ARREGLOS .................................................................... 16
pág. 2
INTRODUCCIÓN
Hoy abordaremos una serie de conceptos esenciales de programación en el lenguaje C,
centrándonos en arreglos y apuntadores, así como en su interrelación. Comenzaremos con los
arreglos unidimensionales, conocidos como vectores, que almacenan secuencias lineales de datos
homogéneos. Analizaremos cómo declarar, inicializar y manipular estos arreglos, así como cómo
acceder a sus elementos mediante índices.
Luego, exploraremos los arreglos bidimensionales, también llamados matrices, que almacenan
datos en formato de tabla, con filas y columnas. Discutiremos cómo declarar, inicializar y manejar
matrices, y cómo acceder a sus elementos utilizando dos índices. A continuación, estudiaremos los
arreglos de caracteres, tanto unidimensionales como bidimensionales, para almacenar cadenas de
texto y tablas de texto, respectivamente. Aprenderemos sobre la terminación nula de las cadenas
de texto y cómo manipular estos arreglos.
Después, nos enfocaremos en los apuntadores, que son variables que almacenan direcciones de
memoria, y cómo se utilizan para acceder a los datos en variables y arreglos. Veremos cómo
declarar, asignar y desreferenciar apuntadores. Examinaremos la relación entre apuntadores y
arreglos en C, ya que el nombre de un arreglo actúa como un apuntador constante al primer
elemento del arreglo. Descubriremos cómo emplear la aritmética de apuntadores para navegar por
un arreglo y manipular sus elementos de manera flexible.
Además, discutiremos operaciones comunes con apuntadores, como asignación,
desreferenciación, aritmética y comparación de apuntadores, y cómo trabajar con apuntadores a
apuntadores para permitir múltiples niveles de indirección, también estudiaremos cómo declarar
apuntadores constantes y apuntadores a constantes para manejar restricciones de dirección y
modificación de valores.
Por último, aprenderemos a asignar memoria dinámicamente utilizando las funciones malloc() y
free() en C, y los operadores new y delete en C++. Analizaremos ejemplos de cómo reservar y
liberar memoria para estructuras de datos dinámicas.
Estos temas son fundamentales para manejar datos de manera eficiente y nos prepararán para
enfrentar problemas de programación más avanzados. Los libros de Kernighan y Ritchie, Ceballos,
y Deitel ofrecen información adicional sobre estos conceptos【Kernighan y Ritchie, Lenguaje de
Programación C; Ceballos, Enciclopedia del Lenguaje C; Deitel y Deitel, Cómo programar en C/C++
】.
pág. 3
ARREGLOS
Estamos llegando al final de esta unidad y es
momento de introducir nuevos conceptos que
resultan aún más interesantes. Los temas previos
también han sido fundamentales, ya que nos han
permitido comprender conceptos como funciones,
caracteres y lenguajes de programación, ampliando
así nuestro conocimiento en el campo.
En este capítulo, nos enfocaremos en el tema de los
arreglos, una estructura de datos esencial en
programación que nos permitirá manejar
colecciones de datos de manera más eficiente
¿QUÉ SON?
Bueno, existe otra forma de llamarles y esta es “Array” estos son una estructura de datos que
permite almacenar múltiples elementos del mismo tipo dentro de una sola variable. Hasta ahora,
hemos trabajado con variables y constantes, pero los arreglos representan un nivel adicional de
complejidad. Los arreglos contienen una serie de elementos homogéneos, como una lista de
números o palabras, almacenados en celdas de memoria adyacentes.
En C, los arreglos se definen con un tipo de dato específico y un tamaño fijo. Los elementos se
almacenan en ubicaciones de memoria contiguas, lo que facilita el acceso rápido a cualquier
elemento usando un índice. Es importante tener en cuenta que los índices de un arreglo en C suelen
comenzar en 0.
El acceso a los elementos se realiza a través de punteros, lo que permite la manipulación eficiente
de los datos. Además, el código puede ser diseñado para acceder de forma aleatoria a los
elementos dentro del arreglo, lo que proporciona flexibilidad en la gestión de datos y optimiza las
operaciones sobre la colección. En cuanto a los tipos de arreglos, existen varias formas de clasificar
los arrays en C. Uno de ellos es el arreglo unidimensional, también conocido como vector o lista
ARREGLOS UNIDIMENCIONALES :
Un arreglo unidimensional es un conjunto de elementos del mismo tipo y tamaño que se almacenan
en posiciones consecutivas de memoria. Estos elementos comparten un tipo de datos y están
organizados en una única dimensión. El tamaño del arreglo es fijo y se define al momento de la
declaración.
Por ejemplo, se puede escribir un programa sencillo que solicite al usuario que introduzca varios
números para almacenarlos en un arreglo. Luego, el programa muestra el contenido del arreglo.
EJEMPLO:
#include <stdio.h>
int main() {
int arreglo[5]; // Definición de un arreglo unidimensional de tamaño 5
int i; // Solicitar al usuario que introduzca 5 números
printf("Introduce 5 números:\n");
pág. 4
for (i = 0; i < 5; i++) {
printf("Número %d: ", i + 1);
scanf("%d", &arreglo[i]);
} // Mostrar el contenido del arreglo
printf("\nContenido del arreglo:\n");
for (i = 0; i < 5; i++) {
printf("arreglo[%d] = %d\n", i, arreglo[i]);
} return 0;
pág. 5
ARREGLOS BIDIMENCIONAL :
Los arreglos bidimensionales, también conocidos como matrices, son estructuras de datos que
almacenan elementos en forma de tabla. Estos arreglos se componen de filas y columnas,
permitiendo almacenar datos en una estructura bidimensional. Al igual que los arreglos
unidimensionales, los elementos de una matriz son del mismo tipo y tamaño.
En un arreglo bidimensional, los elementos se organizan en una cuadrícula, y se pueden acceder
mediante dos índices: uno para la fila y otro para la columna. Esta estructura resulta útil para
representar datos que tienen una relación tabular, como una hoja de cálculo o una tabla de datos.
#include <stdio.h>
int main() {
int matriz[3][3]; // Definición de una matriz de 3 filas y 3 columnas
int i, j;
// Solicitar al usuario que introduzca valores para llenar la matriz
printf("Introduce los valores para una matriz de 3x3:\n");
for (i = 0; i < 3; i++) {
for (j = 0; j < 3; j++) {
printf("Matriz[%d][%d]: ", i, j);
scanf("%d", &matriz[i][j]);
// Mostrar el contenido de la matriz
printf("\nContenido de la matriz:\n");
for (i = 0; i < 3; i++) {
for (j = 0; j < 3; j++) {
printf("%d ", matriz[i][j]);
printf("\n");
return 0;
pág. 6
}
Los arreglos son estructuras de datos que organizan información en conjuntos reservando espacio
en memoria para su almacenamiento y consulta eficiente.
ARREGLOS NUMERICOS UNIDIMENCIONALES
Los arreglos numéricos unidimensionales, o vectores, son secuencias lineales de datos numéricos
almacenados de forma continua en memoria.
● Organización lineal: Los elementos se almacenan secuencialmente, lo que permite un
acceso eficiente.
● Índices: Los elementos se acceden mediante índices que comienzan en 0 y terminan en el
tamaño del arreglo menos uno.
● Tipo de datos homogéneo: Los elementos deben ser del mismo tipo de datos numéricos,
como int, float o double.
● Tamaño fijo: El tamaño del arreglo se define al momento de la declaración y no puede
cambiar durante la ejecución del programa.
● Acceso eficiente: Los elementos se pueden acceder de forma rápida a través de sus
índices.
EJEMPLO:
#include <stdio.h>
int main()
int numeros[5] = {10, 20, 30, 40, 50}; // Declaración de un arreglo de 5
enteros
// Acceso y modificación de elementos del arreglo
numeros[2] = 35; // Cambiar el tercer elemento a 35
// Imprimir todos los elementos del arreglo
for (int i = 0; i < 5; i++) {
printf("%d ", numeros[i]);
return 0;
}
pág. 7
CARACTERES UNIDIMENCIONALES
Los arreglos de caracteres unidimensionales son secuencias de caracteres o cadenas de texto.
● Secuencia de caracteres: Los elementos se almacenan de forma lineal, lo que permite
representar palabras o frases.
● Tipo de datos homogéneo: Todos los elementos son de tipo char, representando letras,
números o símbolos.
● Tamaño fijo: El tamaño se establece al declarar el arreglo y no puede cambiarse durante la
ejecución del programa.
● Terminación nula: En lenguajes como C, las cadenas de texto terminan con un carácter
nulo ('\0') que indica el final de la cadena.
EJEMPLO:
#include <stdio.h>
int main()
char mensaje[] = "Hola, mundo!"; // Declaración de un arreglo de caracteres
// Modificación del mensaje
mensaje[5] = 'M'; // Cambiar el carácter en la posición 5
// Imprimir el mensaje modificado
printf("%s\n", mensaje);
return 0;
ARREGLOS NUMERICOS BIDIMENCIONALES
Los arreglos numéricos bidimensionales, o matrices, son estructuras que almacenan datos
numéricos en filas y columnas.
● Representación tabular: Los elementos se organizan como una tabla, facilitando la
visualización y manipulación bidimensional de los datos.
● Índices dobles: Los elementos se acceden mediante dos índices, uno para la fila y otro
para la columna.
● Homogeneidad: Los elementos deben ser del mismo tipo de datos numéricos.
pág. 8
● Memoria contigua: Los elementos se almacenan de forma continua en memoria, lo que
mejora la eficiencia de acceso.
EJMPLO:
#include <stdio.h>
int main()
int matriz[2][3] = { {1, 2, 3}, {4, 5, 6} }; // Declaración de una matriz de 2x3
// Acceso y modificación de elementos de la matriz
matriz[1][2] = 8; // Cambiar el elemento en la segunda fila y tercera columna a 8
// Imprimir todos los elementos de la matriz
for (int i = 0; i < 2; i++) {
for (int j = 0; j < 3; j++) {
printf("%d ", matriz[i][j]);
printf("\n");
return 0;
CARACTERES BIDIMENSIONALES
Los arreglos de caracteres bidimensionales son tablas de cadenas de texto organizadas en filas y
columnas.
● Conjunto de cadenas: Permiten almacenar múltiples cadenas de texto.
● Índices dobles: Los elementos se acceden mediante dos índices, uno para la fila y otro
para la columna.
● Homogeneidad: Todos los elementos son de tipo char, permitiendo trabajar con palabras
o frases.
● Flexibilidad: Permiten manejar múltiples cadenas de longitud fija o variable.
pág. 9
Los arreglos numéricos y de caracteres, tanto unidimensionales como bidimensionales, son
herramientas esenciales para trabajar con datos de forma eficiente en programación. Los arreglos
unidimensionales son útiles para secuencias simples, mientras que los bidimensionales permiten
gestionar datos más complejos en forma de tabla.
Ejemplo:
#include <stdio.h>
int main() {
char frases[3][20] = {
"Buenos días",
"Buenas tardes",
"Buenas noches"
}; // Declaración de un arreglo de 3 cadenas de texto
// Modificación de una cadena
frases[1][8] = 'T'; // Cambiar el carácter en la posición 8 de la segunda cadena
// Imprimir todas las cadenas
for (int i = 0; i < 3; i++)
printf("%s\n", frases[i]);
return 0;
Hemos visto cómo los arreglos son secuencias lineales de datos almacenados de forma continua
en la memoria. Ahora, este concepto está estrechamente relacionado con otro tema fundamental
en C: los apuntadores. Los apuntadores son variables que almacenan direcciones de memoria y
pueden utilizarse para acceder y manipular datos en ubicaciones específicas de memoria. Debido
a que los arreglos se almacenan de forma continua, un apuntador puede apuntar al primer elemento
de un arreglo y, a través de aritmética de apuntadores, recorrer el resto de los elementos.
Esta conexión entre apuntadores y arreglos nos permite trabajar con datos de manera eficiente y
flexible, ya que podemos acceder y modificar elementos de un arreglo a través de su dirección de
memoria, y también realizar operaciones más avanzadas como pasar arreglos a funciones o
manejar memoria dinámica. A lo largo de este nuevo tema, explicaremos cómo los apuntadores nos
permiten manipular datos de diversas formas y mejorar el rendimiento de nuestras aplicaciones en
C.
pág. 10
APUNTADORES
Cuando se declara una variable en C, el compilador asigna un espacio de memoria para ella y
vincula su nombre con la dirección de memoria donde comienza el almacenamiento de sus datos.
Estas direcciones de memoria suelen expresarse como números en formato hexadecimal.
Un apuntador es una variable que almacena la dirección de memoria de otra variable. Se dice que
un apuntador "apunta" a la variable cuyo valor se encuentra en la dirección de
memoria almacenada por el apuntador. Por ejemplo, si un apuntador p contiene la dirección de
memoria de una variable x, decimos que "p apunta a x". Esta relación permite a los programadores
manipular los datos de x de forma indirecta a través de p.
REFERENCIACIÓN
La referenciación es el proceso de obtener la dirección de memoria de una variable. Se logra
utilizando el operador unario &, que se coloca antes de la variable cuya dirección se quiere obtener.
EJEMPLO:
int x = 25;
cout << "La dirección de x es: " << &x << endl;
El programa imprime la dirección de memoria de x, que se verá como un número en formato
hexadecimal, por ejemplo, "0x4fffd34". Este valor puede variar en cada ejecución del programa, ya
que el sistema puede asignar diferentes espacios de memoria para la variable en cada ocasión. Por
lo tanto, la dirección de x no es constante entre ejecuciones.
TIPOS DE APUNTADORES
BÁSICO
Apuntadores a Tipo Básico: Los apuntadores pueden apuntar a variables de tipos de datos
primitivos como int, float, double o char.
EJEMPLO:
int x = 10;
int *p = &x; // Apuntador a int
ESTRUCTURAS
Los apuntadores pueden apuntar a estructuras definidas por el programador.
EJEMPLO:
struct Persona {
char nombre[50];
int edad;
};
pág. 11
struct Persona persona;
struct Persona *pPersona = &persona;
Los apuntadores son variables que almacenan direcciones de memoria y tienen varios tipos,
dependiendo del tipo de dato al que apuntan y el uso que se les dé.
DECLARACIÓN DE APUNTADORES
Para declarar un apuntador, se especifica el tipo de dato al que apunta, seguido del operador * y
luego el nombre del apuntador. Por ejemplo:
● int *ptr1; // Apuntador a un entero (int).
● char *cad1, *cad2; // Dos apuntadores a caracteres (char).
● float *ptr2; // Apuntador a un número de punto flotante (float).
ASIGNACIÓN DE APUNTADORES
Los apuntadores pueden asignarse a direcciones de variables utilizando el operador & o a
direcciones almacenadas en otros apuntadores:
● int i = 5;
● int *p, *q;
● p = &i; // Asigna a p la dirección de i.
● q = p; // Asigna a q la dirección almacenada en p.
DESREFERENCIACIÓN DE APUNTADORES
La desreferenciación es la obtención del valor almacenado en la dirección de memoria a la que
apunta un apuntador. Se hace usando el operador * aplicado al apuntador:
● int x = 17;
● int *p;
● p = &x;
● cout << "El valor de x es: " << *p << endl; // Imprime 17.
● int y = *p + 3; // Asigna a y el valor de x más 3.
OPERADOR DE ACCESO A MIEMBROS ->
El operador -> se utiliza para acceder a los campos de una estructura a través de un apuntador a
dicha estructura. Por ejemplo:
pág. 12
● struct Data {
● char nombre[20];
● int edad;
● };
● Data d;
● Data *pd = &d;
● pd->edad = 23; // Acceso al campo edad de d usando ->.
VERIFICACIÓN DE TIPOS DE APUNTADORES
Los apuntadores se vinculan a tipos de datos específicos, por lo que solo se pueden asignar
direcciones de variables del tipo especificado:
● int *p1;
● float *p2;
● int x;
● p1 = &x; // Válido, ya que p1 es un apuntador a int.
● p2 = &x; // No válido, ya que p2 es un apuntador a float y x es int.
APUNTADORES NULOS
Un apuntador se considera nulo cuando su valor es NULL o 0, lo que significa que no apunta a
ninguna dirección válida de memoria. Esto puede servir como indicador de que el apuntador no está
asociado a ningún dato.
int *p = NULL; // Apuntador nulo.
if (p == NULL) {
// El apuntador no apunta a nada, se puede manejar de acuerdo a esta
condición.
Es importante tener en cuenta que desreferenciar un apuntador nulo o un apuntador que apunta a
una dirección de memoria inválida puede causar comportamientos inesperados o errores en el
programa. Siempre es importante verificar si un apuntador es nulo antes de intentar
desreferenciarlo.
APUNTADORES A APUNTADORES
Un apuntador puede apuntar a otro apuntador, y este puede apuntar a otro, creando una cadena de
apuntadores. Esto permite trabajar con niveles de indirecta, es decir, tener apuntadores a
apuntadores o más niveles de apuntadores. Los apuntadores se declaran con tantos asteriscos (*)
como niveles de indirecta se necesiten.
char c = 'z'; // Declaración de una variable char.
char *pc = &c; // Apuntador a char, apunta a la dirección de c.
char **ppc = &pc; // Apuntador a apuntador, apunta a la dirección de pc.
pág. 13
char ***pppc = &ppc; // Apuntador a apuntador a apuntador, apunta a la
dirección de ppc.
***pppc = 'm'; // Cambia el valor de c a 'm' a través de pppc.
***pppc desreferencia tres niveles de apuntadores para llegar al valor de c y cambiarlo a 'm'.
APUNTADORES CONSTANTES Y APUNTADORES A CONSTANTES
En C, es posible declarar apuntadores constantes y apuntadores a constantes.
1. Apuntadores Constantes: Un apuntador constante es un apuntador cuya dirección no se
puede cambiar después de su inicialización. Sin embargo, se puede modificar el valor al que
apunta.
int x = 5, y = 7;
int *const p = &x; // Apuntador constante.
*p = 3; // Válido, cambia el valor de x.
// p = &y; // Inválido, el compilador genera un error.
2. Un apuntador a constante es un apuntador que no puede modificar el valor al que apunta.
Sin embargo, se puede cambiar la dirección a la que apunta.
int x = 5, y = 7;
const int *p = &x; // Apuntador a constante.
p = &y; // Válido, cambia el apuntador a que apunte a y.
// *p = 3; // Inválido, el compilador genera un error.
APUNTADORES, ARREGLOS Y ARITMÉTICA DE APUNTADORES
Los arreglos y los apuntadores están estrechamente relacionados en C. El nombre de un arreglo
actúa como un apuntador constante al inicio del arreglo. Por lo tanto, puedes usar la aritmética de
apuntadores para navegar por un arreglo o manipular elementos de un arreglo a través de un
apuntador. Ejemplos:
int lista_arr[5] = {10, 20, 30, 40, 50};
int *lista_ptr = lista_arr; // Ambos apuntan al mismo sitio.
lista_ptr[0] es equivalente a lista_arr[0].
*lista_ptr es equivalente a *lista_arr.
pág. 14
Puedes sumar o restar valores enteros a un apuntador para desplazarte a través de los elementos
de un arreglo:
int lista[5] = {10, 20, 30, 40, 50};
int *p = &lista[3]; // Apuntador a la posición 3 del arreglo.
cout << *(lista + 2); // Imprime el valor en la posición 2 del arreglo.
ASIGNACIÓN DINÁMICA DE MEMORIA
Se puede asignar memoria dinámicamente utilizando las funciones malloc() y free(), que se definen
en stdlib.h. malloc() reserva memoria y devuelve su dirección (o NULL si no se pudo reservar
memoria). free() libera la memoria reservada por malloc().
#include <stdlib.h>
#include <string.h>
typedef struct {
char nombre[20];
int edad;
} Data;
Data *p_data = (Data*)malloc(sizeof(Data)); // Reserva memoria para un
registro.
if (p_data != NULL) {
strcpy(p_data->nombre, "Rachel");
p_data->edad = 21;
free(p_data); // Libera la memoria.
// Reserva memoria para un arreglo de 10 registros.
p_data = (Data*)malloc(sizeof(Data) * 10);
if (p_data != NULL) {
for (int i = 0; i < 10; i++) {
// Leer datos para cada elemento del arreglo.
pág. 15
free(p_data); // Libera la memoria del arreglo.
En C++, los operadores new y delete se usan para la asignación dinámica de memoria
Data *p_data = new Data; // Reserva memoria para un registro.
if (p_data != NULL) {
strcpy(p_data->nombre, "Rachel");
p_data->edad = 21;
delete p_data; // Libera la memoria.
// Reserva memoria para un arreglo de 10 registros.
p_data = new Data[10];
if (p_data != NULL) {
for (int i = 0; i < 10; i++) {
// Leer datos para cada elemento del arreglo.
delete[] p_data; // Libera la memoria del arreglo.
RELACIÓN DE APUNTADORES CON ARREGLOS
Los apuntadores y los arreglos en C están estrechamente relacionados, y su combinación es una
característica poderosa del lenguaje.
1. Nombre de arreglo como apuntador constante: En C, el nombre de un arreglo actúa como
un apuntador constante al primer elemento del arreglo. Esto significa que se puede utilizar
el nombre del arreglo para obtener la dirección del primer elemento.Referencia:
KERNIGHAN, B. W.; D.M. Ritchie, Lenguaje de Programación C, Prentice-Hall.
int arr[5] = {10, 20, 30, 40, 50};
int *ptr = arr; // ptr apunta al primer elemento de arr.
2. Aritmética de apuntadores: Los apuntadores pueden ser manipulados mediante operaciones
aritméticas como suma y resta. Al sumar o restar un número entero a un apuntador, se
desplaza por el arreglo, moviéndose de un elemento a otro. Cada operación se desplaza por
el tamaño de los elementos del tipo de dato al que apunta el arreglo.Referencia: CEBALLOS,
Francisco Javier, Enciclopedia del Lenguaje C, Computec-Rama, México, 1994.
pág. 16
int arr[5] = {10, 20, 30, 40, 50};
int *ptr = arr;
// Acceso a elementos usando aritmética de apuntadores
int segundo_elemento = *(ptr + 1); // Equivalente a arr[1]
int cuarto_elemento = *(ptr + 3); // Equivalente a arr[3]
3. Desreferenciación de apuntadores: Los apuntadores se pueden desreferenciar usando el
operador * para acceder o modificar el valor almacenado en la dirección de memoria a la
que apunta.Referencia: DEITEL, H.M.; Deitel, P.J. Cómo programar en C/C++, Prentice-Hall,
Hispanoamericana, México, 1995.
int arr[5] = {10, 20, 30, 40, 50};
int *ptr = arr;
// Desreferenciar el apuntador
*ptr = 15; // Cambia el valor del primer elemento de arr a 15
4. Comparación de apuntadores: Los apuntadores se pueden comparar para verificar si
apuntan a la misma dirección de memoria, o comparar un apuntador con NULL para
comprobar si no apunta a nada.Referencia: KERNIGHAN, B. W.; D.M. Ritchie, Lenguaje de
Programación C, Prentice-Hall.
int arr1[5], arr2[5];
int *ptr1 = arr1, *ptr2 = arr2;
if (ptr1 == ptr2) {
// Los dos apuntadores apuntan a la misma dirección de memoria.
int *ptr_null = NULL;
if (ptr_null == NULL) {
// ptr_null no apunta a nada.
5. Paso de arreglos a funciones: Cuando se pasa un arreglo como argumento a una función,
lo que realmente se pasa es un apuntador al primer elemento del arreglo. Esto permite que
la función acceda a los elementos del arreglo.Referencia: CEBALLOS, Francisco Javier,
Enciclopedia del Lenguaje C, Computec-Rama, México, 1994.
void imprimir_arreglo(int *ptr, int size) {
for (int i = 0; i < size; i++) {
pág. 17
printf("%d ", ptr[i]);
printf("\n");
int arr[5] = {10, 20, 30, 40, 50};
imprimir_arreglo(arr, 5); // Llama a la función con el arreglo y su
tamaño
Concluyendo esta unidad, hemos explorado en detalle los conceptos de arreglos y apuntadores en
C, así como su estrecha relación y cómo se pueden utilizar juntos para gestionar datos de forma
eficiente. A lo largo de la unidad, hemos visto ejemplos y discusiones sobre arreglos
unidimensionales y bidimensionales, tanto numéricos como de caracteres, y cómo estos arreglos
nos permiten manejar colecciones de datos homogéneos.
Hemos aprendido que los apuntadores son variables que almacenan direcciones de memoria, lo
que nos permite acceder y manipular datos almacenados en arreglos de manera flexible y eficiente.
La combinación de apuntadores y arreglos nos permite realizar operaciones avanzadas, cómo pasar
arreglos a funciones, modificar elementos dentro de arreglos, y gestionar la memoria de manera
dinámica.
A lo largo de este proceso, hemos trabajado con ejemplos prácticos que ilustran cómo utilizar
arreglos y apuntadores en C, y cómo aprovechar sus ventajas para escribir programas más
eficientes y funcionales. Esto ha sentado una base sólida para comprender conceptos de
programación más avanzados que explicaremos en futuras unidades.
pág. 18
BIBLIOGRAFÍAS
Curso intermedio de C. (2018, 21 octubre). Emilio Pérez. https://emiliopm.com/curso/intermedio-de-
c/
Flores, J. R. (2019, 30 noviembre). ¿Como funciona un compilador? Usuario Peru TI.
https://usuarioperu.com/2019/07/22/como-funciona-un-compilador/
Grune, D., Van Reeuwijk, K., Bal, H. E., Jacobs, C. J., & Langendoen, K. (2012). Modern Compiler
design. Springer Science & Business Media.
Kernighan, B. W., & Ritchie, D. M. (1988). The C programming language: 2nd Edition. Prentice Hall;
2 edition (April 1, 1988).
Pitts, D. (1998). Red hat Linux unleashed. Sams Publishing.
Tanenbaum, A. S. (2003). Sistemas operativos modernos. Pearson Educación.
Tucker, A. B. (1987). Lenguajes de programación.
pág. 19
