There is probably a really simple answer to this but I just can't see it.
#include <stdio.h>
int main(void) {
int x = 0;
printf("\n%d\n%d\n",x,&x);
}
Okay, so the printf gives 0 (x) and 2293752 (&x). I am trying to figure out a way to look at any address (&) and see what is already stored there. This is just for experimentation. Any help?
That would be pointer dereferencing, which is the * operator. However, you have no way of telling what the type of the stored data is for a random address.
#include <stdio.h>
int main(void) {
int x = 0;
printf("\n%d\n%d\n%d\n",x,&x,*(&x));
}
/* resulting output will be 0, some memory address, and 0 again */
Assuming that you want to look at "raw" data and that you know an address inside the address space of your process, you would do this:
long x=<address>
printf("%x", *(int *)x);
void* memAddr = (void*)0xAABBCCDD; //put your memory address here
printf("int value at memory address %p is %i", memAddr, *((int*)memAddr));
You'll probably find that examining arbitrary memory addresses will just cause a crash.
If you want to explore memory, I would recommend using a low-level debugger such as OllyDbg.
There are many problems with attempting to do this, first and foremost that as mentioned by Wilson you really won't have any idea what is stored there.
Wilson is slightly off, though, you really should cast it to a char instead of an int, as with an int you will see 4 bytes not a single byte as you would with a char.
Additionally, unless you can read 8bit ASCII characters and map them to something meaningful in your head, you would probably want to convert it to some other form such as base2, base8, or base16.
You can do this in several ways - probably the best way to do this is with bitwise operators and binary shift operators, looking up into a dispatch table to map it into viewable ASCII.
However, you still won't know what it stored there, you will just be able to see some encoded form of the raw binary data. The reason is that C is typed only with regard to the variable pointing to that memory address. A naked view into that memory will just give you binary and no ability to look up what variables that memory is bound to or what type those variables are.
A second problem is that you need to be careful to only look into portions of the memory you have access to. Unless you are careful with how you access it, code segments of memory can't be looked into. You will be lucky if you poke around to avoid a segmentation fault.
Probably the most effective way, though, to look into memory of a process is to dump its segment to disk. In UNIX this is done through a core dump. You can then load it against a debugger and poke around to your hearts content, and even be able to map it to correct types with enough knowledge of the stack. You can also use a binary editor to examine it in an untyped way - often strings are recognizable.
Good luck!
to see an address you can use %p
printf("%p",&x);
I recommend you start reading about pointers, a pointer is a variable that store a memory address
int x=10;
int *p; //this is a pointer to int
p=&x; //now p has the memory location of x
printf("%d\n",*p); //this will print 10