Take the 2-minute tour ×

I recently developed an interest in C programming so I got myself a book (K&R) and started studying.

Coming from a University course in Java (basics), pointers are a totally new chapter, and from what I read online it's a rather difficult concept to get your head around. Before getting to the pointer chapter I was under the impression that pointers are a major part of C and provide great benefits.

Upon reading the chapter and getting a basic idea of what pointers are and how they work, the benefits are not obvious to me.

For example (please correct me if I got this totally wrong) in the introduction of pointers in the K&R book it says that since we call by value, when passing a variable in a function call we pretty much pass a copy of the variable for the function to handle and therefore the function can't do anything to the original variable and we can overcome this with pointers.

In a later example that uses a char pointer, the book says that incrementing the char pointer is legal since the function has a private copy of the pointer. Aren't 'private copies' a reason to use pointers instead?

I guess I'm a bit confused on the whole use of pointers. If asked I can use pointers instead of using array subscripts for example, but I doubt this is the main use of pointers.

Linux and Open source programming was the main reason I got into C. I got the source code of a C project to study (Geany IDE) and I can see that pointers are used throughout the source code.

I also did a bit of searching in the forums and a found a couple of posts with similar questions. An answer was (I quote):

If you don't know when you should use pointers just don't use them.

It will become apparent when you need to use them, every situation is different.

Is it safe for me to avoid using pointers at the time being and only use them in specific situations (where the need for pointers will be apparent?)

Thanks for any input and sorry for the huge post :)

share|improve this question

11 Answers 11

up vote 4 down vote accepted

Your highlighted rule is very wise. It will keep you out of trouble but sooner or later you have to learn pointers.

So Why do we want to use pointers?

Say I opened a textfile and read it into a giant string. I can't pass you the giant string by value because its too big to fit on the stack (say 10mb). So I tell you where the string is and say "Go look over there at my string".

An array is a pointer ( well almost )

int[] and int* are subtly different but interchangable for the most part.

int[] i = new int[5]; // garbage data
int* j = new int[5]   // more garbage data but does the same thing
std::cout << i[3] == i + 3 * sizeof(int); // different syntax for the same thing

A more advanced use of pointers thats extremely useful is the use of function pointers. In C and C++ functions aren't first class data types, but pointers are. so you can pass a pointer to a function that you want called and they can do so.

Hopefully that helps but more than likely will be confusing.

share|improve this answer
Note that the code above is C++, not C. –  Billy ONeal Dec 19 '10 at 0:10
True, but the point is still valid. C would use malloc() instead of new. and printf() instead of std::cout –  EnabrenTane Dec 19 '10 at 0:12
I never said the answer was wrong. But the question is tagged c. –  Billy ONeal Dec 19 '10 at 0:12

A benefit of pointers is you when you use them in function arguments, you don't need to copy large chunks of memory around, and you can also change the state by dereferencing the pointer.

For example, you may have a huge struct MyStruct, and you have a function a().

void a (struct MyStruct* b) {
   // You didn't copy the whole `b` around, just passed a pointer.
share|improve this answer

Coming from Java, you'll have a slightly different perspective than what is presented in K&R (K&R doesn't assume that the reader knows any other modern programming language).

A pointer in C is like a slightly more capable version of a reference in Java. You can see this similarity through the Java exception named NullPointerException. One important aspect of pointers in C is that you can change what they point to by increment and decrement.

In C, you can store a bunch of things in memory in an array, and you know that they are sitting side by side each other in memory. If you have a pointer to one of them, you can make that pointer point to the "next" one by incrementing it. For example:

int a[5];

int *p = a; // make p point to a[0]
    printf("element %d is %d\n", i, *p);
    p++; // make `p` point to the next element

The above code uses the pointer p to point to each successive element in the array a in sequence, and prints them out.

