Thread: Initializing pointers always necessary?

I'm not too keen on initializing to NULL if I can help it; it seems to me that there is a lot of opportunity for things to go wrong if my code expects my pointers to have a value, and instead they're pointing to nothing/NULL. Am I correct in this concern?

When you don't initialize a pointer and then try to use it, you have 3 problems:

- It might be pointing at memory you don't have access to, in which case it causes a segmentation fault and crashes your program
- It might be pointing at real data, and if you don't know what it's pointing to, you're causing unpredictable (and very hard to debug) changes to your data.
- You have no way of knowing if it's been initialized or not - because how do you tell the difference between a valid address and the address that happened to be there when you declared the pointer?

Initializing every pointer to NULL seriously decreases or eliminates those problems:

- If I try and use it, it will still segfault, but at least I can test if it's NULL and act accordingly - I can know that it WILL segfault, and do something else. If it's a random value, I don't know anything until it crashes.
- If you initialize it to NULL, I can't make it point to data unless I explicitly tell it to. So I only modify what I meant to.
- As implied above, I can tell when I've initialized it and when I haven't, and make a decision.

Obviously it's a matter of style, and it is possible to write an application where variables are only initialized to their intended value, but I feel it is safer and easier to initialize them to NULL always. Even the best programmers make typos - NULL makes it easier to know when that's happened.

That was very instructive, Sean. Thanks.

>> Obviously it's a matter of style, and it is possible to write an application where variables are only initialized to their intended value, but I feel it is safer and easier to initialize them to NULL always.

I followed your advice and initialized my pointers to NULL, and indeed found that I can still use them normally in my code without errors. However, I'm confused by your comment, "If I try and use it, it will still segfault..." -- are you saying that if the pointers are used *incorrectly* in the code, after they've been initialized to NULL, it will cause a segfault?

I don't initialize FILE pointers to anything, before they're assigned their value from fopen().

Where you can get into trouble is with stuff like:

Code:

int *pint;

//some other code.
//more code

*pint = 15;

Because you forgot that *pint was never given a valid address.

Making an assignment of a pointer to null, is no help (to me, so far) - the program is still not going to work reliably, until you make the CORRECT assignment. All before you dereference the pointer.

>> If you do want to initialise them anyway, yet cannot initialise them with the values that they are supposed to have, then for pointers NULL is a reasonable value. Random "characters, or numbers" would be unreasonable.

Thanks for the clarification, laserlight. Some of the examples I came across seemed to initialize pointers to arbitrary variable addresses within the code (e.g. fid1 = &myval1), which was confusing to me.

>> Making an assignment of a pointer to null, is no help (to me, so far) - the program is still not going to work reliably, until you make the CORRECT assignment.

I don't mean to be obtuse, but can you clarify what you mean by the "correct" assignment? I read your post as saying that, as long as I'm only using file pointers in the way I stated, there is no need to initialize them to NULL... if so, would you consider my pointers to be "correctly" assigned?

are you saying that if the pointers are used *incorrectly* in the code, after they've been initialized to NULL, it will cause a segfault?

When I say used, I mean dereference. Anytime you dereference a NULL pointer, you're going to get a segfault, because you're accessing memory you shouldn't access. It's the same situation when you try and accesses memory addresses that aren't allocated to your program.

>> Anytime you dereference a NULL pointer, you're going to get a segfault

Ok, so as long as I use and assign value to each of my initialized-to-NULL pointers, I will have no problem dereferencing them at the end of my code. After initializing my pointers to NULL, my code seems to run fine with my calls to fclose( ) [although this initialization unfortunately hasn't fixed my buggy values].

Right. As someone mentioned, earlier, a lot of code is written to expect NULL to mean an uninitialized value. A function might do this:

Code:

int doSomething(int* x) {
    if(x == NULL) {
        return ERROR_CODE;
    }
    ...
    // do something with x
    ...
    return SUCCESS;
}

If the function is passed a NULL, it knows that you've done something you shouldn't have done (you passed a pointer with the value NULL, rather than a real, intentional value), and so it cane return an error and fail gracefully. If it was passed a random value or other invalid pointer, it would try and do something with it, segfault, and crash the entire program.

Thanks, Elysia. That was a very straightforward analysis.

a) for my FILE pointers, how do I correctly initialize these?
Yes, of course just like you need to correctly initialize other type variables.

b) Is there anything different/additional that I need to do when I'm done using these initialized pointers, beyond calling fclose( )? I read in one place that you're supposed to set the pointers to 0 after calling fclose( ), but am not sure if this is true, and if true, I'm wondering about the correct syntax for this.
No, it's not necessary to set to 0 after calling fclose().
File pointer are just pointer. assignment operator(=) is all you need.