Thread: The keyword restrict in the prototype of memcpy function.

I have a query about memcpy's prototype.

Since the arguments are restricted pointers and according to a restricted pointer only that pointer has access to the object how the function works? and copies the bytes from one pointer to another?

I think overlapping situation is something like :

Code:

#include<stdio.h>

int main(void)
{
  char msg[60]="abcdefghijklmnopqrstuvwxyz";
 char tmp[60];

strcpy(tmp , msg);
memcpy(tmp+4 , tmp+16 , 10); /* without overlap temp is : abcdqrstuvwxyzopqrstuvwxyz */

strcpy(tmp,msg);
memcpy(tmp+6, tmp+4,10); /* with overlap temp is :
abcdefefefefefefqrstuvwyz */

return 0;
}

for example here :

Code:

// C99 code
void *memcpy(void * restrict dest, const void * restrict src, size_t n)
{
    char *d = dest;
    const char *s = src;
    size_t i;
    for (i = 0; i != n; ++i)
        d[i] = s[i];
    return dest;
}

How the assignment d[i]=s[i] works? since d is restricted.

I am confused when I see the keyword restrict in the function although I know its concept.

Originally Posted by Mr.Lnx

Since the arguments are restricted pointers and according to a restricted pointer only that pointer has access to the object how the function works? and copies the bytes from one pointer to another?

I think overlapping situation is something like :

Refer to the C standard:

Originally Posted by C11 Clause 7.24.2.1

The memcpy function

Synopsis

Code:

#include <string.h>
void *memcpy(void * restrict s1,
             const void * restrict s2,
             size_t n);

Description
The memcpy function copies n characters from the object pointed to by s2 into the object pointed to by s1. If copying takes place between objects that overlap, the behavior is undefined.

Returns
The memcpy function returns the value of s1.

Restrict doesn't mean nobody else can access the data. It declares that there isn't some other pointer floating around that points at that data. That's just advisory information.

In the prototype of memcpy(), it serves to document the fact that the source and destination regions are not allowed to overlap each other.

Originally Posted by Mr.Lnx

the statement in memcpy above function

Code:

 d[i] = s[i] ;

is not an access?

It is an access, but since there is no overlap, at no point do you access an element through d that is also accessed through s.

Originally Posted by Mr.Lnx

Ok but with this the concept of restriction to a pointer does not corrupted?

What do you mean by "corrupted"?

Originally Posted by laserlight

What do you mean by "corrupted"?

I mean that is canceled. When you say that you declare a pointer to be restricted how you can have access from some other? live the previous examples. The only access is from one pointer.

For example if you have :

Code:

  memcpy( str , str+2 , N);

So this is a possible overlapping. But the call

Code:

 memcpy( str+2 , str , N)

is a certain overlapping.

Maybe you mean if we have a different strings for example string1 and string2.

Code:

  char string1[N]="bla bla";
          char string2[N]="bla blah";

So on this case you are right since there is no overlap, at no point do we access an element through d that is also accessed through s. The copy comes from *s1++ = *s2++; statement there is no some assignment s1=s2; I have only this on my brain in order to understand the concept of restriction. Sorry

Originally Posted by Mr.Lnx

I mean that is canceled. When you say that you declare a pointer to be restricted how you can have access from some other? live the previous examples. The only access is from one pointer.

Please show how you have access from some other pointer. I have already told you that that does not happen. The only access is from one pointer.

EDIT:
I quoted the C standard is post #2: if there is overlap, the behaviour is undefined. In other words, if you violate the pre-condition, then you have this logical problem of aliasing despite the use of restrict, but that is a bug with the memcpy call, not with memcpy itself. Fix your bug instead of complaining about restrict and memcpy.

Originally Posted by Mr.Lnx

Sorry but how is from one pointer? s[i] is also a pointer right? the function treats it as a pointer on its body like we know. And d[i] is also a pointer in the function only! So we copy from s[i] to d[i] so it is an access from a different pointer (the s[i]). I am confused. :/

s[i] is not a pointer: it is a const char. s is a pointer, but its value is based on src, so there is no problem: ultimately, access to the object only happens via src.