Why pointers? (The answer)

I am actually speaking from the point of view from someone who used to think pointers were useless. They are most definately not. If you don't understand them, you have to learn, because you cannot get past the title of "Newbie" until you do.

For those of you who do not understand how pointers work, i'll try to explain.

Code:

---

#include <iostream.h>

int main(void)
{
  int *ptr; //this creates a pointer to an integer (int). The * means it's a pointer. the actual data type is: int *
  int x = 0;
  ptr = &x; //sets the pointer to the address of x.
  cout<<"stored in ptr is: "<<ptr<<endl;
  cout<<"stored in x is: "<<x<<endl;
  cout<<"stored in *ptr is: "<<*ptr<<endl; //by using * you dereference the pointer.
  *ptr = 5;
  cout<<"*ptr set to: "<<*ptr<<endl;
  cout<<"x is now: "<<x<<endl;
  return 0;
}

---

I hope that clears up somethings. Feel free to ask questions or add to what I've said. I am not a C++ guru, but I figured other people may have the same question I did: Why do we need to learn pointers?

I know I didn't cover everything, but I hope this will inspire some people to help the newbs learn more about pointers.

Well, you haven't really answered the question "Why pointers?"

yah I was thinking that. there are so many reasons that I didn't want to list them all.
here are some:
1. To alter a variables value in a function you have to pass it's address, or a pointer to it.
2. By passing a pointer to a struct/class/union you avoid placing a lot of variables on the stack. You just pass the address.
3. You use them when you want to access the value in a variable that could change throughout the program.

gah, it's harder to explain their uses than I thought it would be. A little help would be appreciated

Those three situations could all be accomplished using references, and in the general case I prefer using references.

Some times when I prefer a pointer include:
1. When storing the address of a variable and the address might be null, or you might have to change what it is pointing to later on.
2. When storing base class objects in a container to take advantage of polymorphism. References cannot be assigned, so they don't work with many types of containers.
3. When keeping track of dynamically allocated memory - since new returns a pointer and delete requires one.

Well, I learned C before C++. I don't know much about references. I started looking at them online, and they appear sort of odd to me.

Some more reasons:
-In case you want to have an OPTIONAL parameter, you can pass NULL to signal that it's not used
-If you're returning dynamically allocated memory
-If you want to use dynamic arrays
-Can sometimes be helpful in traversing arrays or parsing blocks of data
-If you don't know how to use them, you won't be able to read anybody else's code ;)

**EDIT**
References are like pointers, except easier to handle. While with pointers you need to use * to get the value pointed to, with a reference you just use the name of the reference and it automatically fetches the value for you. The only problem, is you can't point a reference in another direction. Once it's pointing somewhere, it's stuck for good ;) They're particularly useful in passing objects of structures to functions, because then you don't have to worry about creating a copy constructor or anything - like using a pointer.