(Note: The above code is an expository example only, and you wouldn't usually write a simple loop that way. It would be easier to access the elements of the array as a[i], and not use a pointer there.)

share|improve this answer
+1 for the point that the closest analog of C pointers are Java references. –  Billy ONeal Dec 19 '10 at 0:11


I'd say that this means that they are incrementing the pointer itself, which means changing the address (and therefore making it point to a different value). This could be useful if they were passed the first item of an array and want to continue in the array, but not change the values.

share|improve this answer
Man that was fast :) Kudos. –  Marcus Fritzsch Dec 19 '10 at 0:05
The '(and what it is pointing to)' comment is ambiguous - you probably need to say '(and therefore making it point to a different value)'. As it stands, it could be interpreted to mean '(and changes the value stored at the location it points to)'. –  Jonathan Leffler Dec 19 '10 at 0:06
true dat, but I think he got the point. for wiki sake i changed it –  zsalzbank Dec 19 '10 at 0:15

Ignore that answer please.

If you don't know how to use pointers, learn how to use them. Simple.

Pointers as you say allow you to pass more than one variable into a function via a pointer to it, as you have rightly observed. Another use of pointers is in referring to arrays of data, which you can step through using pointer arithmetic. Finally, pointers allow you allocate memory dynamically. Therefore advising you don't use pointers is going to severely limit what you can do.

Pointers are C's way to talk about memory addresses. For that reason, they are critical. As you have K&R, read that.

For one example of usage, see my answer to this. As I say in that answer, it isn't necessarily how you'd do it, given the question.

However, that technique is exactly how libraries like MPIR and GMP work. libgmp if you haven't met it powers mathematica, maple etc and is the library for arbitrary precision arithmetic. You'll find mpn_t is a typedef to a pointer; depending on the OS depends on what it points to. You'll also find a lot of pointer arithmetic in the slow, C, versions of this code.

Finally, I mentioned memory management. If you want to allocate an array of something you need malloc and free which deal with pointers to memory spaces; specifically malloc returns a pointer to some memory once allocated or NULL on failure.

One of my favourite uses of pointers yet is to make a C++ class member function act as a thread on windows using the win32 API i.e. have the class contain a thread. Unfortunately CreateThread on windows won't accept C++ class functions for obvious reasons - CreateThread is a C function that doesn't understand class instances; so you need to pass it a static function. Here's the trick:

    return ((CLASSNAME*)pvParam)->ThreadFunc();

(PVOID is a void *)

What happens is it returns ThreadFunc which gets executed "instead of" (actually STATICFUNC calls it) STATICFUNC and can indeed access all the private member variables of CLASSNAME. Ingenious, eh?

If that isn't enough to convince you pointers kinda are C, I don't know what is. Or maybe there's no point in C without pointers. Or...

share|improve this answer
+1 for "ignore that answer please". The "avoid use of pointers" argument is more a C++ thing, whereby one should use references where possible. –  Billy ONeal Dec 19 '10 at 0:15
@Billy yeah, but in C++ you also have std::vector for dynamic memory and new/delete for classes. So life gets so much easier. But they can still be used (PVOID = void* I believe) as in my answer with a bit of casting magic to very good effect. –  Ninefingers Dec 19 '10 at 0:19
They can be used yes, but where one doesn't need the additional power offered by pointers one is better off using the more limited construct. (I was saying that in addition to your answer, not saying your answer was wrong (though in the specific case if your answer I'd use static_cast rather than the C style cast)) –  Billy ONeal Dec 19 '10 at 0:21
And I was also adding to my answer. You're right, I should be using static_cast. Oh well, I copied it out of a very old project of mine when I first started with "all that C++ stuff"... –  Ninefingers Dec 19 '10 at 0:30

Remember that C (and the K&R book) very old, probably older than anything you've learned before (definitely ages older than Java). Pointers aren't an extra feature of C, they're a very basic part of how computers work.

Pointer theory isn't particularly hard to master, just that they're very powerful so an error will most likely crash your application, and compilers have a hard time trying to catch pointer-related errors. One of the big novelties about Java was to have 'almost' as much power as C without pointers.

