Tengo una estructura con letras dentro y quiero dar las letras a una matriz para poder usarla después. Funciona si solo imprimiera las letras.

Arriba (estructura):

 #include "stdafx.h"

typedef struct { char* code; char* letter;}morse_tabelle; 

morse_tabelle tabelle[] = {
    { ".-", "A" },
    { "-...", "B" },
    { " -.-. ", "C" },
    { "-..", "D" },
    { ".", "E" },
    { "..-.", "F" },
    { "--.", "G" },
    { "....", "H" },
    { "..", "I" },
    { ".---", "J" },
    { "-.-", "K" },
    { ".-..", "L" },
    { "--", "M" },
    { "-.", "N" },
    { "---", "O" },
    { ".--.", "P" },
    { "--.-", "Q" },
    { ".-.", "R" },
    { "...", "S" },
    { "-", "T" },
    { "..-", "U" },
    { "...-", "V" },
    { ".--", "W" },
    { "-..-", "X" },
    { "-.--", "Y" },
    { "--..", "Z" },
    { "-----", "0" },
    { ".----", "1" },
    { "..---", "2" },
    { "...--", "3" },
    { "....-", "4" },
    { ".....", "5" },
    { "-....", "6" },
    { "--...", "7" },
    { "---..", "8" },
    {"----.", "9" },
    { "/", " " },
    };

Para el tamaño de matriz:

#define ARR_SIZE(x) (sizeof(x)/sizeof((x)[0]))

Función:

    void morse_to_text(void)
    {


    char input[100];
    char* morse_letter;

    int j = 0;
    char* translation[50];


    printf_s("\n\nput in Morsecode:\n\n");
    fgets(input, 100, stdin);                                             
    input[strlen(input)-1] = '\0';                                       

    morse_letter = strtok(input, " ");                               

    while (morse_letter)                                                      
    {
        for (int i = 0; i < ARR_SIZE(tabelle); i++)                            
        {

            if (!strcmp(morse_letter, tabelle[i].code))                  
            {
                translation[j] = tabelle[i].letter;                    
                j++;
                /*printf_s("%s", tabelle[i].letter);*/   //This works              
            }
        }
        morse_letter = strtok(NULL, " ");                            
    }

    /*output*/
    printf_s("\n\n---------------\n\n");
    for (int i = 0; i <= strlen(translation[50]); i++){
            printf("%s", translation[i]);
    }

};

De alguna manera funciona si cambio el char* letter a char letter dentro de la estructura. pero luego obtengo un desbordamiento de búfer. La pregunta nuevamente: ¿cómo puedo almacenar cadenas dentro de una matriz?

0
L. Hiernickel 3 may. 2017 a las 11:33

3 respuestas

La mejor respuesta

Lo que realmente quieres es esto:

char translation[50]; // no string array, char array!

Luego tenga la carta tan char como usted pretendía:

typedef struct { char* code; char letter;} morse_tabelle;

Con eso, ahora puedes simplemente hacer

translation[j] = tabelle[i].letter;

De nuevo, como antes. Solo cambió el tipo de datos ...

Sin embargo, debe terminar con nulo su cadena traducida, de lo contrario no puede usarla con printf("%s", translation)

while(...) { ... }
translation[j] = 0;

// output:
// no for loop any more!

printf("%s", translation);

Una alternativa para terminar el carácter nulo sería dar la longitud al parámetro de formato printf:

while(...) { ... }
// no termination any more...

// output:
// no for loop any more!

printf("%.*s", j, translation);

Consulte printf para obtener detalles (OK, el enlace en realidad es C ++, pero la documentación es exactamente cierta para C también ...).

3
Aconcagua 3 may. 2017 a las 08:59

En lugar de:

translation[j] = tabelle[i].letter;

Hacer:

translation[j] = tabelle[i].letter[0];

O en su lugar, y aún mejor, hacer:

typedef struct { char* code; char letter;} morse_tabelle; 

morse_tabelle tabelle[] = {
    { ".-", 'A' },
    { "-...", 'B' },
    { " -.-. ", 'C' },
    { "-..", 'D' },
    etc. etc.

char translation[50];
...
printf("%s\n", translation);

O, si desea imprimir la traducción letra por letra:

for (int i = 0; i < strlen(translation); i++)
{
    printf("%c\n", translation[i]);
}

Para agregar algunas clases básicas de C:

char * es un puntero a una matriz de tipos char. "A" es una matriz char con dos elementos y se puede escribir como { 'A', '\0' }. Por lo tanto, asignar "A" a un tipo char es incorrecto.

Si define letter como char * y llena los datos con una cadena de un carácter, puede acceder al carácter indexando el elemento 0 como letter[0]. Sin embargo, en lugar de usar matrices de caracteres en todo el espacio y desperdiciar memoria y complicar demasiado su código, es mejor usar caracteres en su lugar.

1
AlastairG 4 may. 2017 a las 13:25

Aquí:

for (int i = 0; i <= strlen(translation[50]); i++) {

strlen(translation[50] está mal. translation es una matriz de 50 punteros a char*. Entonces, strlen(translation[50]) es la longitud del 50º carácter traducido (que por cierto solo existe si ha escrito 50 códigos morse) y no la cantidad de elementos que ha puesto en la matriz translation. Ha puesto punteros j char* en la matriz translation, por lo tanto, el código correcto es:

for (int i = 0; i < j); i++) {
0
Jabberwocky 3 may. 2017 a las 08:59