One of the fundamental concepts in computer programming is a variable. If you are studying computer science, or programming in general, chances are you know what a variable is. In simple terms,
A variable is a container which holds a value
A variable can hold values of certain datatypes, such as
bool etc. Pointers are nothing but a special kind of variable. Instead of storing a value, it stores address of a variable.
In case all of this jargon didn't make any sense, we will dig deeper into this.
A computer primarily consists of two types of storage, Primary Memory and Secondary Memory, whenever we execute a program, all of the variables declared in it gets stored in the Primary Memory a.k.a the Main Memory a.k.a the RAM. Now the variables can be anywhere in the RAM, but how could we locate them?
Lets say, you want to invite one of buddies to your house, but he has never visited your house before, then how would he find it? He will need an address. With an address he can locate your house exactly. But without one, he has to roam around the entire world until he finds your house. That doesn't sound like a fun task...does it?
Similarly, every variable that is stored in the primary memory has a specific address assigned to it. Different variables can not reside in the same address. Just like, the address of your house and your friends house can not be same unless you both live in the same house.
Now you need to send your address to your friend. How would you do that? Let's say, your send a text message to your friend containing your address. your friend receives it, and comes to your place by locating the address and making his way to it.
Let's retrace his steps, first he receives the text message, which reveals your address, then he locates the specific address to find your house. This is an example of a pointer. Just like the text message contained the address of your house, a pointer contains the address of a variable. It does not contain the actual value of the variable, rather an address where to find it. Imagine if your text message contained your entire house in it. As the text message contained a reference to your actual house, a pointer contains a reference to an actual variable. Dereferencing the pointer reveals the value of the variable it is referencing.
Let's talk CODE 👨💻
- In C Language, a pointer is declared as
- The datatype of a pointer is same as the datatype of the variable it is storing. If a pointer referencing a variable which is storing integer value, the pointer will be an integer pointer, if the variable is storing a character, the pointer will be called a character pointer.
int a = 5; int *ip = &a; // '&' is called the "address of" operator, and the '*' is known as "dereference" operator Here, the address of a is fetched and stored inside ip char c = 'c'; char *cp = &c;
Let's dig deeper into the code. For the first example, let the assume that
a is stored in memory location
a has a value of
ip contains the address of
a. So, technically the value of
ip will be 100. Dereferencing
ip will result in the value of
a which is
Pointers can also hold address of another pointer. They are called double pointers
int a = 5; int *ip = &a; // ip holds the address of a int **pp = &p; // pp holds the address of p, which holds the address of a
In the above example, dereferencing
ip once gives the value of
a. As it directly points to
a, but in case of
pp to get the value of
a you need to dereference twice. As,
pp is holding the address of
ip is holding the address of
This way, pointers can be chained together.
Pointers are SLOW! 🐌
Whenever you execute a program, all the variables declared in it is stored in that programs stack frame which resides in RAM. Now, during the calculations, CPU fetches variables from the RAM into its internal registers. This memory access is not the fastest thing in the world. This process takes up quite a few nanoseconds. So, in case of directly accessing a variable, CPU needs to fetch the variable only once from the memory and it gets its value. But in case of pointers, multiple trips are required to the RAM from CPU to get a value. In case of single pointers, first the address of the variable is fetched and then again, the value variable is fetched from that specific memory address. In case of double pointers, it makes three trips to the RAM before it gets the value of the variable. So, longer the chain, the more time it will take to fetch the variable.
Let's take the previous scenario. Instead of providing direct address to your house, you text your friend the address of your local grocery store, there a man hands him the address to your nearest rail station, there someone gives him the address to your house, This will surely take longer time, instead if he was given direct address to your house.
That's all folks, hope this article gives you "yet another" viewpoint towards pointers. Pointers are often misunderstood by a lot of newbie programmers. When broken down to its basics, they are really simple and easy to grasp.
Top comments (6)
You mention secondary memory, but (1) never say what it is; and (2) never mention it again. So why mention it at all?
No, it simply stores an address. That address doesn't need to belong to a variable:
ppoints to an
intin memory, but that
intisn't a variable in the same sense as
pitself in that it doesn't have name.
u.coccupy the same address.
pis declared as a pointer without using
Strictly speaking, C's declaration syntax is that you write some base type (like
int), then you write an expression yielding that type. So for
int *p, what you're really saying is that the "expression"
pitself must be a pointer to
int. It's declaration by inference.
This article is written keeping beginners in mind. C can be very complex at times. So to keep things simple, I did skip a lot of stuff and focused only in bare basics. None the less, I find your comment extremely helpful and informative.
You can both keep things simple and correct. They're not mutually exclusive. For example, I would describe a variable as:
I would describe a pointer declaration as:
The other way to write simple posts is to say something, but include a note saying that the thing you just said isn't strictly true, but will do for now.
Great explanation and in-detail 👍🏻
By the way:
That's simply not true. For example, consider this. Even though
*pis in a loop, the compiler reads the value once and is clever enough to convert the loop into a multiplication. Even in a simpler case like:
the compiler will still read from
*ponly once because it assumes that there are no data races. (If your program is single-threaded, then there can't be any data races; if your program is multi-threaded and there are data races, then your program has undefined behavior and the compiler isn't responsible.)
I don't know where you got the idea that reading from a pointer requires multiple trips to RAM; but in the future, I respectfully suggest that perhaps you should really be 100% sure about a topic before writing about it and spreading incorrect information.