如何用C中的内存地址初始化char数组？

Question

I'm in a sophomore C class and this project is about dealing with pointers and designing a memory dump function. So I've been able to struggle through the pointers and got a beginning and ending address to dump, even bitmasked it, and I wanted to initialize a char array with the beginning memory address. I initialize it with the same variable storing my masked beginning address but when I print the array, it contains a different memory address. Here's the function:

void memDump(void *base, int bytes)
{
unsigned char *begin;
begin = base;//beginning of range of memory
unsigned char *end;// ending range of memory
end = base + bytes;
int a, b;
long long int d=base;
d=d&0xFFFFF0; //trying to bitmask
long long int e=end;
e = e&0xFFFF0; //masked off the beginning and ending range
char c[16]={d}; //loop variables
printf("%x", c);

for (a=begin; a<=end; a+=16)
    {
        printf("\n%016X\n", d);
        printf("%016X\n", a);
        printf("%016X", e);
    }

}

Sorry guys, i can't find something similar and this is my last resort. Thanks!

Update: Thanks for the insight everyone, reading some more about C and some articles on how to debug helped me out.

Answer 1

You cannot "initialize a char array" with some "memory address." A char array can only be initialized with characters.

Stackoverflow is not about doing your homework for you, so I will give you some advice, and then you can try implementing it. If you cannot put the advice into code, then you do not deserve to turn in a completed assignment.

First of all, once you have bitmasked your "d", you need to store it back into "begin", so that you have a pointer from which you can start reading bytes to dump.

This instruction:

printf( "%08p ", begin );

Will render the hexadecimal representation of your "begin" address in 8 characters, followed by a space. This is how you need to begin each row of your memory dump.

The instruction:

printf( "%02x ", *(begin++) );

gets the byte pointed by "begin", and renders the hexadecimal representation of that byte in two characters, followed by a space. It then increments "begin", to point to the next byte. You need to do this 8 or 16 times, depending on how wide you want your memory dump to be, then do a printf( "\\n" ) to move to the next line.

Then you need to keep repeating the above until your "begin" has exceeded your "end". (So, you are looking at an outer loop, for each row, and an inner loop, for each byte within the row.)

I hope this helps.

Answer 2

As @Jean-FrançoisFabre observed,

 char c[16]={d};

probably does not do what you think it does. That is, unless what you think it does is convert the long long int value stored in d to type char (producing an implementation-defined result drawn from a much smaller range than that of d itself), initializing the first element of array c with that value, and initializing the other fifteen with 0 . I can't imagine what you would want to do with the result, but since you actually don't do anything with it, that's probably moot.

As I observed myself,

 printf("%x", c);

also probably does not do what you think it does. Indeed, you cannot rely on it to do any particular thing, because its behavior is undefined. You are passing a pointer to the first element of c as the second argument, but a value of type unsigned int will be expected instead (based on the format). In any case, this neither "print[s] the array" nor tells you anything about what it contains .

I suspect that what you actually had in mind was to declare c as an array whose address -- not contents -- is that designated by base , truncated to a 16-byte-aligned address. You cannot do that, because you cannot specify the address of any variable you declare, but you can declare c as a pointer, like this:

unsigned char *c = d;

(Oh no, more pointers!) There's some implementation-dependency there, but it probably has the result I think you want. Or if you want to be really clever, you might do this:

unsigned char (*c16)[16] = d;

That declares c16 as a pointer to an array of 16 unsigned char . It's as close as you can get to declaring an array at an address specified by you. I suspect you'll find it easier to work with the other declaration, however.

If you want to print the contents of the memory to which such a pointer points (as a "memory dump" function seems wont to do) then you'll need to do a little more work. The standard library's formatted I/O functions do not provide directly for printing arrays (for good reasons that I'll not go into here), except C strings, and you do not appear to want to print the data as a C string. Do, however, consider this call, and how you might modify it for or adapt it to your purpose (assuming my above declaration for c ):

printf("%02x", *c);