Thread: More questions (relating to global doubts)

Pointer arithmetic is valid only with subtract and only for pointers that point to the same block of memory (sure, you can do it for other pointers too, since the compiler doesn't actually check it - but the result is undefined, and quite often meaningless).

So ptr1 - ptr2 is valid if ptr1 and ptr2 are pointing to the same original block of memory. And you will get the "number of elements" between the two points - not the number of bytes between. So if it's char, int, struct FILE, or some other functions, it won't make any difference. Pointer arithmetic on void * is undefined.

--
Mats

Originally Posted by matsp

Pointer arithmetic is valid only with subtract and only for pointers that point to the same block of memory (sure, you can do it for other pointers too, since the compiler doesn't actually check it - but the result is undefined, and quite often meaningless).

So ptr1 - ptr2 is valid if ptr1 and ptr2 are pointing to the same original block of memory. And you will get the "number of elements" between the two points - not the number of bytes between. So if it's char, int, struct FILE, or some other functions, it won't make any difference. Pointer arithmetic on void * is undefined.

--
Mats

Right, thanks.

One last question to wrap everything up (for now). Are the following implementations of memcpy and memove ok? I'm not quite sure if memmove is meant to do that.

Code:

/* memcpy - Copy memory from source to destination with the length of num. */
void * memcpy ( void * destination, const void * source, size_t num ) {
char* ptr_src=(char*)source,* ptr_dest=(char*)destination;
while(num--) *ptr_dest++ = *ptr_src++;
return destination;
}
/* memmove - Copy memory from source to destination with the length of num using a secondary buffer. This is useful for overlapping memory blocks. */
void * memmove ( void * destination, const void * source, size_t num ) {
char* buffer = new char [num];
memcpy((void*)buffer, source, num);
memcpy(destination, (void*)buffer, num);
delete[] buffer;
return destination;
}

And so I thank you once more and guarantee to you that this is the last topic to be discussed, not to bother you that much.

Jorl17

Edit: About the functions, I haven't altered them to fix the casts and all that, so don't comment on that please, I'm already fixing it

I'm sorry but who else in this thread are discussing using globals? I take "global doubt" in the title to mean "general questions"...

Besides, as OP is reimplementing the standard C/C++ library, it does use globals (rand/srand, std::cout and friends) and static buffers/variables, so what can you do?

Code:

void * memmove ( void * destination, const void * source, size_t num ) {
char* buffer = new char [num];
memcpy((void*)buffer, source, num);
memcpy(destination, (void*)buffer, num);
delete[] buffer;
return destination;
}

1. Standard C functions should not use C++ functionality.
2. What if the user tries to copy 1GB of memory - you will most likely fail the new.

The normal memmove deterimens if the copy is overlapping, and if so, copies in a direction that avoids overwriting the data, otherwise just call memcpy() in the first place.

Also, your memcpy() is FAR from the optimal performance.

--
Mats

How does memmove determine overlaps?

Originally Posted by anon

How does memmove determine overlaps?

Comparing the range of source, source+len with destination, destination+length. If destination or destination+ len is within source to source + length, then it is an overlap.

--
Mats

Originally Posted by Jorl17

Right, so replace c++ syntax with C syntax, shouldn't be too harsh. How can I copy memory without allocating new one?

By copying in the opposite direction of there is an overlap. (so start at source+length-1 and copy to destination+length-1 - the same way you would do if you have an array that you want insert something into - you start at the back and copy each down one up to the point where you want the empty location).

And how would I determine if they overlap? Would it be done using pointer arithmetic?

Check out my reply to anon.

Why is memcpy such a performance hit atm?

Because it is copying a byte at a time, which is quite slow on all machines. It is correct (and correctness is better than performance).

Some of the work I did with Mike Wall at AMD is published here. It's not EXACTLY memcopy, but it explains some of the basic principles
http://www.amd.com.cn/CHCN/Processor...9_7451,00.html
(Scroll to the bottom for a 2002 presentation about "Block Prefetching").

--
Mats

And as you can see, the linked memmov use "long" size if possible - it's only doing the simplest form of aligned copies, but that will be very close to "sizeof(long)" times faster than a char copy.

--
Mats

Here's my attempt:

Code:

const char* 
strrchr( const char* str, int val )
{
    const char* 
        ptr;
    for( ptr = 0; *str; ++str )
    {
        if( *str == val )
            ptr = str;
    }
    return ptr;
}

char* 
strncpy( char* dst, const char* src, size_t len )
{
    char* 
        cpy = dst;
    while( len-- )
    {
        *cpy++ = *src++;
    }
    *cpy = 0;
    return dst;
}


size_t
strspn( const char* str, const char* pat )
{
    const char*
        bas = str;
    int
        fnd = 1;
    for( ; *str && fnd; ++str )
    {
        fnd = 0;
        for( const char* ptr = pat; *ptr; ++ptr )
        {
            if( *str == *ptr )
            {
                fnd = 1;
                break;
            }                
        }
    }
    return str - bas;
}