**EDIT2**
Reminded by someone's post below, I thought of a couple more uses for pointers:
-Good for storing structures in STL containers (don't need to worrry about copy constructors etc)
-Useful for calling overridden virtual functions in a derived class from a pointer to the base class (polymorphism stuff).

I think of references as either an alias for an object, or if I want to get a little more technical---as a const pointer (that is, can't change what address/object it points to, but can change the value stored at the address/of the object) with some restrictions (as previously pointed out) in return for which there is an easier to use syntax.

We use pointers for the same reason we use pronouns, it would suck to have to list every single person by name every time you wanted to say "everyone". C/C++ differs from many languages in that it's pointers are "anything" pronouns, written in your machines native toung. References are prounouns written in the compilers native toung. For the record, polymorphism works just fine with references consider

Code:

---

template<class T>
std::ostream & pvec(const std::vector<T> &v, std::ostream &os) {
    os << '{';
    std::vector<T>::const_iterator i = v.begin();
    if(i != v.end()) {
        os << ' '<< *i;
        for(++i; i != v.end(); ++i) os << ", " << *i;
    }
    return os << '}';
}

int main() {
    std::vector<int> v;
    std::ostringstream oss;
    std::ofstream of;
...
    pvec(v,oss);
    pvec(v,of) << '\n';
    pvec(v,std::cout) << std::endl;
...
}

---

i got confused about references. but Hunter kind of cleared it up.

Quote:

---

While with pointers you need to use * to get the value pointed to, with a reference you just use the name of the reference and it automatically fetches the value for you.

---

i was thinking, "wouldn't it return the address or something? not the actual value?"

Let us not forget linked lists.. heavily pointer dependant and very optimal.. especially when it comes to binary search trees and stuff

There are three steps in learning C++:

1. You think that pointers are hard to understand and seem unneccesary.
2. You finally understand pointers and what they are for. You can now allocate and deallocate memory dynamically. Pointers make programming easier!
3. Finally, you realize that pointers don't need to be used much in C++. You use references to pass values to functions and STL containers to dynamically allocate memory. Your code is easy to read and very robust.

:)

I've seen pointers overused in many, many situations. For great examples, look at any code written by Bjarne Stroustrup.

Consider the program that prompts the user to input some number and calculate something with those numbers:

Programmer at step 1:

Code:

---

cout << "How many numbers do you want:";
int n;
cin >> n;
int numbers[1000];
for (int i=0; i<n; ++i)
cin >> numbers[i];
 
calculate(numbers,n);

---

Programmer at step 2:

Code:

---

cout << "How many numbers do you want:";
int n;
cin >> n;
int* numbers = new int[n];
for (int i=0; i<n; ++i)
cin >> numbers[i];
 
calculate(numbers,n);
 
delete[] n;

---

Programmer at step 3:

Code:

---

cout << "How many numbers do you want:";
int n;
cin >> n;
vector<int> numbers(n);
for (int i=0; i<n; ++i)
cin >> numbers[i];
 
calculate(numbers,n);

---

Perhaps you think that the last two are equally good, but they are not! There is a potential memory leak if you forget to delete[] the memory you allocated.
If you think it is extremly easy to remember such a thing, remember that error handling in C++ is done via exceptions, what happens if calculate() throws an exception? The level 3 example handles this, the level 2 does not.

Dude, What the heck are these pointer things you are talking about? are they a code that draws an index finger pointing at an image? ;)

The three steps rephrased:
1) You don't think pointers really have a point
2) You finally get the point of pointers and love them for their pointiness!
3) You realize that pointers really don't have a point after all :(

>>int numbers = new int[n];
You mean int *numbers? :)

Quote:

---

Originally Posted by Sang-drax

There are three steps in learning C++:

1. You think that pointers are hard to understand and seem unneccesary.
2. You finally understand pointers and what they are for. You can now allocate and deallocate memory dynamically. Pointers make programming easier!
3. Finally, you realize that pointers don't need to be used much in C++. You use references to pass values to functions and STL containers to dynamically allocate memory. Your code is easy to read and very robust.

:)

I've seen pointers overused in many, many situations. For great examples, look at any code written by Bjarne Stroustrup.

---

Have you read his book yet Sang-drax? He explains why he uses pointers instead of references so much. Basically he has said that in his belief that passing a reference should be used only to minimize the amount of data passed to a function that won't change the reference's data. And that a pointer should be used to pass data to a function that might change the data. This is so that when you make the call to a function you'll know if the data being passed in has the possibility of being different after the call.

Thantos:

I thought keyword const was what kept a function from changing values (aka data).

Code:

---

int x = 4;
change(x);
 
Version 1:
void change(int & z)
{
  z = 5;  //x now equals 5 as well eventhough reference used rather than pointer
}
 
Version 2:
void change(const int & z)
{
  z = 5; //error, z is a const reference and value/data cannot change
}
 
Version 3:
void change(int & z) const
{
  z = 5; //change() is a const function and promises not to change parameters passed in.
}
 
Version 3
void change(const int & z) const
{
  z = 5;  //okay I'm paranoid and prone to overkill, either of the const should prevent data passed in from changing, both const aren't needed. This is an error twice over.
}

---

Or am I reading your post wrong?

Exactly a const reference is ok but what the book seemed to imply was that something like:

Code:

---

void foo ( int &a )
{
  a = 5;
}

---

is less desirable then say

Code:

---

void bar (int *a)
{
  *a = 5;
}

---

Because of the function call itself:

Code:

---

int b=10;
foo ( b ); //  No idea that b won't be 10 afterwards
bar ( &b ); // Now I have an idea that b might be different afterwards

---

And for those of you who want to argue ease of use inside the functions I present:

Code:

---

void foobar (int *paraA)
{
  int &a = *paraA;
  a = 5;
}

---

After all this, I still like pointers more than references. pointers can pretty much do all that references can and more.

sure you have to use * and & more...who cares?!

Quote:

---

Originally Posted by MMD_Lynx

After all this, I still like pointers more than references. pointers can pretty much do all that references can and more.

