Токенизация строки и возврат ее в виде массива

Question

Я пытаюсь токенизировать переданную строку, сохранить токены в массиве и вернуть его. Я запускаю это на Ubuntu. Я в тупике, когда дело доходит до этого языка.

Пример ввода: coinflip 3

Мой код мыслительный процесс выглядит следующим образом:

take: string
if string = null: return null
else:
while temp != null
   token[i++] = temp
   temp = get next token
return

Вот мое текущее решение , Разделитель - это пробелы. C давно не был моей сильной стороной.

#include <stdio.h>
#include <string.h>
#include <stdlib.h>

//Clears the screen and prompts the user
void msg()
{
    static int init = 1;
    if(init)
    {
        printf("\e[1;1H\e[2J");
        init = 0;
    }
    printf("%s", "uab_sh > ");

}

//Reads in line
char *readIn(void)
{
    char param[101];
    fgets(param, 101, stdin);
    return param;
}

//parse string - still working out the kinks :)
char **parseString(char *cmd)
{
    char delim[] = " ";
    char* temp = strtok(cmd, delim);
    if (temp == " ")
    {
        return NULL;
    }
    else
    {
        int i = 0;
        char** tokens = malloc(3 * sizeof(char*));
        while (temp != NULL)
        {
            tokens[i++] = temp;
            temp = strtok(NULL, " ");
        }
        for (i = 0; i < 3; i++)
        {
            printf("%s\n", tokens[i]);
        }
        return tokens;
    }
}

//Command
int command(char ** cmd)
{
    int pid;
    if (cmd[0] != NULL)
    {
        pid = fork();
        if (pid == 0)
        {
            exit(0);
        }
        else if (pid < 0)
        {
            perror("Something went wrong...");
        }
    }
    else
        return 1;
}


int main()
{
    char *line;
    char **cmd;
    int stat = 0;
    while (1)
    {
        msg();
        line = readLine();
        cmd = parseString(line);
        stat = command(cmd);
        if (stat == 1)
        {
            break;
        }
    }
    return 0;
}

Текущие ошибки:

main.c: In function ‘readIn’:
main.c:24:9: warning: function returns address of local variable [-Wreturn-local-addr]
  return param;
         ^~~~~
main.c: In function ‘parseString’:
main.c:32:11: warning: comparison with string literal results in unspecified behavior [-Waddress]
  if (temp == " ")
           ^~
main.c: In function ‘command’:
main.c:59:9: warning: implicit declaration of function ‘fork’ [-Wimplicit-function-declaration]
   pid = fork();
         ^~~~
main.c: In function ‘main’:
main.c:82:10: warning: implicit declaration of function ‘readLine’; did you mean ‘readIn’? [-Wimplicit-function-declaration]
   line = readLine();
          ^~~~~~~~
          readIn
main.c:82:8: warning: assignment makes pointer from integer without a cast [-Wint-conversion]
   line = readLine();
        ^
main.c: In function ‘command’:
main.c:71:1: warning: control reaches end of non-void function [-Wreturn-type]
 }
 ^

Answer 1

Компилятор уже сообщил, что эта функция

//Read-in string
char *readIn(void)
{
    char param[101];
    fgets(param, 101, stdin);
    return param;
}

имеет неопределенное поведение, поскольку возвращает указатель на локальный массив param, который не будет активен после выхода из функции.

In в этой функции

char *parseString(char* cmd)
{
    char* temp = strtok(cmd, " ");
    if (cmd == NULL)
    {
        return temp;
    }
    else
    {
        int i = 0;
        char *tokens[3];
        while (temp != NULL)
        {
            tokens[i++] = temp;
            temp = strtok(NULL, " ");
        }
        for (i = 0; i < 3; i++)
        {
            printf("%s\n", tokens[i]);
        }
        return tokens;
    }
}

существует та же проблема (если не учитывать неправильную реализацию) и, кроме того, тип возвращаемого выражения

        return tokens;

