Arreglo
En C, un arreglo (o array) es una estructura de datos que permite almacenar una colección de elementos del mismo tipo en posiciones consecutivas de memoria. Esto facilita el manejo de grandes cantidades de datos relacionados, como listas de números, cadenas de caracteres, etc.
1. Declaración de Arreglos
Para declarar un arreglo en C, se especifica el tipo de dato de los elementos, el nombre del arreglo y el tamaño entre corchetes (`[]`), indicando cuántos elementos contendrá.
```c
tipo nombre_arreglo[tamaño];
```
Ejemplo:
``c
int numeros[5]; // Declara un arreglo de 5 enteros
```
Este ejemplo crea un arreglo llamado `numeros` que puede almacenar 5 enteros.
2. Inicialización de Arreglos
Los arreglos pueden inicializarse en el momento de su declaración. Esto se puede hacer especificando los elementos entre llaves `{}`.
Ejemplo:
``c
int numeros[5] = {1, 2, 3, 4, 5}; // Inicializa el arreglo con valores específicos
``
También es posible inicializar un arreglo sin especificar el tamaño explícitamente, en cuyo caso el compilador calcula el tamaño automáticamente en función de los elementos proporcionados.
Ejemplo:
```c
int numeros[] = {1, 2, 3, 4, 5}; // El compilador deduce que el tamaño es 5
```
3. Acceso a los Elementos de un Arreglo
Cada elemento en un arreglo tiene un índice que comienza desde 0 (el primer elemento está en la posición 0). Se accede a los elementos utilizando el nombre del arreglo seguido del índice entre corchetes.
Ejemplo:
```c
int numeros[5] = {1, 2, 3, 4, 5};
printf("%d", numeros[0]); // Imprime el primer elemento: 1
printf("%d", numeros[2]); // Imprime el tercer elemento: 3
```
Es importante recordar que el acceso a un índice fuera del rango del arreglo (por ejemplo, `numeros[5]` en este caso) puede producir un error o resultados inesperados.
4. Recorrer un Arreglo con Bucles
Es común utilizar un bucle `for` para recorrer todos los elementos de un arreglo.
Ejemplo:
```c
int numeros[5] = {1, 2, 3, 4, 5};
for (int i = 0; i < 5; i++) {
printf("%d ", numeros[i]);
}
```
Este código imprime cada número en el arreglo `numeros`, mostrando: `1 2 3 4 5`.
5. Arreglos Multidimensionales
C también permite crear arreglos de múltiples dimensiones, como matrices (arreglos bidimensionales) o arreglos tridimensionales. Estos se declaran especificando más de un conjunto de corchetes.
Ejemplo de un arreglo bidimensional (matriz):
```c
int matriz[3][3] = {
{1, 2, 3},
{4, 5, 6},
{7, 8, 9}
};
```
Aquí `matriz` es un arreglo 3x3. Se accede a cada elemento proporcionando los índices de fila y columna.
Acceso a elementos:
```c
printf("%d", matriz[0][1]); // Imprime 2, el elemento en la primera fila y segunda columna
```
6. Arreglos y Punteros
En C, el nombre de un arreglo se refiere a la dirección de memoria del primer elemento, por lo que puede usarse como un puntero. Esto permite manipular los elementos de un arreglo utilizando punteros.
Ejemplo:
```c
int numeros[5] = {1, 2, 3, 4, 5};
int *ptr = numeros; // ptr apunta al primer elemento del arreglo
printf("%d", *(ptr + 1)); // Accede al segundo elemento: 2
```
7. Arreglos de Cadenas (Arreglos de `char`)
Los arreglos de tipo `char` se usan comúnmente para almacenar cadenas de caracteres.
Ejemplo:
```c
char saludo[] = "Hola";
printf("%s", saludo); // Imprime "Hola"
``
La cadena `"Hola"` incluye un carácter `'\0'` al final, que indica el fin de la cadena.
Resumen
- Declaración: `tipo nombre[tamaño];`
- Acceso a elementos: `nombre[indice];`
- Recorrido: Usar bucles como `for` o `while`.
- Arreglos multidimensionales: Permiten trabajar con matrices y arreglos de mayor dimensión.
- Arreglos de `char`: Útiles para almacenar y manipular cadenas de texto.
Los arreglos son una de las estructuras de datos más importantes y usadas en C, permitiendo almacenar y organizar datos de manera eficiente.
1.Arreglo Unidimensional
#include <stdio.h>
int main() {
int arreglo[5] = {1, 2, 3, 4, 5}; // Declaración e inicialización del arreglo
// Imprimir los elementos del arreglo
for (int i = 0; i < 5; i++) {
printf("Elemento en índice %d: %d\n", i, arreglo[i]);
}
return 0;
}
2.Arreglo Bidimensional
#include <stdio.h>
int main() {
int matriz[3][3] = { // Declaración e inicialización del arreglo
{1, 2, 3},
{4, 5, 6},
{7, 8, 9}
};
// Imprimir los elementos del arreglo bidimensional
for (int i = 0; i < 3; i++) {
for (int j = 0; j < 3; j++) {
printf("Elemento en posición [%d][%d]: %d\n", i, j, matriz[i][j]);
}
}
return 0;
}
3. Arreglo Tridimensional
#include <stdio.h>
int main() {
int arreglo3D[2][2][2] = { // Declaración e inicialización del arreglo
{
{1, 2},
{3, 4}
},
{
{5, 6},
{7, 8}
}
};
// Imprimir los elementos del arreglo tridimensional
for (int i = 0; i < 2; i++) {
for (int j = 0; j < 2; j++) {
for (int k = 0; k < 2; k++) {
printf("Elemento en posición [%d][%d][%d]: %d\n", i, j, k, arreglo3D[i][j][k]);
}
}
}
return 0;
}