如何将传递给函数的字符串数组传递给另一个函数？

Question

我是指针的新手，我已经可以看到它们是多么令人困惑。 我试图在几个线程和谷歌中查找这个，但他们并没有完全返回我正在寻找的东西，也许是因为我缺乏经验。

我正在传递一个字符串数组，我必须再次将它传递给另一个函数，但是我对如何执行此操作感到非常困惑，并且不知道要使用什么*或&或在哪里使用。

我的代码：

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

char    *ft_strcat(char *dest, char *src)
{
    unsigned int    c;
    unsigned int    count;

    count = 0;
    while (dest[count] != 0)
    {
        count++;
    }
    c = 0;
    while (src[c] != '\0')
    {
        dest[c + count] = src[c];
        c++;
    }
    dest[c + count] = 0;
    return (dest);
}

int size_str(char *str)
{
    int c;

    c = 0;
    while (str[c] != '\0')
    {
        c++;
    }
    return (c - 1);
}

int size_all(int size, char *strs[], char *sep)
{
    int i;
    int counter;

    i = 0;
    counter = 0;
    counter += size_str(sep) * (size - 1);
    while (i < size)
    {
        counter += size_str(strs[i]);
        i++;
    }
    return (counter);
}

char    *ft_strjoin(int size, char **strs, char *sep)
{
    int     i;
    char    *str;

    str = malloc(sizeof(char) * size_all(size, strs, sep));
    str = strs[0];
    i = 1;
    while (i < size)
    {
        str = ft_strcat(str, strs[i]);
    }
    return (str);
}

int main(void)
{
    char    *sep = "   ";
    char    a1[] = "Batata";
    char    a2[] = "frita";
    char    a3[] = "\'e";
    char    a4[] = "melhor";
    char    a5[] = "que";
    char    a6[] = "Banana";
    char    *strs[] = {a1, a2, a3, a4, a5, a6};
    char    *final = ft_strjoin(6, strs, sep);

    printf("%s", final);
}

我认为 size all 必须在函数声明上有一个额外的取消引用运算符，当我调用它时还有一个引用运算符，但这工作得很好。 我做错了什么还是我只是误解了指针的工作原理？ 不是每次通过的时候都要加一个*吗？

最后为什么while (src[c] != '\\0')不起作用？

Answer 1

我最近一直在研究这个有问题的字符串接头。 我注意到您忘记添加大小为 0 的 if 条件。此外，while 循环需要迭代，这意味着它将给您一个无限循环。

您可以找到以下对代码的一些调整：

int     i;
char    *str;
int     j;
int     k;

i = 0;
k = 0;
str = (char *)malloc(sizeof(char) * sizeall(size, strs, sep) + 1));
if (size == 0)
    return (0);
while (i < size)
{
    j = 0;
    while (strs[i][j])
        str[k++] = strs[i][j++];
    j = 0;
    if (i < size - 1)
        while (sep[j])
            str[k++] = sep[j++];
    i++;
}
str[k] = '\0';
return (str);

如果有什么不明白的地方，请随时问我，祝你好运。

Answer 2

在size_str ：

while (src[c] != '\\0')没有任何问题，但是return (c - 1); 导致您的字符串长度出现一对一错误。 循环中不计算 NUL 字节，无需减去1 。

在ft_strcat ：

第一个循环是重复可以通过调用size_str处理的工作。

在ft_strjoin ：

str = malloc(sizeof(char) * sizeall(size, strs, sep)));

sizeof (char)是不必要的，因为它总是1 。 您需要将额外的1个字节添加到传递给malloc的长度上，以便为最终字符串中的 NUL 字节腾出空间。

请记住，指针也是值。 str = strs[0]; 将保存在strs[0]的指针分配给变量str 。 它不会复制strs[0]的内容。 您正在使用指向不同内存的指针覆盖malloc返回的值。

相反，给定这组函数，将malloc返回的malloc初始化为空字符串，通过将第一个字节设置为 NUL，并使用ft_strcat连接第一个字符串。

没有必要不断地重新分配ft_strcat的结果，因为您已经在改变str ，并且返回值永远不会改变。

一个完整的例子。 当不再需要生成的字符串时，一定不要忘记free它。

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

int size_str(char *str)
{
    int i = 0;

    while (str[i])
        i++;

    return i;
}

char *ft_strcat(char *dest, char *src)
{
    int i = 0,
        length = size_str(dest);

    do
        dest[length++] = src[i];
    while (src[i++]);

    return dest;
}

int size_all(int size, char **strs, char *sep)
{
    int total_length = size_str(sep) * (size - 1);

    for (int i = 0; i < size; i++)
        total_length += size_str(strs[i]);

    return total_length;
}

char *ft_strjoin(int size, char **strs, char *sep)
{
    char *result = malloc(1 + size_all(size, strs, sep));
    result[0] = '\0';

    ft_strcat(result, strs[0]);

    for (int i = 1; i < size; i++) {
        ft_strcat(result, sep);
        ft_strcat(result, strs[i]);
    }

    return result;
}

int main(void)
{
    char *sep = "   ";
    char a1[] = "Batata";
    char a2[] = "frita";
    char a3[] = "\'e";
    char a4[] = "melhor";
    char a5[] = "que";
    char a6[] = "Banana";
    char *strs[] = {a1, a2, a3, a4, a5, a6};
    char *final = ft_strjoin(6, strs, sep);

    printf("%s\n", final);

    free(final);
}

输出：

Batata   frita   'e   melhor   que   Banana