<\/td><\/tr><\/table><\/p>\nHere is how it works:<\/p>\n
<\/p>\n
The Heap…<\/h3>\n
You’ve probably noticed that programs take up computer memory. As they do stuff, they need to store information. The program says, “Hey, I need 8 bytes of memory.” The system finds a free spot in memory big enough to hold something 8 bytes in size, and tells the program where it is. This happens thousands of times a second for a busy program. Get four bytes. Get eight more bytes. Then release the four because you’re done with them. Now get 100 bytes. Now get a megabyte. Now drop the eight bytes. <\/p>\n
This sea of data is called “the heap”. It’s also sometimes called the “free store”, but I’ve only ever heard old beardy types use that terminology. I think the last time I saw the words “free store” was in 1991-ish. And the book I was reading was already old.<\/p>\n
Anyway, usually this activity is abstracted for a programmer. You just create variables when you need them and throw them away when you’re done. <\/p>\n
But sometimes, in some languages, you do need to worry about memory. And this is where things get messy.<\/p>\n
…and the trashing thereof.<\/h3>\n
Let’s say you’re programming in C or C++, and you have the program grab enough memory to store 20 bytes of data. And now you make a perfectly innocent mistake and accidentally copy 4,096 bytes into that 20-byte slot. (This is actually easy to do for a lot of reasons. More on that in a minute.) Your data will fill up those 20 bytes, and then overwrite the next 4,076 of data. Any variables that happened to be occupying that space have now had their values replaced with something different. <\/p>\n
Congratulations, you’ve just trashed the heap. If you are very very lucky, the program will crash right away. <\/p>\n
If you are not<\/em> lucky, it will continue to run but begin behaving oddly. See, those 4,076 bytes of memory might have been filled with crucial bits of data needed to keep this program operational. If it crashes instantly you can look at what it was doing just before death and you’ll find the trouble spot. But those bytes of memory could have been empty, and thus spewing a bunch of random garbage into that space is “harmless”. (This time.) What you’ve got in this case is a random crash bug. The program may run fine, act oddly, or insta-crash, all based on what things happened to be in that spot of memory at the time. <\/p>\n This is the subject of holy wars. Some say that C is a crap language because you can (and must) interact with memory directly. Other people say the people in the first group are just crap programmers.<\/p>\n I am not an expert on languages. Other than doing a lot of BASIC in my teenage years I’ve spent limited time dabbling outside of C, so I can’t make any really good comparisons. But 90% of the problems I have in C are because it doesn’t have a simple way of handling strings of text.<\/p>\n Here is a bit of old-school BASIC code that adds two strings of data together:<\/p>\n Run this, and it will take two phrases:<\/p>\n and: <\/p>\n And merge them together to print the entire sentence. <\/p>\n In many languages you can define bits of text, cut them up, join them, or whatever you like and you don’t have to worry about memory. In fact, it’s actually impossible to worry about memory in old-school BASIC – it has no tools for doing so. It’s simple. It’s readable. It’s impossible to make it crash. (Although it’s still possible to create all sorts of other bugs. But trashing the heap is not a risk.)<\/p>\n In C*, the language does not do all of this legwork for you. If you wanted to add those strings together you’d need to measure the length of the first string. Then measure the length of the second. Then allocate a block of memory large enough for both strings plus 1 extra byte. Then copy the first string into that spot of memory. Then copy the second string in the spot 24 bytes after that (just after the first string). <\/p>\n (Note to would-be nitpickers: I’m aware you’d use sprintf to save yourself a few lines, and I know you wouldn’t really do things just this way. This post is for non-coders. Don’t Be That Guy.)<\/p>\n The advantage of the C way is that it is crazy fast and memory efficient. This was important back when machines ran at sub-megahertz speeds and had 64k of memory. Which is not even enough memory to store this one image:<\/p>\nWHYYYYY!?!?<\/h3>\n
a$ = \"Twilight is a great book\"\r\nb$ = \"- for starting arguments!\"\r\nc$ = a$ + b$\r\nPRINT c$\r\n<\/pre>\n
Twilight is a great book<\/code><\/p>\n- for starting arguments!<\/code><\/p>\nTwilight is a great book - for starting arguments!<\/code><\/p>\n\r\nchar* TellMeAboutTwilight ()\r\n{\r\n\r\n char a[] = \"Twilight is a great book\";\r\n char b[] = \"- for starting arguments!\";\r\n \/\/See how big a and b are\r\n int len = strlen (a) + strlen(b);\r\n \/\/Now allocate enough memory for both, plus 1 byte\r\n char* c = (char*)malloc (len + 1);\r\n \/\/Now copy a into c\r\n strcpy (c, a);\r\n \/\/Now copy b just after that\r\n strcpy (c + strlen (a), b);\r\n return c;\r\n\r\n}\r\n<\/pre>\n
<\/a><\/td><\/tr><\/table><\/p>\n