sure you have to use * and & more...who cares?!

---

You must be on step 2 then. ;)

Seriously, though, there are plenty of things that references can do that pointers cannot, and vice versa. Both have their uses. Both have their benefits, and both have their disadvantages.

I agree with jlou. Besides, the cout << and cin >> chains wouldn't work without references. Now where would we be without those?? :)

Thanks Thantos I read the excerpt from the C++ Programing Language a long time ago but was unclear as to the reason for using a pointer instead of a refrence for function parameters. It seems the clarity of using pointers when you intend to alter the variable passed should be used consistantly throughout the programmers code.
If the value of the prameter passed to the function is not to be changed is there any reason to use a refrence to a constant instead of simply passing by value and using a simple variable.

If it's a complex structure, you don't want to have to make a copy each time you call the function; so you use a const reference.

@elad, your explanation on the use of const in Version 3 is not accurate.
The const in this context can only be used by member function of a class to make sure that its member data will not be modified.
Thus, the following will not compile

Code:

---

void foo(int & z) const
{
    // z is not modified yet compile error will
    // be issued
}

int main()
{
    int n = 7;
    foo( n );
    return 0;
}

---

But the following is the right use of const and will compile

Code:

---

class MyClass
{
public:
    MyClass()
    {
        memberData = 7;
    }

    void foo(int &nonMemberData) const
    {
        // below is legal because th const we have
        // does not affect what being passed to foo()
        nonMemberData = 5;

        // if below is uncommented it will cause compile error
        // memberData = 8;
    }

private:
    int memberData;
};

int main()
{
    int n = 10;
    MyClass myClass;
    myClass.foo( n );
    return 0;
}

---

Quote:

---

Originally Posted by Hunter2

I agree with jlou. Besides, the cout << and cin >> chains wouldn't work without references. Now where would we be without those?? :)

---

well, i do prefer printf() a little more over cout.

printf() is fine, I suppose. But then there are also those of us who DO use cout/cin. Where would WE be without references? ;)

P.S. I still like references better, just 'cause I'm lazy and find the * button incredibly hard to reach... and I run into problems with running out of names for things when I need to have a pointer, then a reference to the dereferenced pointer, for several variables....

shoulda posted this in the C programming board. then we wouldn't have this dispute (cuz C doesn't have references)

Quote:

---

Originally Posted by Thantos

Have you read his book yet Sang-drax? He explains why he uses pointers instead of references so much. Basically he has said that in his belief that passing a reference should be used only to minimize the amount of data passed to a function that won't change the reference's data. And that a pointer should be used to pass data to a function that might change the data. This is so that when you make the call to a function you'll know if the data being passed in has the possibility of being different after the call.

---

Yes I've read his book (although I don't own it) and I think that point could be valid. I think mutable reference arguments have their place though. Here's an example:

Code:

---

template<typename T>
void swap(T& a, T& b) //Here it would be cumbersome with pointers
{
a^=b^=a^=b; //Fun way to swap a and b :)
}
 
int a = 23;
int b = 234;
swap(a,b); //The intended result is clear.

---

Pointers certainly have their place, but if it is possible to use STL containers instead of new/delete, they should be used, which Stroustrup stresses in his examples.

auto_ptr<T> could be used instead, of course.

Quote:

---

Originally Posted by MMD_Lynx

shoulda posted this in the C programming board. then we wouldn't have this dispute (cuz C doesn't have references)

---

Yes, C programmers that have moved to C++ really like overusing pointers. Step 3 doesn't exist in C. :)

Quote:

---

Originally Posted by Sang-drax

Yes I've read his book (although I don't own it) and I think that point could be valid. I think mutable reference arguments have their place though. Here's an example:

Code:

---

template<typename T>
void swap(T& a, T& b) //Here it would be cumbersome with pointers
{
a^=b^=a^=b; //Fun way to swap a and b :)
}
 
int a = 23;
int b = 234;
swap(a,b); //The intended result is clear.

---

---

In fact, Stroustrup qualifies his advice by saying that non-const reference arguments should only be used when the name of the function makes it clear that they will be modified. In this case, the name "swap" makes it obvious, so at least in this case you all agree.

You might note that you can only use that swap function on numbers. It doesn't work with strings or character arrays.

Quote:

---

Originally Posted by pianorain

You might note that you can only use that swap function on numbers. It doesn't work with strings or character arrays.

---

Yes, it is certainly not the recommended way to swap anything, unless you're programming small chips with extremly little memory, in which case you'll probably want to use assembler anyway.

