do.while

Im wondering in what fashion [sysmem_copyptr] is processing its task .

from which direction its pointers are copied ?

Lets assume that pointers holds an digit type :

Through resizing im generating new "table" size

So if it would be an array , in order to shift those from an given index of 2 by 1 , i would have to copy cells starting from last present one ,otherwise i would overwrite cells that would be next in a row to be copied during next cycle .

[4] [7] [old 12] [12] [0] // backward

[4] [7] [old 12] [12] [12] // forward


edit : i know its about block of memory not , pointer by pointer fashion . but thats even more confusing .

is it how pointers (memory) are copied by [sysmem_copyptr] ? or there are some other principles i should understand first in order to ask (or not) such questions ?

    type *data // data pointer

    long index = 2 ;             // insert/gap position
    long size = sysmem_ptrsize(data) ;    // current data size
    long offset = index*sizeof(type) ;    // offset in bytes
    long shift_size = size-offset;         // bytes to be appended

    // resize first
    data = (type *)sysmem_resizeptrclear( data , size+sizeof(type)); 

    // and copy shift by 1
    sysmem_copyptr( data+index , data+index+1 , shift_size);

    // and insert  


After exercise i can assume that pointers are copied backward starting from "end" address . But im not acknowledged how such implementations works under the hood . It also could mean that im trying to do something dangerous , and im just stupid noob , not just noob .

As long as ive tested it ,no problems occurred . But is it safe enough to implement ?

insert new one  of the same type where the "gap" has been achieved thought "this" operation . 

My wondering refer to question :
from which direction its pointers are copied ?

edit : i know its about block of memory not , pointer by pointer fashion . but thats even more confusing .
is it how pointers (memory) are copied by [sysmem_copyptr] ? or there are some other principles i should understand first in order to ask (or not) such questions ? 

	type *data // data pointer

	long index = 2 ; 			// insert/gap position
	long size = sysmem_ptrsize(data) ;	// current data size
	long offset = index*sizeof(type) ;	// offset in bytes
	long shift_size = size-offset; 		// bytes to be appended

	// resize first
	data = (type *)sysmem_resizeptrclear( data , size+sizeof(type)); 

	// and copy shift by 1
	sysmem_copyptr( data+index , data+index+1 , shift_size);

	// and insert  


After exercise i can assume that pointers are copied backward starting from "end" address . But im not acknowledged how such implementations works under the hood . It also could mean that im trying to do something dangerous , and im just stupid noob , not just noob .
As long as ive tested it ,no problems occurred . But is it safe enough to implement ?


pointer-shifting-with-sysmem_copyptr

Hi, sysmem_copyptr() currently calls memmove() (

 memmove() allows overlapping buffers (presumably it has an intermediate buffer, but I'm not sure), so in the current implementation, your code should work (I didn't test it).

I don't anticipate that we'd be changing this implementation anytime soon, but we reserve the right to do so (our header file cites memcpy(), which explicitly does not allow this), so you might be well-advised to use a temporary buffer to do your copying if you want to be future-proof.

Hi, sysmem_copyptr() currently calls memmove() (http://www.manpagez.com/man/3/memmove/). memmove() allows overlapping buffers (presumably it has an intermediate buffer, but I'm not sure), so in the current implementation, your code should work (I didn't test it). 

Thank you Jeremy for the note . for the sake of psychological aspect here :) i will use memory buffer solution . Glad u found time to respond

pointer shifting with [sysmem_copyptr]