So far, your programs have only used memory that has been in frames on the stack. This memory is automatically allocated when the function starts and automatically destroyed when the function ends. (In fact, local variables are often called automatic variables because of this convenient behavior.)
Sometimes, however, you need to explicitly claim a long line of bytes of memory and use it in many functions. For example, you might read a file of text into memory and then call a function that would count all the vowels in that memory. Typically, once you were finished with the text, you would let the program know you were all done so the program could reuse that memory for something else.
Programmers often use the word buffer to mean a long line of bytes of memory. (This explains the term “buffering” to describe the wait for YouTube to send you enough bytes for that cat video to get started.)
You claim a buffer of memory using the function malloc(). The buffer comes from a region of memory known as the heap, which is separate from the stack. When you’re done using the buffer, you call the function free() to release your claim on that memory and return it to the heap. Let’s say, for example, I needed a chunk of memory big enough to hold 1,000 floats.
#include <stdio.h>
#include <stdlib.h> // malloc and free are in stdlib
int main(int argc, const char * argv[])
{
// Declare a pointer
float *startOfBuffer;
// Ask to use some bytes from the heap
startOfBuffer = malloc(1000 * sizeof(float));
// ...use the buffer here...
// Relinquish your claim on the memory so it can be reused
free(startOfBuffer);
// Forget where that memory is
startOfBuffer = NULL;
return 0;
}
startOfBuffer would be a pointer to the first floating point number in the buffer.
At this point, most C books would spend a lot of time talking about how to read and write data in assorted locations in that buffer of floating pointer numbers. This book, however, is trying to get you to objects as quickly as possible. So, we will put off C arrays and pointer arithmetic until later.
You can also use malloc() to claim space for a struct on the heap. For example, if you wanted to allocate a Person struct on the heap, you might have a program like this:
#include <stdio.h>
#include <stdlib.h>
typedef struct {
float heightInMeters;
int weightInKilos;
} Person;
float bodyMassIndex(Person *p)
{
return p->weightInKilos / (p->heightInMeters * p->heightInMeters);
}
int main(int argc, const char * argv[])
{
// Allocate memory for one Person structure
Person *x = (Person *)malloc(sizeof(Person));
// Fill in two members of the structure
x->weightInKilos = 81;
x->heightInMeters = 2.0;
// Print out the BMI of the original Person
float xBMI = bodyMassIndex(x);
printf("x has a BMI of = %fn", xBMI);
// Let the memory be recycled
free(x);
// Forget where it was
x = NULL;
return 0;
}Notice the operator ->. p->weightInKilos says, “Dereference the pointer p to the structure and get me the member called weightInKilos.”
This idea of structures on the heap is a very powerful one. It forms the basis for Objective-C objects, which we turn to next.