es.davy.ai

Preguntas y respuestas de programación confiables

¿Tienes una pregunta?

Si tienes alguna pregunta, puedes hacerla a continuación o ingresar lo que estás buscando.

C – Dos tipos de entrada de usuario formateada con un número desconocido de entradas.

11 Jul, 2023 Programación

Quiero que el usuario pueda ingresar dos tipos de entrada: “C[tamaño_t]” y “O[dirección de memoria]”, y dependiendo de si es una C o una O al principio, llamaré a diferentes funciones. También quiero poder recibir un número desconocido de estas entradas y en cualquier orden.

Mi forma de solucionarlo fue algo así:

int main()
{
    // variables

    while (1) { // Bucle infinito para recibir múltiples entradas de cantidad desconocida?
        while (fgets(input, BUFFER_SIZE, stdin)) {
            if (sscanf(input, "%c%zu", &branch, &num) == 2) {
                if (strcmp(branch, "C")
                    // llamada a la función
            } else if (sscanf(input, "%c%c", &branch, (char *)addr) == 2) {
                if (strcmp(branch, "O")
                    // llamada a la función
            }
        }
    }

    return 0;
}

Entiendo por qué no está funcionando, por supuesto, y sé que mi “no solución” está mal, pero no tengo idea de cómo abordarlo de otra manera. El código recibe la primera entrada y se bloquea y si comienzo con una entrada que comienza con O, entrará en la primera declaración “if” cuando no debería. Tampoco estoy seguro si mi bucle “while(1)” es la forma correcta de manejar las múltiples entradas del usuario.

Tags:  , ,

Answer

  1. Avatar for davy.ai
    davy.ai

    Para manejar las entradas del usuario para “C[tamaño_t]” y “O[dirección de memoria]”, se pueden usar expresiones regulares para buscar un patrón de entrada. Aquí hay un ejemplo de implementación:

    #include <stdio.h>
#include <regex.h>

#define MAX_INPUTS 10      // número máximo de entradas
#define BUFFER_SIZE 256    // tamaño del buffer para la cadena de entrada

int main() {
    char input[BUFFER_SIZE];
    int num_inputs = 0;
    char *patterns[] = {"^C(\\d+)$", "^O(0[xX][0-9a-fA-F]+)$"};  // expresiones regulares para buscar patrones de entrada
    regex_t regex;      // compilar expresión regular
    regmatch_t matches[2];   // array para almacenar coincidencias

    // compilar expresiones regulares
    if (regcomp(&regex, patterns[0], REG_EXTENDED) != 0) {
        printf("Error al compilar la expresión regular: %s\n", patterns[0]);
        return -1;
    }
    if (regcomp(&regex, patterns[1], REG_EXTENDED) != 0) {
        printf("Error al compilar la expresión regular: %s\n", patterns[1]);
        return -1;
    }

    // bucle para leer la entrada
    while (1) {
        printf("Introduzca la entrada (C[tamaño_t] u O[dirección_memoria]): \n");
        fgets(input, BUFFER_SIZE, stdin);

        // comprobar si la entrada coincide con el patrón
        for (int i = 0; i < 2; i++) {
            if (regexec(&regex, input, 2, matches, 0) == 0) {
                // la entrada coincide con el patrón
                char branch = input[0];
                char *substring = input + matches[1].rm_so;
                unsigned long num = strtoul(substring, NULL, 0);  // convertir cadena a unsigned long

                // llamar a la función según la entrada
                if (branch == 'C') {
                    // llamar a la función para la entrada "C"
                    printf("Entrada C: %lu\n", num);
                } else if (branch == 'O') {
                    // llamar a la función para la entrada "O"
                    printf("Entrada O: %lu\n", num);
                }

                if (++num_inputs >= MAX_INPUTS) {
                    printf("Se alcanzó el número máximo de entradas\n");
                    return 0;
                }
                break;
            }
        }
    }
    return 0;
}

    Esta implementación utiliza fgets() para leer la entrada del usuario y regexec() para buscar el patrón de entrada utilizando expresiones regulares. Las expresiones regulares "^C(\\d+)$" y "^O(0[xX][0-9a-fA-F]+)$" buscan entradas que comiencen con “C” u “O”, seguido de un número decimal o una dirección hexadecimal de memoria, respectivamente.

    El programa lee la entrada en un bucle infinito hasta que se alcance el número máximo de entradas. La función strtoul() se utiliza para convertir la cadena de entrada a un entero largo sin signo.

    Tenga en cuenta que es necesario incluir el archivo de encabezado regex.h y enlazar con la biblioteca libregex utilizando la opción -lregex al compilar el programa.</regex.h></stdio.h>

Comments are closed.