problem on My own implemntation of strlcpy?

Question

Hello i just faced a problem when testing an implementation of strlcpy

long unsigned int ft_strlcpy(char *dst, const char *src, unsigned int len)
{
  unsigned int l;
  unsigned int i;
  i = 0;
  while (i < len - 1)
  {
      if (*src != '\0')
          *dst++ = *src++;
      i++;
  }
  *dst = '\0';
  return i + 1;
}

i did a test with the original strlcpy but i didn't get the same result src = "string", len = 6 output of my strlcpy

return value = 6
dst = strin

output of the original strlcpy

return value = 10
dst = strin

the result is the same in dst but in the return value should be the length of the string trying to make

Why is it called `strlcpy` if it's supposed to be `strlcat`? — Barmar, Nov 04 '21 at 19:16
So are you talking about `strlcpy` or `strlcat` here? The `10` value suggests `strlcat` but the example you give suggests `strlcpy`. — 500 - Internal Server Error, Nov 04 '21 at 19:16
Tip: `size_t` makes more sense than `unsigned int` or `long unsigned int` — ikegami, Nov 04 '21 at 19:18
yup i'm talking about `strlcpy` it's supposed to give the same output as mine but i don't know why its gives an output like `strlcat` — Hatim Fanzaoui, Nov 04 '21 at 19:18
The return value of the `strlXXX` functions is supposed to be the total size that the result would be if you didn't hit the `len` limit. You're returning the limited length. — Barmar, Nov 04 '21 at 19:19
in the arguments i i'm giving it (`len` limit) to the original strlcpy — Hatim Fanzaoui, Nov 04 '21 at 19:21
If you're saying Barnar is wrong, please provide a minimal, runable demonstration of the problem as required. — ikegami, Nov 04 '21 at 19:22
@Barmar thanks for the correction i didn't realise that i did that lol — Hatim Fanzaoui, Nov 04 '21 at 19:24
`ft_strlcpy(" ", "string", 6)` i did the same for the original strlcpy — Hatim Fanzaoui, Nov 04 '21 at 19:26

score 0 · Accepted Answer · answered Nov 04 '21 at 19:26

From the documentation

The strlcpy() and strlcat() functions return the total length of the string they tried to create. For strlcpy() that means the length of src.

You're returning the length of the resulting string, not the length it would have been without the len limit.

Save strlen(src) in a variable and return that at the end.

size_t ft_strlcpy(char *dst, const char *src, size_t len)
{
  size_t l = strlen(src);
  size_t i = 0;

  while (i < len - 1 && *src != '\0')
  {
      *dst++ = *src++;
      i++;
  }
  *dst = '\0';
  return l;
}

Also, the len parameter and the return type should be size_t.

ikegami · Answer 2 · 2021-11-04T19:37:28.287

It should return the length of the string to copy, not the length of the result.

You seem to be claiming you did

ft_strlcpy(dst, "string", 6);  // 6

and

strlcpy(dst, "string", 6);  // 10

But the output suggests you did something closer to

ft_strlcpy(dst, "abcdefghij", 6);  // 6

and

strlcpy(dst, "abcdefghij", 6);  // 10

strlcpy returns the length of the string it tried to create, meaning the length of the string that would have been copied if the limit hadn't been imposed. This is not what ft_strlcpy returns.

Fixed:

size_t ft_strlcpy(char *dst, const char *src, size_t len) {
  if ( !len )
     return strlen(dst);

  size_t i = 0;
  while ( --len ) {
     if ( !( *dst++ = *src++ ) )
        return i;

     ++i;
  }

  while (*str) {
     ++str;
     ++i;
  }

  return i;
}

yes that's what i faced i don't know why `strlcpy` gives me a different result. — Hatim Fanzaoui, Nov 04 '21 at 19:30

problem on My own implemntation of strlcpy?

2 Answers2