Manipular Arreglos y Cadenas en C++

Introducción

En este laboratorio, aprenderás cómo manipular matrices (arrays) y cadenas (strings) en C++. El laboratorio cubre una variedad de temas, incluyendo la creación e inicialización de matrices unidimensionales, el acceso y modificación de elementos de la matriz, la implementación de matrices bidimensionales, el trabajo con cadenas de estilo C y la clase String, la ordenación de elementos de la matriz, la realización de búsquedas lineales y el manejo de la entrada de cadenas con getline(). A través de estos ejercicios prácticos, desarrollarás una sólida comprensión de las operaciones fundamentales de matrices y cadenas en la programación en C++.

Crear e Inicializar Arreglos Unidimensionales

En este paso, aprenderás cómo crear e inicializar matrices unidimensionales en C++. Las matrices (arrays) son estructuras de datos fundamentales que te permiten almacenar múltiples elementos del mismo tipo en una ubicación de memoria contigua.

Abre el WebIDE y crea un nuevo archivo llamado arrays_intro.cpp en el directorio ~/project. Exploraremos diferentes formas de inicializar matrices.

touch ~/project/arrays_intro.cpp

Agrega el siguiente código al archivo arrays_intro.cpp:

#include <iostream>

int main() {
    // Método 1: Declarar e inicializar una matriz con un tamaño específico
    int numbers[5] = {10, 20, 30, 40, 50};

    // Método 2: Dejar que el compilador determine el tamaño de la matriz
    int scores[] = {85, 92, 78, 95, 88};

    // Método 3: Inicializar la matriz con el valor predeterminado cero
    int zeros[6] = {0};

    // Método 4: Crear una matriz e inicializarla más tarde
    int temperatures[4];
    temperatures[0] = 72;
    temperatures[1] = 68;
    temperatures[2] = 75;
    temperatures[3] = 80;

    // Imprimir los elementos de la matriz
    std::cout << "Primer método - matriz numbers:" << std::endl;
    for (int i = 0; i < 5; i++) {
        std::cout << "Elemento " << i << ": " << numbers[i] << std::endl;
    }

    return 0;
}

Analicemos la inicialización de matrices:

1. int numbers[5] = {10, 20, 30, 40, 50};: Definir explícitamente el tamaño de la matriz e inicializar todos los elementos
2. int scores[] = {85, 92, 78, 95, 88};: Dejar que el compilador determine el tamaño de la matriz
3. int zeros[6] = {0};: Inicializar todos los elementos a cero
4. Asignar valores manualmente utilizando el índice temperatures[index] = value

Compila y ejecuta el programa:

g++ arrays_intro.cpp -o arrays_intro
./arrays_intro

Ejemplo de salida:

Primer método - matriz numbers:
Elemento 0: 10
Elemento 1: 20
Elemento 2: 30
Elemento 3: 40
Elemento 4: 50

Puntos clave sobre las matrices:

• Las matrices tienen un tamaño fijo una vez declaradas
• La indexación de matrices comienza en 0
• Puedes inicializar matrices de múltiples maneras
• Asegúrate siempre de no exceder los límites de la matriz

Acceder y Modificar Elementos de un Arreglo Usando Índices

En este paso, aprenderás cómo acceder y modificar elementos de una matriz (array) utilizando su índice en C++. A partir del paso anterior de inicialización de matrices, exploraremos cómo interactuar con elementos individuales de la matriz.

Abre el WebIDE y crea un nuevo archivo llamado array_indexing.cpp en el directorio ~/project:

touch ~/project/array_indexing.cpp

Agrega el siguiente código al archivo array_indexing.cpp:

#include <iostream>

