).A memory address is a location within your computers memory. Its where something is. And each one of your variables has a memory address of its own. Which means that at that address in memory is the value of that variable. Say for instance you have a single integer named
x and it has a value of 654. Let's pretend that x's memory address is "0x5FA70" (hexidecimal). Well, at the location "0x5FA70" in your computers memory is the number 654. Still, don't see it? Okay, well let's just say for the sake of example that your computer's memory looks like this:| memory address | value |
| 0x5FA62 | ... |
| 0x5FA66 | ... |
| 0x5FA70 | 654 |
| 0x5FA74 | ... |
| 0x5FA78 | ... |
See, now at the memory address "0x5FA70" is the number
654. I put "..." in the other boxes because we don't know what's at those memory locations. On a nerdy note, I wrote the memory addresses in hexidecimal because its easier to represent them that way. Also, the addresses in this depiction increase in increments of 4. That is because the size (in bytes) of an integer is usually four (unless you're working with a crummy ol' 16-bit compiler). Actually you can try out the following program to see how big (in bytes) your typical integer is with your compiler:/* -example-[size of typical integer]-------------------------------- */
#include <iostream.h>
int main()
{
int x;
cout << "The size of integers on this compiler is " << sizeof(x)
<< " bytes." << endl;
return 0;
}
/* ------------------------------------------------------------------ */Remember, every single stinking variable has a memory address. It has to keep whatever you put into it somewhere. So when we stick that
654 into x it puts it at that memory address. The memory address is the place where that variable keeps its value. I suppose you might be able to say its like how everyone on the internet has an email address. Hmm, better yet. Since a memory address is a location ... if you were a variable then the place you were sitting/standing would be your memory address. And what you are is the value that is put there.&x we would see "0x5FA70" rather than 654. And how does this work, you ask?Let's say we wanted to output the memory address of
x. Run this short program:
/* -example-[memory address of 'x']---------------------------------- */
#include <iostream.h>
int main()
{
int x = 654;
cout << "The value of 'x' is " << x << ", its memory address is "
<< &x << endl;
return 0;
}
/* ------------------------------------------------------------------ */x we're telling the compiler, "we don't care what the hell it has, we want to know where it is!" You'll get varying results from this program, for example when I compiled it through DJGPP I did get "0x5FA70".By this point you should have a very basic understanding of memory addresses. Enough so you kind of know what they are, and what's in them.
x may very well be at that address. However, when you're program completes and exits (or crashes ), the address becomes available again. The next time you run your program x could possibly be a memory address megabytes away!Did you ever declare a variable and then view its contents before actually putting anything there? Well, try it out and you'll probably find that there's garbage data there. Garbage as in useless! When a process or program ends or at least stops using a part of memory, it does not automatically get cleared. This means that when another program comes along to use the same space, there will generally be crap there. That's why its a good idea to remember to initialize your variables before using them and never assume that the value will be zero. Some compilers will automatically generate code to reset variables when you declare them - do not depend on this under any circumstance.
Think of "647" as the person that lives at address "0x5FA70".
x could be the car that gets you to see that nice person, "647". If you put an ampersand(&) in front of x you are looking for the house address and you could care less about who's inside.Still unfinished!
