top of page

SEMANA 3

LIBRERÍA <ctype.h>

La biblioteca <ctype.h> en el lenguaje de programación C proporciona funciones para realizar operaciones y pruebas de caracteres. Estas funciones son especialmente útiles cuando trabajas con caracteres individuales, como verificar si un carácter es una letra mayúscula, minúscula, un dígito, etc.

Aquí hay algunas funciones comunes proporcionadas por <ctype.h>:

  1. isalpha(int c):

    • Devuelve un valor diferente de cero si c es una letra (mayúscula o minúscula), y 0 si no lo es.

  2. isdigit(int c):

    • Devuelve un valor diferente de cero si c es un dígito numérico (0-9), y 0 si no lo es.

  3. isalnum(int c):

    • Devuelve un valor diferente de cero si c es un carácter alfanumérico (letra o dígito), y 0 si no lo es.

  4. islower(int c):

    • Devuelve un valor diferente de cero si c es una letra minúscula, y 0 si no lo es.

  5. isupper(int c):

    • Devuelve un valor diferente de cero si c es una letra mayúscula, y 0 si no lo es.

  6. tolower(int c):

    • Convierte c a minúscula si es una letra mayúscula; de lo contrario, devuelve c sin cambios.

  7. toupper(int c):

    • Convierte c a mayúscula si es una letra minúscula; de lo contrario, devuelve c sin cambios.

Estas funciones son útiles para realizar pruebas y manipulaciones de caracteres en programas en C. Por ejemplo, puedes usarlas para validar la entrada del usuario, realizar operaciones de conversión entre mayúsculas y minúsculas, y más. Recuerda incluir la directiva #include <ctype.h> al principio de tu programa para utilizar estas funciones.

EJEMPLO 1 

#include <iostream>
#include <cctype>

int main() {
    char caracter = 'A';

    // Verificar si el caracter es una letra mayuscula
    if (std::isupper(caracter)) {
        std::cout << "El caracter '" << caracter << "' es una letra mayuscula." << std::endl;
    } else {
        std::cout << "El caracter '" << caracter << "' no es una letra mayuscula." << std::endl;
    }

    // Convertir el caracter a minuscula
    char caracterMinuscula = std::tolower(caracter);
    std::cout << "Caracter en minuscula: " << caracterMinuscula << std::endl;

    // Verificar si el caracter es un digito
    caracter = '7';
    if (std::isdigit(caracter)) {
        std::cout << "El caracter '" << caracter << "' es un digito." << std::endl;
    } else {
        std::cout << "El caracter '" << caracter << "' no es un digito." << std::endl;
    }

    return 0;
}
 

image.png

LIBRERIA <DEQUE>

La biblioteca <deque> en C++ proporciona la implementación de la estructura de datos deque (cola doble). Un deque es similar a un vector, pero permite inserciones y eliminaciones eficientes tanto al principio como al final de la secuencia. La palabra "deque" significa "double-ended queue" (cola de doble extremo).

  • Se utiliza std::deque<int> para declarar un deque de enteros.

  • Se utilizan las funciones push_back() y push_front() para insertar elementos al final y al principio del deque, respectivamente.

  • Se utiliza un bucle for para recorrer e imprimir los elementos del deque.

  • Se utiliza pop_front() y pop_back() para eliminar el primer y último elemento del deque.

. La biblioteca <deque> ofrece muchas más funciones y características, como acceso aleatorio eficiente a elementos, inserción y eliminación en cualquier posición, y más.

CÓDIGO 

#include <iostream>
#include <deque>

int main() {
    // Declaracion de un deque de enteros
    std::deque<int> miDeque;

    // Inserta elementos al final del deque
    miDeque.push_back(1);
    miDeque.push_back(2);
    miDeque.push_back(3);

    // Inserta elementos al principio del deque
    miDeque.push_front(0);
    miDeque.push_front(-1);

    // Imprime los elementos del deque
    std::cout << "Elementos del deque: ";
    for (std::deque<int>::iterator it = miDeque.begin(); it != miDeque.end(); ++it) {
        std::cout << *it << " ";
    }
    std::cout << std::endl;

    // Acceso aleatorio al segundo elemento
    std::cout << "Segundo elemento: " << miDeque[1] << std::endl;

    // Insercion en una posicion especifica
    std::deque<int>::iterator insertPos = miDeque.begin();
    ++insertPos;
    miDeque.insert(insertPos, 99);

    // Imprime el deque despues de la insercion
    std::cout << "Elementos despues de insertar '99' en la posicion 2: ";
    for (std::deque<int>::iterator it = miDeque.begin(); it != miDeque.end(); ++it) {
        std::cout << *it << " ";
    }
    std::cout << std::endl;

    // Elimina el primer y ultimo elemento del deque
    miDeque.pop_front();
    miDeque.pop_back();

    // Imprime el deque despues de las eliminaciones
    std::cout << "Elementos despues de eliminar el primer y ultimo elemento: ";
    for (std::deque<int>::iterator it = miDeque.begin(); it != miDeque.end(); ++it) {
        std::cout << *it << " ";
    }
    std::cout << std::endl;

    return 0;
}
 

En este ejemplo, se utilizan iteradores para recorrer el deque y algunas de las funciones básicas disponibles en la librería <deque> en C++98. Ten en cuenta que C++98 no incluye características como bucles for basados en rango o inicializadores de lista, que son introducidos en versiones posteriores del lenguaje.

2024-01-11 (10).png

LIBRERIA <EXCEPTION>

​

Si te refieres a la biblioteca estándar de excepciones en C++, puedes utilizar la biblioteca <stdexcept> y otras bibliotecas relacionadas con excepciones. Aquí hay algunos ejemplos de clases de excepciones en C++:

  1. std::exception: Es la clase base para todas las excepciones estándar de C++. Puedes usar esta clase directamente o derivar de ella para crear tus propias clases de excepciones.

  2. std::runtime_error: Se utiliza para excepciones que reflejan errores que solo pueden ser detectados durante el tiempo de ejecución.

  3. std::logic_error: Se utiliza para excepciones que reflejan errores en el diseño o la lógica del programa.

  4. std::out_of_range: Se utiliza para excepciones relacionadas con índices fuera de rango en contenedores como std::vector o std::string.

Aquí tienes un ejemplo básico que muestra cómo lanzar y capturar excepciones usando la biblioteca de excepciones de C++:

EJEMPLO

#include <iostream>
#include <stdexcept>

// Función que realiza una división y puede lanzar una excepción si el divisor es cero
double dividir(double numerador, double denominador) {
    if (denominador == 0.0) {
        throw std::runtime_error("Error: Division por cero.");
    }
    return numerador / denominador;
}

int main() {
    try {
        double resultado = dividir(10.0, 2.0);
        std::cout << "Resultado de la division: " << resultado << std::endl;

        // Intentar una división por cero para provocar una excepción
        resultado = dividir(5.0, 0.0);
        std::cout << "Resultado de la segunda division: " << resultado << std::endl;  // Esta linea no se alcanzara
    } catch (const std::exception& e) {
        // Atrapar la excepción y mostrar un mensaje de error
        std::cerr << "Excepcion atrapada: " << e.what() << std::endl;
    }

    return 0;
}
 

image.png
bottom of page