Fundamentos y aplicaciones de cadenas y arrays en C: Gestión de memoria explicada a fondo

1. Introducción

2. Conceptos básicos de arreglos

¿Qué es un arreglo?

int numbers[5]; // Arreglo que almacena 5 valores enteros

Declaración e inicialización de arreglos

int numbers[5] = {1, 2, 3, 4, 5}; // Declaración e inicialización del arreglo

Configuración de memoria de los arreglos y métodos de acceso

printf("%d", numbers[0]); // Muestra el primer elemento del arreglo

3. Lo básico de las cadenas

¿Qué es una cadena?

char greeting[6] = {'H', 'e', 'l', 'l', 'o', '�'};

Declaración e inicialización de cadenas

char greeting[] = "Hello";

Diferencia entre literales de cadena y arreglos de caracteres

const char *greeting = "Hello"; // Literal de cadena

greeting[0] = 'h'; // Cambiar "Hello" a "hello"

4. Relación entre cadenas y arrays

Las cadenas son arrays de caracteres

char name[10] = "Alice";

{'A', 'l', 'i', 'c', 'e', '�', '�', '�', '�', '�'}

Métodos de declaración de cadenas y precauciones

char name[3] = "Alice"; // Causa de error

Asignación y manipulación de cadenas

name[0] = 'B'; // Alice -> Blice

strcpy(name, "Bob"); // Asignar "Bob" a name

Métodos de inicialización de cadenas y precauciones

char greeting[] = "Hello";

5. Funciones básicas para la manipulación de cadenas

Función de copia de cadenas strcpy

#include 

char source[] = "Hello";
char destination[10];

strcpy(destination, source); // copia source en destination

Función de concatenación de cadenas strcat

#include 

char greeting[20] = "Hello";
char name[] = " World";

strcat(greeting, name); // greeting se convierte en "Hello World"

Obtener la longitud de la cadena con strlen

#include 

char greeting[] = "Hello";
int length = strlen(greeting); // length es 5

Comparar cadenas con strcmp

#include 

char str1[] = "Hello";
char str2[] = "Hello";
char str3[] = "World";

int result1 = strcmp(str1, str2); // result1 es 0 (iguales)
int result2 = strcmp(str1, str3); // result2 es diferente de 0 (diferentes)

6. Arreglo de cadenas (arreglo bidimensional)

Lo básico de los arreglos bidimensionales

char names[3][10] = {
    "Alice",
    "Bob",
    "Carol"
};

Acceso a los arreglos bidimensionales

char first_char = names[0][0]; // Obtener el primer carácter de "Alice": 'A'

for (int i = 0; i < 3; i++) {
    printf("%s\n", names[i]);
}

Inicialización de arreglos bidimensionales y precauciones en la especificación de tamaño

char colors[3][10] = {"Red", "Green", "Blue"};

Ejemplo de operaciones con cadenas usando arreglos bidimensionales

#include 
#include 

int main() {
    char names[3][10] = {"Bob", "Alice", "Carol"};
    char temp[10];

    for (int i = 0; i < 2; i++) {
        for (int j = i + 1; j < 3; j++) { if (strcmp(names[i], names[j]) > 0) {
                strcpy(temp, names[i]);
                strcpy(names[i], names[j]);
                strcpy(names[j], temp);
            }
        }
    }

    for (int i = 0; i < 3; i++) {
        printf("%s\n", names[i]);
    }

    return 0;
}

7. Gestión de memoria y puntos de atención

¿Qué es un desbordamiento de búfer?

char buffer[10];
strcpy(buffer, "This is a very long string"); // Ejemplo de desbordamiento de búfer

Operaciones seguras con cadenas: Uso de strncpy

char buffer[10];
strncpy(buffer, "This is a very long string", sizeof(buffer) - 1);
buffer[sizeof(buffer) - 1] = '�'; // Agregar el carácter de terminación manualmente

Aprovechamiento de la asignación dinámica de memoria

#include 
#include 

char *str = (char *)malloc(20 * sizeof(char)); // Asignar 20 bytes de memoria
strcpy(str, "Asignación dinámica");

// Liberar la memoria con free después de usarla
free(str);

Precauciones para prevenir fugas de memoria

char *name = (char *)malloc(50 * sizeof(char));
strcpy(name, "John Doe");

// Liberar cuando ya no sea necesario
free(name);

8. Resumen

Comprensión básica de arrays y cadenas

Funciones básicas para la manipulación de cadenas

Gestión de múltiples cadenas usando arrays bidimensionales

Gestión de memoria y riesgos de desbordamiento de búfer

En conclusión