int main() {
    // Crear una matriz de calificaciones de estudiantes
    int scores[5] = {85, 92, 78, 95, 88};

    // Accediendo a elementos de la matriz por índice
    std::cout << "Calificación del primer estudiante: " << scores[0] << std::endl;
    std::cout << "Calificación del tercer estudiante: " << scores[2] << std::endl;

    // Modificando elementos de la matriz
    std::cout << "Calificación original del segundo estudiante: " << scores[1] << std::endl;
    scores[1] = 96; // Actualizar la calificación del segundo estudiante
    std::cout << "Calificación actualizada del segundo estudiante: " << scores[1] << std::endl;

    // Calculando la suma de los elementos de la matriz
    int total_score = 0;
    for (int i = 0; i < 5; i++) {
        total_score += scores[i];
    }
    std::cout << "Calificación total de la clase: " << total_score << std::endl;

    // Cálculo de la calificación promedio
    double average_score = static_cast<double>(total_score) / 5;
    std::cout << "Calificación promedio de la clase: " << average_score << std::endl;

    return 0;
}

Puntos clave sobre la indexación de matrices:

• Los índices de las matrices comienzan en 0
• Utiliza corchetes cuadrados [] para acceder a los elementos
• Puedes leer y modificar elementos utilizando su índice
• Ten cuidado de no acceder a índices fuera de los límites de la matriz

Compila y ejecuta el programa:

g++ array_indexing.cpp -o array_indexing
./array_indexing

Ejemplo de salida:

Calificación del primer estudiante: 85
Calificación del tercer estudiante: 78
Calificación original del segundo estudiante: 92
Calificación actualizada del segundo estudiante: 96
Calificación total de la clase: 442
Calificación promedio de la clase: 88.4

Reglas importantes de indexación:

• El primer elemento está en el índice 0
• El último elemento está en el índice (tamaño de la matriz - 1)
• Acceder a un índice fuera del rango de la matriz causa un comportamiento indefinido

Implementar Arreglos Bidimensionales para Matrices

En este paso, aprenderás cómo crear y trabajar con matrices bidimensionales en C++. Las matrices bidimensionales son como tablas o matrices con filas y columnas, lo que te permite almacenar y manipular datos en una estructura similar a una cuadrícula.

Abre el WebIDE y crea un nuevo archivo llamado matrix_arrays.cpp en el directorio ~/project:

touch ~/project/matrix_arrays.cpp

Agrega el siguiente código al archivo matrix_arrays.cpp:

#include <iostream>

int main() {
    // Método 1: Declarar e inicializar una matriz 3x3
    int matrix[3][3] = {
        {1, 2, 3},
        {4, 5, 6},
        {7, 8, 9}
    };

    // Método 2: Declarar la matriz e inicializarla más tarde
    int grades[2][4];
    grades[0][0] = 85;
    grades[0][1] = 92;
    grades[0][2] = 78;
    grades[0][3] = 95;
    grades[1][0] = 88;
    grades[1][1] = 90;
    grades[1][2] = 82;
    grades[1][3] = 87;

    // Imprimir la primera matriz
    std::cout << "Primera Matriz:" << std::endl;
    for (int row = 0; row < 3; row++) {
        for (int col = 0; col < 3; col++) {
            std::cout << matrix[row][col] << " ";
        }
        std::cout << std::endl;
    }

    // Imprimir la matriz de calificaciones
    std::cout << "\nMatriz de Calificaciones:" << std::endl;
    for (int row = 0; row < 2; row++) {
        for (int col = 0; col < 4; col++) {
            std::cout << grades[row][col] << " ";
        }
        std::cout << std::endl;
    }

    return 0;
}

Puntos clave sobre las matrices bidimensionales:

• Utiliza dos índices para acceder a los elementos: array[row][column]
• El primer índice representa la fila, el segundo índice representa la columna
• Pueden ser inicializadas de múltiples maneras
• Típicamente se utilizan bucles anidados para iterar a través de las filas y columnas

Compila y ejecuta el programa:

g++ matrix_arrays.cpp -o matrix_arrays
./matrix_arrays

Ejemplo de salida:

Primera Matriz:
1 2 3
4 5 6
7 8 9

Matriz de Calificaciones:
85 92 78 95
88 90 82 87

Conceptos importantes de las matrices bidimensionales:

• Las matrices pueden tener más de dos dimensiones
• Cada fila puede tener un número diferente de columnas
• Siempre ten cuidado con los límites de la matriz para evitar errores

