Pointers in C

Hello students, welcome to Kwickprep. Every variable in your program lives at an address, just like your home. What if a variable could store that address? That variable is a pointer. Today we learn memory addresses, declaring and dereferencing pointers, pointer arithmetic, and pointers with arrays and functions.

Think of computer memory as a very long street of houses. Memory is a long row of tiny boxes, and each box is called a byte. Every byte has a number, called its address, just like a house number. A variable uses a few bytes, and an int usually takes four. The ampersand sign before a variable, as in ampersand x, gives its address.

Let us picture it, using easy made-up addresses. The variable marks lives at address one thousand, and stores eighty five. The pointer p lives at address two thousand, and stores one thousand, which is the address of marks. When we write star p, C goes to address one thousand and finds eighty five. Real addresses are long numbers in hexadecimal, and they change every time you run the program.

Here is how to see a real address. The first printf prints the value, eighty five. The second uses percent p, the format for an address, with ampersand marks. The void star cast is the correct way to pass an address to percent p. It prints a long hexadecimal number, and that number changes on each run.

Now let us declare a pointer. Int star p means p is a pointer that can hold the address of an int. P equals ampersand marks stores the address of marks inside p. Star p, used in an expression, means go to that address and use the value there, and this is called dereferencing. The type must match, so an int pointer holds the address of an int, not a float.

Here p points to marks. The line star p equals ninety means, go to the address in p and store ninety there. That address belongs to marks, so marks itself becomes ninety. So printing marks and star p both give ninety. We changed marks without ever writing its name.

Students often mix up these two symbols. The star in a declaration, like int star p, makes p a pointer, while in an expression it means the value at the address. The ampersand in an expression means address of, and it is not used in a pointer declaration. Remember, ampersand gives an address, and star follows an address.

Pointers need care. A pointer that is declared but not given an address holds a garbage address. Using star on it may change random memory or crash the program. So if a pointer has no address yet, set it to NULL, which means points nowhere. And before using star p, check that p is not equal to NULL.

Pointers can do a little arithmetic, and it works in a special way. P plus one moves to the next element, not simply the next byte. For an int pointer, the address jumps by the size of an int, usually four bytes. P plus plus moves the pointer forward, and p minus minus moves it back. Subtracting two pointers into the same array tells you how many elements apart they are, but adding two pointers is not allowed.

Suppose an int array holding ten, twenty and thirty starts at address one thousand, and p points to it. P itself is address one thousand, and star p is ten. P plus one is address one thousand four, not one thousand one, and the value there is twenty. P plus two is one thousand eight, and the value is thirty.

Pause and predict the output. P starts at the first element, ten. After p plus plus, p points to the second element. So star p is twenty. Star of p plus one is the element after that, thirty. The output is twenty and thirty.

Arrays and pointers are close friends in C. The name of an array gives the address of its first element. In fact, a of i is just a short way to write star of a plus i. That is why int star p equals a needs no ampersand. But an array name is not a variable, so a plus plus gives a compiler error.

Here we walk through an array using only a pointer. P starts at a, the first element. While p is less than a plus four, which is just past the last element, we add star p to sum. Then p plus plus moves to the next element. Five plus ten plus fifteen plus twenty is fifty.

Pointers let a function change a variable in main. The function add GST receives the address of bill in a pointer called price. It adds eighteen percent to the value at that address. Five hundred plus ninety is five hundred ninety. Because we passed ampersand bill, bill in main really changes, which is call by reference.

Let us revise what we learned today. Every variable has an address, and the ampersand sign gives it. A pointer like int star p stores an address, and star p reads or changes the value there. P plus one jumps by the size of the type, not by one byte. For arrays, a of i is the same as star of a plus i. And pass ampersand x when a function must change x. Draw memory boxes on paper for every pointer program you trace.