Pointers: What, How, and Why

[arkanion]

good question

[hodge-podge]

So why should I use them? D: I don't understand why you would use them rather than just variables. Im sure there are some very good reasons, and things you can only do when using pointers, but I can't think of any.

[Guest]

There are a lot of reasons to use pointers! In fact, they are my favorite feature in C programming. If you read the tutorial, it mentions dynamic memory allocation. That means that my program can request more memory whenever I need it, which is an extremely useful feature. Also, if a function needs to modify a variable, you need to pass a pointer to it like so:

#include <stdio.h>

void triple(int *num) {
    (*num)=(*num)*3
}

int main(void) {
    int x=5;
    triple(&x);
    printf("%d\n", x);
    return 0;
}

Running this program should print out 15. There are even more reasons to use pointers. You can definitely find more reasons if you do some research.

[DarkLordoftheMonkeys]

Pretty helpful introduction. +rep

[Bartimäus]

Good tut ! +rep

[dcs]

Gotchas:
There are some problems with pointers that can make using them dangerous:

1. If you attempt to dereference a pointer without assigning it a value, this results in, according to the C standard, "Undefined behavior". Undefined behavior is the worst kind of behavior, since this essentially means your entire program becomes undefined, and thus buggy. This kind of pointer is also known as a "wild pointer".
2. Dereferencing a NULL pointer is equally dangerous, but doesn't result in undefined behavior. Instead, the C standard mandates that this results in a segmentation fault since by definition your program is broken.
3. Obviously due to the above, passing a NULL pointer to a function that doesn't specifically document accepting NULL pointers or passing a wild pointer to any function is equally dangerous.

The standard doesn't mention "segmentation fault". It's kinda specific that dereferencing a NULL pointer is undefined behavior, isn't it?

If an invalid value has been assigned to the pointer, the behavior of the unary * operator is undefined.84)

[...]

84) Thus, &*E is equivalent to E (even if E is a null pointer), and &(E1[E2]) to ((E1)+(E2)). It is always true that if E is a function designator or an lvalue that is a valid operand of the unary & operator, *&E is a function designator or an lvalue equal to E. If *P is an lvalue and T is the name of an object pointer type, *(T)P is an lvalue that has a type compatible with that to which T points.

Among the invalid values for dereferencing a pointer by the unary * operator are a null pointer, an address inappropriately aligned for the type of object pointed to, and the address of an object after the end of its lifetime.

[whitey6993]

Possibly the most comprehensive and excellent tutorial I have seen thus far. +rep to both

[Guest]

The standard doesn't mention "segmentation fault". It's kinda specific that dereferencing a NULL pointer is undefined behavior, isn't it?

Yeah, I have to rely on Zeke to change the tutorial.

Possibly the most comprehensive and excellent tutorial I have seen thus far. +rep to both

Thanks, every +rep brings me closer to world domination.

[ZekeDragon]

The standard doesn't mention "segmentation fault". It's kinda specific that dereferencing a NULL pointer is undefined behavior, isn't it?

I researched where I got that information, and how that came about. There was quite a storm of quick research me and Guest made during this project, and it appears I simply took what Wiki said at face value instead of insisting on a direct reference from it, and misinterpreted the statement. Strange mistake, either way it's been rectified.

[se7en]

Nice tut dude, thanks a lot.