Inicializar Cadenas de Estilo C con Terminador Nulo

En este paso, aprenderás sobre las cadenas de estilo C y la importancia del terminador nulo en C++. Las cadenas de estilo C son matrices de caracteres que terminan con un carácter especial '\0' para marcar el final de la cadena.

Abre el WebIDE y crea un nuevo archivo llamado c_style_strings.cpp en el directorio ~/project:

touch ~/project/c_style_strings.cpp

Agrega el siguiente código al archivo c_style_strings.cpp:

#include <iostream>
#include <cstring>

int main() {
    // Método 1: Inicializar una cadena con un terminador nulo explícito
    char greeting[6] = {'H', 'e', 'l', 'l', 'o', '\0'};
    std::cout << "Saludo: " << greeting << std::endl;

    // Método 2: Inicializar como una cadena literal (agrega automáticamente el terminador nulo)
    char name[] = "John Doe";
    std::cout << "Nombre: " << name << std::endl;

    // Método 3: Declarar con un tamaño fijo e inicializar
    char message[20] = "Welcome to C++!";
    std::cout << "Mensaje: " << message << std::endl;

    // Demostrar la longitud de la cadena
    std::cout << "Longitud del nombre: " << strlen(name) << std::endl;

    // Cálculo manual de la longitud de la cadena
    int length = 0;
    while (name[length]!= '\0') {
        length++;
    }
    std::cout << "Longitud manual del nombre: " << length << std::endl;

    return 0;
}

Puntos clave sobre las cadenas de estilo C:

• El terminador nulo '\0' marca el final de la cadena
• Siempre reserva un carácter adicional para el terminador nulo
• Las cadenas literales agregan automáticamente el terminador nulo
• La función strlen() cuenta los caracteres antes del terminador nulo

Compila y ejecuta el programa:

g++ c_style_strings.cpp -o c_style_strings
./c_style_strings

Ejemplo de salida:

Saludo: Hello
Nombre: John Doe
Mensaje: Welcome to C++!
Longitud del nombre: 8
Longitud manual del nombre: 8

Conceptos importantes de inicialización de cadenas:

• El terminador nulo es crucial para las operaciones de cadenas
• Siempre asegúrate de tener suficiente espacio para el terminador nulo
• Ten cuidado con los tamaños de los buffers de cadenas para evitar desbordamientos

Utilizar Métodos de la Clase String (length, substr, find)

En este paso, aprenderás sobre los potentes métodos de la clase string en C++ que facilitan y hacen más intuitiva la manipulación de cadenas. Exploraremos métodos clave como length(), substr() y find().

Abre el WebIDE y crea un nuevo archivo llamado string_methods.cpp en el directorio ~/project:

touch ~/project/string_methods.cpp

Agrega el siguiente código al archivo string_methods.cpp:

#include <iostream>
#include <string>

int main() {
    // Crear una cadena
    std::string message = "Hello, C++ Programming!";

    // Usando el método length()
    std::cout << "Longitud de la cadena: " << message.length() << std::endl;

    // Usando el método substr()
    std::cout << "Primeros 5 caracteres: " << message.substr(0, 5) << std::endl;
    std::cout << "Subcadena a partir del índice 7: " << message.substr(7) << std::endl;

    // Usando el método find()
    std::string search_word = "Programming";
    size_t position = message.find(search_word);

    if (position!= std::string::npos) {
        std::cout << "'" << search_word << "' encontrado en el índice: " << position << std::endl;
    } else {
        std::cout << "Palabra no encontrada" << std::endl;
    }

    // Ejemplo adicional de find()
    std::string email = "user@example.com";
    size_t at_symbol = email.find('@');
    size_t dot_symbol = email.find('.');

    std::cout << "Nombre de usuario: " << email.substr(0, at_symbol) << std::endl;
    std::cout << "Dominio: " << email.substr(at_symbol + 1, dot_symbol - at_symbol - 1) << std::endl;

    return 0;
}