So, in my opinion trying to write C avoiding pointers is like trying to ride a bike without one pedal. Yes, it's doable but you'll work twice as hard.

share|improve this answer

Considering that you're coming from a Java background, here's the simplest way to get your head around what use pointers have.

Let's say you have a class like this in Java:

public class MyClass {
    private int myValue;

    public int getMyValue() { return myValue; }
    public void setMyValue(int value) { myValue = value; }

Here's your main function, that creates one of your objects and calls a function on it.

public static void Main(String[] args) {
    MyClass myInstance = new MyClass();

    System.out.printLn(myInstance.getMyValue()); // prints 1

    System.out.printLn(myInstance.getMyValue()); // prints 2

public static void DoSomething(MyClass instance) {

The myInstance variable you declared in Main is a reference. It's basically a handle that the JVM uses to keep tabs on your object instance. Now, let's do the same thing in C.

typedef struct _MyClass
    int myValue;
} MyClass;

void DoSomething(MyClass *);

int main()
    MyClass myInstance;

    myInstance.myValue = 1;
    printf("i", myInstance.myValue); // prints 1

    MyClass *myPointer = &myInstance; // creates a pointer to the address of myInstance

    printf("i", myInstance.myValue); // prints 2

    return 0;

void DoSomething(MyClass *instance)
    instance->myValue = 2;

Of course, pointers are much more flexible in C, but this is the gist of how they work in a Java sort of way.

share|improve this answer
(*instance).myValue should probably be instance->myValue. –  Billy ONeal Dec 19 '10 at 0:23
Ah yes, for a second I thought that was C++ syntax. –  Adam Maras Dec 19 '10 at 0:25

If you are dealing with dynamically allocated memory, you have to use pointers to access the allocated space. Many programs deal with allocated memory, so many programs have to use pointers.

share|improve this answer

In this example:

int f1(int i); 

the parameter i is passed by value, so the function f1 could not change the value of variable x of the caller.

But in this case:

int f2(int* i);
int x;
int* px = &x;

Here we still pass px parameter by value, but in the same time we pass x by refference!. So if the callee (f2) will change its int* i it will have no effect on px in the caller. However, by changing *i the callee will change the value of x in the caller.

share|improve this answer

Let me explain this more in terms of Java references (as pointed out by @Greg's answer)

In Java, there are reference types (i.e. reference to a class) and value types (i.e. int). Like C, Java is pass by value, only. If you pass a primitive type into a function, you actually pass the value of the value (after all, it is a "value type"), and therefore any modifications to that value inside that function are not reflected in the calling code. If you pass a reference type into a function, you can modify the value of that object, because when you pass the reference type, you pass the reference to that reference type by value.

share|improve this answer

Pointers make it possible to dynamically dispatch code given conditions or state of the program. A simple way of understanding this concept is to think of a tree structure where each node represents either a function call, variable, or a pointer to a sublevel node. Once you understand this you then use pointers to point to established memory locations that the program can reference at will to understand the intitial state and thus the first dereference and offset. Then each node will contain it's own pointers to further understand the state whereby a further dereference can take place, a function can be called, or a value grabbed.

Of course this is just one way of visualizing how pointers can be used since a pointer is nothing more than an address of a memory location. You can also use pointers for message passing, virtual function calls, garbage collection, etc. In fact I have used them to recreate c++ style virtual function calls. The result is that the c virtual function and c++ virtual functions run at the exact same speed. However the c implementation was much smaller in size (66% less in KB) and slightly more portable. But replicating features from other languages in C will not always be advantageous, obviously b/c other languages could be better equipped to gather information that the compiler can use for optimization of that data structure.

In summary there is a lot that can be done with pointers. The C language and pointers are devalued nowadays b/c most higher level languages come equipped with the more often used data structures / implementations that you would have had to build on your own with the use of pointers. But there are always times when a programmer may need to implement a complex routine and in this case knowing how to use pointers is a very good thing.

share|improve this answer

Your Answer


