Problems writing the memset function

Question

Hi, I am writing the memset function and my code is below, I am having a problem

void* memsetFun(void* pointer, int c, int size) {

  if ( pointer != NULL && size > 0 ) {

    unsigned char* pChar =  pointer;


    int i = 0;

      for ( i = 0; i < size; ++i) {

      unsigned char temp = (unsigned char) c;

      *pChar++ = temp; // or pChar[i] = temp (they both don't work)

    }
  }  
    return pointer;


}

I also tried pChar[i] = the value we want and still not working. It gives me some trash numbers that do not make any sense.

And I am calling it:

memsetFun(address, num, size);
printf("value at %p is %d\n", address, *((int*) address));

Where I call the address (I just input the address)

For example, if you to print the chars ( c ) it prints like a weird char that looks like ( for the value 4 )

0 0
0 4

Answer 1

return p; prevents this from compiling: p is not defined.

A minor efficiency issue—in practice it would have little effect, since any good compiler would rearrange it, but coding perfectionists wouldn't allow it to remain—the assignment to temp is inside the loop, but it is the same assignment every time. That is, the assignment to temp can be moved before the loop.

Answer 2

You return p, which isn't defined/doesn't point to anything in particular. Maybe you meant pointer?

Answer 3

The code is logically correct. With the p => pointer change it works correctly.

Clarify how exactly it is "not working". Perhaps you are not understanding what it is supposed to do?

Answer 4

You are probably getting trash numbers because you are casting from an int (4 bytes) to an unsigned char (1 byte), so if c > 255 or < 0 you won't be memsetting the values you are expecting to be.

Answer 5

Your function, as is, works for me.

I suppose you're calling it wrong. I call it like this

char a[100];
memsetFun(a, 0, sizeof a);
int b[100];
memsetFun(b, 0, sizeof b);

How are you calling your memsetFun()?

Edit

With

int b[100];
memsetFun(b, 9, sizeof b);

as an int is made up of 4 bytes (on my system) each value will be set to 0x09090909 or 151587081.

Answer 6

I ran a test if your program setting the memory of an int vector of 5 elements setting with the value 0x01.

The problem here is that you are iterating in a vector of int for example (which is 4 bytes) but iterating over it using char pointer arithmetic (1 byte). If you want to memset 0x01 for example you will write this number per value in the vector: 00000001000000010000000100000001 which gives me the same value using the original memset.

Answer 7

Your code looks fine to me and several people here have commented that it works on their system.

So the obvious thing to do is to debug it - that's a skill that will come in handy quite a bit in future :-) You should learn it now.

What does the following code output when you run it?

void* memsetFun(void* pointer, int c, int size) {
    printf("A %x %d %d\n", pointer, c, size);
    if ( pointer != NULL && size > 0 ) {
        printf("B\n");
        unsigned char* pChar =  pointer;
        int i = 0;
        for ( i = 0; i < size; ++i) {
            printf("C %d (%d)", i, *pChar);
            unsigned char temp = (unsigned char) c;
            *pChar++ = temp; // or pChar[i] = temp (they both don't work)
            printf(" -> (%d)", i, *(pChar-1));
        }
    }  
    printf("D\n");
    return pointer;
}

From the output, it should be clear what paths the code is taking and what your parameters are (which will greatly assist the debugging process).

Update:

If you're filling your memory block with anything other than zeros and using this:

printf("value at %p is %d\n", address, *((int*) address));

to print it out, you will get strange results.

You're basically asking for a number of those bytes to be interpreted as an integer. So, for example, if you filled it with 0x02 bytes and you have a 4-byte integer type, you will get the integer 0x02020202 (33686018), not 0x02 as you may expect. If you want to see what the first character value is, use:

printf("value at %p is %d\n", address, *((char*) address));

And based on your latest question update:

For example, if you to print the chars ( c ) it prints like a weird char that looks like ( for the value 4 )
0 0
0 4

If that's a single character and you're printing it as a character, there's probably nothing wrong at all. Many output streams will give you that for a control character (CTRL-D in this case, ASCII code 4). If you instead filled it with ASCII code 0x30 (48), you would see the character '0' or ASCII 0x41 (65) would give you 'A'.

Answer 8

That is exactly what it's supposed to do. Your function is working perfectly fine. The value "0x4" is not the ASCII character '4'.

Answer 9

As pointed out already, your function works as it should. Here is a complete example:

#include <assert.h>
#include <string.h>

void* memsetFun(void* pointer, int c, int size) {
    if ( pointer != NULL && size > 0 ) {
        unsigned char* pChar =  pointer;
        int i = 0;
        for ( i = 0; i < size; ++i) {
            unsigned char temp = (unsigned char) c;
            *pChar++ = temp; // or pChar[i] = temp (they both don't work)
        }
    }
    return pointer;
}

int main() {
    // Your memset
    char a[10];
    memsetFun(a, 'A', sizeof(a));

    // Uses system memset for verification
    char b[10];
    memset(b, 'A', sizeof(b));

    assert(sizeof(a) == sizeof(b));
    assert(memcmp(a, b, sizeof(b)) == 0);
    return 0;
}

Answer 10

It turned out that your memsetFun was correct, but your understanding of it was incorrect. You were asked repeatedly to show us the full code, but you didn't. You didn't even show us the actual input values you used in your call. From this, I hope you learn that:

• When we ask for full code, we mean it.
• If your code is really long, you should isolate the problem to a minimal program, which is still compilable, and post it.
• You should not say "it doesn't work"; instead, you should tell us exactly how it doesn't work. What did you expect it to do? What did it do?
• When you post code, copy-paste it. This will allow you to avoid errors like return p; when you wanted return pointer;.

Please understand that we are all trying to help you (and others), and the first step in the process is for you to help us help you by providing accurate information.

Finally, I have two comments about your memsetFun:

• You should rename it to something else: names beginning with mem and followed by a lowercase letter are reserved for the C language.
• You should change the type of the third parameter to size_t, because that is how memset is defined.

If your instructor gave you the function name and/or prototype, you should talk to him about it.