Puntos clave sobre los métodos de la clase string:

• length(): Devuelve el número de caracteres en la cadena
• substr(): Extrae una parte de la cadena
  • El primer argumento es el índice de inicio
  • El segundo argumento (opcional) es la longitud de la subcadena
• find(): Busca una subcadena o un carácter
  • Devuelve el índice de la primera aparición
  • Devuelve std::string::npos si no se encuentra

Compila y ejecuta el programa:

g++ string_methods.cpp -o string_methods
./string_methods

Ejemplo de salida:

Longitud de la cadena: 23
Primeros 5 caracteres: Hello
Subcadena a partir del índice 7: C++ Programming!
'Programming' encontrado en el índice: 11
Nombre de usuario: user
Dominio: example

Conceptos importantes de los métodos de cadena:

• Los métodos de cadena proporcionan una potente manipulación de texto
• La indexación comienza en 0
• Siempre verifica los valores de retorno para manejar posibles errores

Convertir entre Cadenas de Estilo C y la Clase String

En este paso, aprenderás cómo convertir entre cadenas de estilo C y la clase string de C++. Estas conversiones son esenciales cuando se trabaja con diferentes representaciones de cadenas en C++.

Abre el WebIDE y crea un nuevo archivo llamado string_conversion.cpp en el directorio ~/project:

touch ~/project/string_conversion.cpp

Agrega el siguiente código al archivo string_conversion.cpp:

#include <iostream>
#include <string>
#include <cstring>

int main() {
    // Convertir cadena de estilo C a cadena de C++
    const char* c_style_str = "Hello, C++ World!";
    std::string cpp_string(c_style_str);
    std::cout << "Cadena de C++: " << cpp_string << std::endl;

    // Convertir cadena de C++ a cadena de estilo C
    std::string message = "Converting strings";
    const char* c_str = message.c_str();
    std::cout << "Cadena de estilo C: " << c_str << std::endl;

    // Conversión manual usando strcpy
    char buffer[50];
    strcpy(buffer, message.c_str());
    std::cout << "Copiado al buffer: " << buffer << std::endl;

    // Comparación de la longitud de las cadenas
    std::cout << "Longitud de la cadena de C++: " << message.length() << std::endl;
    std::cout << "Longitud de la cadena de estilo C: " << strlen(c_str) << std::endl;

    return 0;
}

Métodos de conversión clave:

• std::string(c_style_str): Convertir una cadena de estilo C a una cadena de C++
• .c_str(): Convertir una cadena de C++ a una cadena de estilo C
• strcpy(): Copiar manualmente una cadena a una matriz de caracteres

Compila y ejecuta el programa:

g++ string_conversion.cpp -o string_conversion
./string_conversion

Ejemplo de salida:

Cadena de C++: Hello, C++ World!
Cadena de estilo C: Converting strings
Copiado al buffer: Converting strings
Longitud de la cadena de C++: 18
Longitud de la cadena de estilo C: 18

Conceptos importantes de conversión:

• Utiliza .c_str() para obtener un const char* a partir de una cadena de C++
• Ten cuidado con los tamaños de los buffers al realizar conversiones
• strlen() funciona con cadenas de estilo C
• .length() funciona con cadenas de C++

Ordenar Elementos de un Arreglo Utilizando el Algoritmo de Ordenamiento Burbuja

En este paso, aprenderás cómo implementar el algoritmo de Ordenamiento Burbuja (Bubble Sort) para ordenar los elementos de un arreglo en C++. El Ordenamiento Burbuja es un método de ordenamiento simple que recorre repetidamente la lista, compara elementos adyacentes y los intercambia si están en el orden incorrecto.

Abre el WebIDE y crea un nuevo archivo llamado bubble_sort.cpp en el directorio ~/project:

touch ~/project/bubble_sort.cpp

Agrega el siguiente código al archivo bubble_sort.cpp:

#include <iostream>

