Is it possible to have an efficient replacement for the memmove() function?

I am trying to move memory with possible overlap, using negative or positive increments for the *src and *dst, and without using a large temporary buffer.

I am trying to come up with an efficient replacement for the memmove() function, something along the开发者_JAVA技巧 lines of:

smart_memmove(char *dst, const char *src, size_t num, int dst_inc, int src_inc);

dst and src may overlap, and dst_inc and src_inc may be any positive or negative integer (negative increments denote moving backwards in memory with the starting pointer at the top). I'd like to avoid using a large temporary buffer even if it means a reduction in execution speed.

An example of this would be to copy 10 bytes starting from memory location 0 incrementing at every other byte, to memory location 17 counting backwards by 1:

smart_memmove(17, 0, 10, -1, 2);

Another example would be to, say, reverse 10 series of bytes in memory locations 6, 9, 12, 15, 18, 21, 24, 27, 30, 33 by calling smart_memmove with the following parameters:

smart_memmove(6, 33, 10, 3, -3); /* or... smart_memmove(33, 6, 10, -3, 3); */

---

You can also prefer the memcpy() function.

void * memcpy ( void * destination, const void * source, size_t num );

destination Pointer to the destination array where the content is to be copied, type-casted to a pointer of type void*.

source Pointer to the source of data to be copied, type-casted to a pointer of type const void*.

num Number of bytes to copy.

size_t is an unsigned integral type.

Copies the values of num bytes from the location pointed by source directly to the memory block pointed by destination.

The underlying type of the objects pointed by both the source and destination pointers are irrelevant for this function; The result is a binary copy of the data.

The function does not check for any terminating null character in source - it always copies exactly num bytes.

To avoid overflows, the size of the arrays pointed by both the destination and source parameters, shall be at least num bytes, and should not overlap (for overlapping memory blocks, memmove is a safer approach).

Sample Program

/* memcpy example */
#include <stdio.h>
#include <string.h>

struct {
  char name[40];
  int age;
} person, person_copy;

int main ()
{
  char myname[] = "user613994";

  /* using memcpy to copy string: */
  memcpy ( person.name, myname, strlen(myname)+1 );
  person.age = 46;

  /* using memcpy to copy structure: */
  memcpy ( &person_copy, &person, sizeof(person) );

  printf ("person_copy: %s, %d \n", person_copy.name, person_copy.age );

  return 0;
}