не соответствует типу возвращаемого значения функции, потому что выражение в операторе возврата имеет тип char **, а тип возвращаемого значения функции - char *.

Я уверен, что наиболее трудным для вас является написание функции, которая разбивает строка в токены.

Это может выглядеть следующим образом, как показано в демонстрационной программе ниже. Функция динамически распределяет память для массива указателей на токены. Если распределение завершается неудачно, функция возвращает NULL. В противном случае функция возвращает указатель на первый элемент динамически размещенного массива указателей. Последний элемент массива содержит NULL. Этот элемент можно использовать для определения количества фактических указателей на токены в массиве.

Вот и вы.

#include <stdio.h>
#include <string.h>
#include <stdlib.h>

char ** parseString( char *cmd )
{
    char **tokens = malloc( sizeof( char * ) );
    *tokens = NULL;
    size_t n = 1;

    const char *delim = " \t";

    char *p = strtok( cmd, delim );

    int success = p != NULL;

    while ( success )
    {
        char **tmp = realloc( tokens, ( n + 1 ) * sizeof( char * ) );

        if ( tmp == NULL )
        {
            free( tokens );
            tokens = NULL;

            success = 0;
        }
        else
        {
            tokens = tmp;

            tokens[n - 1] = p;
            tokens[n] = NULL;
            ++n;

            p = strtok( NULL, delim );

            success = p != NULL;
        }
    }

    return tokens;
}

int main(void) 
{
    char cmd[] = "Many various and unique commands";

    char **tokens = parseString( cmd );

    if ( tokens != NULL )
    {
        for ( char **p = tokens; *p != NULL; ++p )
        {
            puts( *p );
        }
    }

    free( tokens );

    return 0;
}

Вывод программы:

Many
various
and
unique
commands

Answer 2

Вот небольшое рекурсивное решение. Эта идиома использует стек вызовов в качестве временного пространства, чтобы распределять массив токенов только один раз. Поскольку это требует очень мало бухгалтерии, код радикально упрощен. Не все найдут это привлекательным.

#include <stdlib.h>
#include <string.h>
static char** helper(char* token, int argc) {
  char** retval = token ? parseString(strtok(NULL, " "), argc + 1)
                        : malloc((argc + 1) * sizeof *retval);
  if (retval) retval[argc] = token;
  return retval;
}

char** parseString(char* cmd) {
  return helper(strtok(cmd, " "), 0);
}

Конечно, рекурсивная реализация означает, что строка с действительно большим количеством токенов может переполнить стек. На практике я не беспокоюсь об этом, потому что стековый фрейм для helper довольно мал и нет VLA, alloca s или даже неинициализированных локальных объектов. Таким образом, переполнение стека (1) потребует действительно много токенов, и (2) надежно попадет на защитную страницу, если она есть, и завершит процесс. Если вы используете ОС без защиты стека, вы можете поставить проверку глубины рекурсии в функции, поскольку второй аргумент отслеживает глубину.

Answer 3

Ну, исключая тот факт, что этот код не способен обрабатывать не более 3 токенов, у него есть еще одна базовая c проблема: Он вернет недопустимый указатель на память . temp и tokens - это переменные, которые находятся внутри фрейма стека функции parseString(). Поэтому, когда его выполнение завершится, эти переменные исчезнут. Идеальным решением здесь является выделение tokens в куче.

Вот мое решение:

char** parseString(char* cmd)
{
    char delimiters[] = " ";
    char* temp = strtok(cmd, delimiters);
    //If temp is NULL then the string contains no tokens
    if (temp == NULL)
    {
        return NULL;
    }
    else
    {
        int i = 0;
        char** tokens = malloc(3*sizeof(char*));
        while (temp != NULL)
        {
            tokens[i++] = temp;
            temp = strtok(NULL, " ");
        }
        for (i = 0; i < 3; i++)
        {
            printf("%s\n", tokens[i]);
        }
        return tokens;
    }
}