int main() {
    // Inicializar un arreglo desordenado
    int numbers[5] = {64, 34, 25, 12, 22};
    int size = 5;

    // Imprimir el arreglo original
    std::cout << "Arreglo Original: ";
    for (int i = 0; i < size; i++) {
        std::cout << numbers[i] << " ";
    }
    std::cout << std::endl;

    // Implementación del Ordenamiento Burbuja
    for (int i = 0; i < size - 1; i++) {
        for (int j = 0; j < size - i - 1; j++) {
            // Comparar elementos adyacentes
            if (numbers[j] > numbers[j + 1]) {
                // Intercambiar elementos
                int temp = numbers[j];
                numbers[j] = numbers[j + 1];
                numbers[j + 1] = temp;
            }
        }
    }

    // Imprimir el arreglo ordenado
    std::cout << "Arreglo Ordenado: ";
    for (int i = 0; i < size; i++) {
        std::cout << numbers[i] << " ";
    }
    std::cout << std::endl;

    return 0;
}

Conceptos clave del Ordenamiento Burbuja:

• Compara elementos adyacentes
• Intercambia elementos si están en el orden incorrecto
• Repite el recorrido del arreglo hasta que esté ordenado
• Complejidad temporal: O(n²)

Compila y ejecuta el programa:

g++ bubble_sort.cpp -o bubble_sort
./bubble_sort

Ejemplo de salida:

Arreglo Original: 64 34 25 12 22
Arreglo Ordenado: 12 22 25 34 64

Notas importantes sobre el ordenamiento:

• El Ordenamiento Burbuja es simple pero ineficiente para arreglos grandes
• Es bueno con fines educativos
• Existen algoritmos de ordenamiento más eficientes para aplicaciones del mundo real

Implementar la Búsqueda Lineal en Arreglos

En este paso, aprenderás cómo implementar un algoritmo de Búsqueda Lineal en C++. La Búsqueda Lineal es un método simple para encontrar un elemento en un arreglo verificando cada elemento secuencialmente hasta que se encuentra el objetivo o se alcanza el final del arreglo.

Abre el WebIDE y crea un nuevo archivo llamado linear_search.cpp en el directorio ~/project:

touch ~/project/linear_search.cpp

Agrega el siguiente código al archivo linear_search.cpp:

#include <iostream>

int linearSearch(int arr[], int size, int target) {
    // Iterar a través de cada elemento en el arreglo
    for (int i = 0; i < size; i++) {
        // Verificar si el elemento actual coincide con el objetivo
        if (arr[i] == target) {
            return i;  // Devolver el índice si se encuentra
        }
    }
    return -1;  // Devolver -1 si el objetivo no se encuentra
}

int main() {
    // Crear un arreglo de calificaciones de estudiantes
    int scores[] = {85, 92, 78, 95, 88, 76, 90};
    int size = sizeof(scores) / sizeof(scores[0]);

    // Calificación objetivo a buscar
    int targetScore = 78;

    // Realizar la búsqueda lineal
    int result = linearSearch(scores, size, targetScore);

    // Mostrar los resultados de la búsqueda
    if (result!= -1) {
        std::cout << "Calificación objetivo " << targetScore
                  << " encontrada en el índice " << result << std::endl;
    } else {
        std::cout << "Calificación objetivo " << targetScore
                  << " no encontrada en el arreglo" << std::endl;
    }

    // Intentar otra búsqueda
    int missingScore = 100;
    result = linearSearch(scores, size, missingScore);

    if (result!= -1) {
        std::cout << "Calificación " << missingScore
                  << " encontrada en el índice " << result << std::endl;
    } else {
        std::cout << "Calificación " << missingScore
                  << " no encontrada en el arreglo" << std::endl;
    }

    return 0;
}

Conceptos clave de la Búsqueda Lineal:

• Verifica cada elemento del arreglo secuencialmente
• Devuelve el índice del objetivo si se encuentra
• Devuelve -1 si el objetivo no está en el arreglo
• Complejidad temporal: O(n) - tiempo lineal
• Es simple y funciona para arreglos no ordenados

Compila y ejecuta el programa:

g++ linear_search.cpp -o linear_search
./linear_search

