• Sean Kelly (10/10) Jul 02 2006 Assuming I want to remove an element in an array and preserve order,
• Oskar Linde (13/24) Jul 02 2006 As far as I understand, slice copying is equivalent to memcopy and
• Sean Kelly (4/31) Jul 02 2006 I should have just checked the spec :-) Thanks!

Sean Kelly <sean f4.ca> writes:

Assuming I want to remove an element in an array and preserve order, 
does the D spec consider it legal to do this:

     char[] str = "abc def";
     int    pos = 3;
     str[pos .. $-1] = str[pos+1 .. $];
     str.length = str.length - 1;
     assert( memcmp( &str[0], "abcdef", str.length ) );

Or are slice copy semantics equivalent to memcpy where overlapping 
regions are not allowed?


Sean

Oskar Linde <oskar.lindeREM OVEgmail.com> writes:

Sean Kelly wrote:
 Assuming I want to remove an element in an array and preserve order, 
 does the D spec consider it legal to do this:
 
     char[] str = "abc def";
     int    pos = 3;
     str[pos .. $-1] = str[pos+1 .. $];
     str.length = str.length - 1;
     assert( memcmp( &str[0], "abcdef", str.length ) );
 
 Or are slice copy semantics equivalent to memcpy where overlapping 
 regions are not allowed?

As far as I understand, slice copying is equivalent to memcopy and 
overlapping copies are illegal. According to the spec:

(http://www.digitalmars.com/d/arrays.html)
Under Array Copying:

""
Overlapping copies are an error:

s[0..2] = s[1..3];	// error, overlapping copy
s[1..3] = s[0..2];	// error, overlapping copy

Disallowing overlapping makes it possible for more aggressive parallel 
code optimizations than possible with the serial semantics of C.
""

/Oskar

Sean Kelly <sean f4.ca> writes:

Oskar Linde wrote:
 Sean Kelly wrote:
 Assuming I want to remove an element in an array and preserve order, 
 does the D spec consider it legal to do this:

     char[] str = "abc def";
     int    pos = 3;
     str[pos .. $-1] = str[pos+1 .. $];
     str.length = str.length - 1;
     assert( memcmp( &str[0], "abcdef", str.length ) );

 Or are slice copy semantics equivalent to memcpy where overlapping 
 regions are not allowed?

 
 As far as I understand, slice copying is equivalent to memcopy and 
 overlapping copies are illegal. According to the spec:
 
 (http://www.digitalmars.com/d/arrays.html)
 Under Array Copying:
 
 ""
 Overlapping copies are an error:
 
 s[0..2] = s[1..3];    // error, overlapping copy
 s[1..3] = s[0..2];    // error, overlapping copy
 
 Disallowing overlapping makes it possible for more aggressive parallel 
 code optimizations than possible with the serial semantics of C.

I should have just checked the spec :-)  Thanks!

So I suppose memmove is probably optimal in this case?


Sean