I completly agree that if a function name indicates that a change will take place then references are perfectly ok.

Personally I don't follow his advice on the matter and tend to use references, but thats just me. However I do understand what he is saying and why he gave that advice.

[going for another page of this thread]

Sang-drax's swap() code brought back memories of an "argument" I had with Prelude........she won.

gg

Doesn't she usally win?

>Sang-drax's swap() code brought back memories of an "argument" I had with Prelude........she won.
Does this mean that I won't have to go through the whole thing again, but with Sang-drax this time? :D Or am I doomed to be the "Undefined Behavior Gestapo"?


It's for your own good, dammit! Now get your butts into Auchwitz (Prelude style) and start analyzing algorithms.

I find that statement aesthetic, that's all. I wouldn't want to use it. In fact, I wouldn't want to define my own swap function at all, since we have std::swap.

>I find that statement aesthetic, that's all.
Sure, it looks cute, but the behavior is undefined. You can write an XOR swap correctly using comma operators and still get the one-liner feel if you want:

Code:

---

void swap ( int& a, int& b )
{
  a ^= b, b ^= a, a ^= b;
}

---

Now it's just a stylistic and obscurity issue rather than a "you're totally wrong" issue. ;)

>In fact, I wouldn't want to define my own swap function at all, since we have std::swap.
True, but many beginners end up writing their own and it's up to us to set a good example.

Quote:

---

Originally Posted by Hunter2

P.S. I still like references better, just 'cause I'm lazy and find the * button incredibly hard to reach

---

Are you using a different keyboard layout? Because I could've sworn the * was next to the & on my keyboard. :p

Assuming you're using the most common QWERTY layout, & is actually further from the right shift than *.

Frobozz, bumping threads is somewhat frowned upon here.

>>& is actually further from the right shift than *.
Bump aside, I was referring to the fact that you need to dereference the pointer to use it (unless, as has been suggested, you use a pointer and then create a reference to the dereferenced pointer). And in some cases, you have to put the dereference in (), which is also annoying and hard to read.

Before it gets closed :)

Quote:

---

Assuming you're using the most common QWERTY layout, & is actually further from the right shift than *.

---

But * is done using the middle finger and the & is done using the index finger which most hunt and peckers use :)

Of course I use my middle for & a lot but I don't claim to have good form.

Actually I use the index finger for * too. Better reach. But in some cases, I actually use rightshift and the left hand to press the button (don't ask me why), so & is really closer than *.
[edit]And besides, it's not good form to use the same hand for shift and a key anyway. You're supposed to use the shift for the opposite hand that you're pressing the key with ;) So if you use proper form, the & and * should be very similar in distance.[/edit]

It's those damn x-or's you gotta reach for.

gg

It's not so bad with Rshift-left index...

>It's those damn x-or's you gotta reach for.
But how often do you really need it? ;)

Maybe that's why it's so hard ;)

Just thought it was ironic...

man...i wanted this post to help eliminate those...why don't these people do at least SOME research before posting...*crowds stares at Lynx with a look that says, "hypocrite..."* uh...

Stroustroup has a point about pointers (pun NOT intended - I don't make such bad puns), but I still prefer using non-const references, because they can't be NULL. I think that's an extremely important point.
Also, if it's ok to use references if the function name makes clear that the argument will be modified, then you always use references because function names that don't make it clear that the argument will be notified are bad function names. IMHO.

>>but I still prefer using non-const references, because they can't be NULL.
That's actually one of the points in favour of pointers (echo CornedBee about puns). If you want an optional argument, it's convenient to have a default argument of a NULL pointer rather than have a reference and a set of argument validation flags.

IF you want an optional argument. Often, I don't, and then I want the security of not dereferencing a NULL pointer without having the runtime cost of checking for one.

Quote:

---

I want the security of not dereferencing a NULL pointer without having the runtime cost of checking for one.

---

Good point. And extending that, if arguments aren't optional, it'll help with debugging because passing NULL for a reference will give you a compile-time error (unless you really really try to get around that) and line number rather than a runtime exception/error. But if you DO want optionals, pointers can still be useful.

Code:

---

void somefunc(int& num)
{
  ++num;
}

somefunc(*(int*)NULL); //Perhaps that would compile?

---

It would compile and yield undefined behaviour. But seriously, if someone does this it's his own fault.

Hence "(unless you really really try to get around that)" :) And in conclusion, use references mostly, but pointers are OK when they make sense.