Ejemplo de salida:

Calificación objetivo 78 encontrada en el índice 2
Calificación 100 no encontrada en el arreglo

Notas importantes sobre la búsqueda:

• La Búsqueda Lineal es sencilla pero ineficiente para arreglos grandes
• Es adecuada para arreglos pequeños o colecciones no ordenadas
• Existen algoritmos de búsqueda más eficientes para arreglos ordenados

Manejar la Entrada de Cadenas con getline()

En este paso, aprenderás cómo utilizar getline() para leer líneas completas de texto de entrada en C++. A diferencia de cin >>, getline() puede leer cadenas con espacios y manejar escenarios de entrada más complejos.

Abre el WebIDE y crea un nuevo archivo llamado getline_input.cpp en el directorio ~/project:

touch ~/project/getline_input.cpp

Agrega el siguiente código al archivo getline_input.cpp:

#include <iostream>
#include <string>

int main() {
    // Declarar una cadena para almacenar la entrada
    std::string fullName;
    std::string address;

    // Solicitar la entrada del nombre completo
    std::cout << "Ingrese su nombre completo: ";
    std::getline(std::cin, fullName);

    // Solicitar la entrada de la dirección
    std::cout << "Ingrese su dirección completa: ";
    std::getline(std::cin, address);

    // Mostrar la entrada con información adicional
    std::cout << "\n--- Información del Usuario ---" << std::endl;
    std::cout << "Nombre: " << fullName << std::endl;
    std::cout << "Dirección: " << address << std::endl;

    // Demostrar la lectura de múltiples líneas
    std::string multiLineText;
    std::cout << "\nIngrese una descripción de varias líneas (presione Ctrl+D para terminar):" << std::endl;

    std::string line;
    while (std::getline(std::cin, line)) {
        multiLineText += line + "\n";
    }

    std::cout << "\nSu descripción:" << std::endl;
    std::cout << multiLineText;

    return 0;
}

Conceptos clave de getline():

• Lee una línea completa de texto, incluyendo espacios
• Sintaxis: std::getline(flujo_de_entrada, variable_de_cadena)
• Puede leer múltiples líneas de entrada
• Maneja entradas complejas con espacios
• Útil para leer nombres completos, direcciones, etc.

Compila el programa:

g++ getline_input.cpp -o getline_input
./getline_input

Ejemplo de interacción:

Ingrese su nombre completo: John Michael Smith
Ingrese su dirección completa: 123 Main Street, Anytown, USA

--- Información del Usuario ---
Nombre: John Michael Smith
Dirección: 123 Main Street, Anytown, USA

Ingrese una descripción de varias líneas (presione Ctrl+D para terminar):
This is a sample
multi-line description
with several lines of text.

Su descripción:
This is a sample
multi-line description
with several lines of text.

Notas importantes sobre el manejo de entrada:

• getline() lee hasta el carácter de nueva línea
• Útil para capturar entradas de texto completas
• Puede combinarse con otros métodos de entrada

Resumen

En este laboratorio, aprenderás cómo crear e inicializar arreglos unidimensionales en C++, acceder y modificar elementos de arreglos utilizando índices, implementar arreglos bidimensionales para matrices, inicializar cadenas de estilo C con un terminador nulo, utilizar métodos de la clase string, convertir entre cadenas de estilo C y la clase string, ordenar elementos de arreglos utilizando el algoritmo de ordenamiento burbuja (bubble sort), implementar la búsqueda lineal en arreglos y manejar la entrada de cadenas con getline().

Explorarás diferentes formas de inicializar arreglos, incluyendo especificar el tamaño e inicializar todos los elementos, dejar que el compilador determine el tamaño, inicializar todos los elementos a cero y asignar valores manualmente utilizando índices. También aprenderás cómo acceder y modificar elementos de arreglos utilizando índices y cómo manejar los límites de los arreglos para evitar errores. Además, trabajarás con arreglos bidimensionales, cadenas de estilo C y la clase string, aprendiendo cómo convertir entre ellos y realizar diversas operaciones.