Вернуть массив строк из функции - PullRequest
Новая
       10

Вернуть массив строк из функции

1 голос
/ 30 мая 2011

Мне нужно вернуть char**, но когда я пытаюсь это сделать, компилятор говорит мне, что я хочу вернуть адрес локальной переменной.Как я могу это сделать?Я знаю, что я должен выделить место для этой переменной, но как?Вот мой код, но второй printf не появляется и функция ничего не возвращает: 

char** parse_cmd(const char* cmdline) {
char** arguments = (char**)malloc(100);
int i;
int j=0, k=0;
printf("%s\n", cmdline);

for(i=0; i<100; i++) {
    arguments[i] = malloc(100);
}

for(i = 0; i < strlen(cmdline); i ++) {
    if(cmdline[i] != ' ') {
        arguments[j][k] = cmdline[i];
        k++;
    } else {
        arguments[j][k] = '\0';
        j++;
        k = 0;
    }
}

printf("%s\n", arguments[1]);

return arguments;
}

Ответы [ 2 ]

4 голосов
/ 30 мая 2011

Вам нужно сделать несколько распределений.Сначала для char**, а затем для каждого из char*.Например, что-то вроде 

  char **args = (char**)malloc(100);
  int i;
  for (i=0; i<100; i++) 
    args[i] = malloc(100);

  // Rest of program

  return args;
2 голосов
/ 30 мая 2011

Вот код, который я собрал и протестировал. Он использует динамическое выделение памяти как для списка аргументов argv, так и для каждого аргумента при сборке. Функция release_cmd() освобождает выделенное пространство. Функция cleanup() является внутренней и освобождает выделенное пространство в случае сбоя перед возвратом нулевого двойного указателя. Это упрощает обработку ошибок. В функции prompt() и main() есть минимальный тестовый жгут. Я не работал под valgrind, но реализация MacOS X malloc() довольно часто выявляет проблемы, поэтому я в меру уверен, что нет грубого злоупотребления памятью - но может быть утечка. Я не проверял код cleanup() путем фальсификации ошибки выделения. 

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

void release_cmd(char **argv)
{
    for (size_t i = 0; argv[i] != 0; i++)
        free(argv[i]);
    free(argv);
}

static char **cleanup(size_t argc, char **argv)
{
    argv[argc] = 0;
    release_cmd(argv);
    return 0;
}

char **parse_cmd(const char* cmdline)
{
    size_t argc = 2;
    char **argv = malloc(argc * sizeof(char *));

    if (argv == 0)
        return 0;

    size_t j = 0;  // Index into argv
    size_t len = strlen(cmdline);

    for (size_t i = 0; i < len; i++)
    {
        while (isspace(cmdline[i]))
            i++;
        if (cmdline[i] == '\0')
            break;
        if (j > argc - 2)
        {
            size_t newc = (argc * 2);
            char **newv = realloc(argv, newc * sizeof(char *));
            if (newv == 0)
                return cleanup(argc, argv);
            argv = newv;
            argc = newc;
        }
        size_t argl = 2;    // Length of argument string
        argv[j] = malloc(argl);
        size_t k = 0;       // Index into argv[j]
        while (cmdline[i] != '\0' && !isspace(cmdline[i]))
        {
            if (k > argl - 2)
            {
                size_t newl = argl * 2;
                char  *news = realloc(argv[j], newl);
                if (news == 0)
                    return cleanup(argc, argv);
                argv[j] = news;
                argl    = newl;
            }
            argv[j][k++] = cmdline[i++];
        }
        argv[j][k] = '\0';
        argv[j] = realloc(argv[j], k+1);    // Shrink to fit!
        j++;
    }
    argv[j] = 0;
    argv = realloc(argv, (j+1)*sizeof(*argv));  // Shrink to fit!

    return argv;
}

static int prompt(const char *prompt, char *buffer, size_t bufsiz)
{
    printf("%s", prompt);
    return (fgets(buffer, bufsiz, stdin) != 0);
}

int main(void)
{
    char line[1024];

    while (prompt("cmd? ", line, sizeof(line)) != 0)
    {
        char **argv = parse_cmd(line);
        char **args = argv;
        while (*args)
            puts(*args++);
        release_cmd(argv);
    }
    putchar('\n');
    return 0;
}
...