CareerCup

divide by 8 ..store in bytes_copied
mod by 8 ...store in leftover_bits

perform normal memcpy using bytes at dest_address

new_dest_address = dest_address + bytes_copied ;
new_src_Address = src_address + bytes_copied ;
uint8 mask = (1 << (leftover_bits + 1) - 1;
uint8 maskComplement = ~(mask);

new_dest_address = (*new_src_address & mask ) | (*new_dest_address & maskComplement);

void memcpy(char *src, char *dst, size_t nbit){
while( nbit / 8 > 0 ){
*dst++ = *src++; // Multiples of bytes, so copy byte level
nbit -= 8; // Decrement 1 byte
}
// Take care of the remaining bits
*dst = (*src) & (-1 >>(8-nbit));// Do a bitwise and of the src and left bits
}

if we just do a bitwise "or" operation that is similar to copy right ?

how to check the "dst" do not locate at the end of memory? or if "dst" locates at somewhere that should be protect?

oid memcpy(char *src, char *dst, size_t nbit){
while( nbit / 8 > 0 ){
*dst++ = *src++; // Multiples of bytes, so copy byte level
nbit -= 8; // Decrement 1 byte
}
// Take care of the remaining bits
*dst = (*src) & (1 >>(8-nbit)-1);// Do a bitwise and of the src and left bits
}

public static unsafe void memcpy(byte* src, byte* dest, int count)
        {
            if (count == 0) return;
            count -= 8;
            while (count > 0)
            {

                *dest++ = *src++;
                count -= 8;                    
            }
            
            byte t = *src;                 
            t = (byte)(t >> ( - count));
            t = (byte)(t << (- count));
            *dest++ = t;
            count = 0;
            return;
        }