Three-level pointer indirection - any usages?
Author
Hi,
I've been playing around with this theory that the reason that most coders are accustomed to at max two-level pointer indirection, e.g.
void safe_delete( int** p ) {
delete *p;
*p = 0;
}
is that the "practical world" doesn't expose us to problems that require more than two-level pointer indirection.
But then again, having an intuitive grasp of multi-level pointer indirection, might embetter one as a programmer. So I thought: perhaps one could come up with practical examples of three-level pointer indirection.
So basically I'm asking; have you ever seen (or have come up with) code that practically requires something like "int*** p", assuming this is just a pointer-to-pointer-to-pointer-to-integer, and has nothing to do with arrays?
Thanks,
- Mikko
Most of the time there is a better alternative; I can't really think of a situation where this syntax is useful.
It happens, although it's not exactly common. But the first few levels will generally be wrapped up in a typedef or structure anyway, so you're still not doing it conceptually.
As for concrete examples, I can't think of anything off-hand..
As for concrete examples, I can't think of anything off-hand..
Dereferencing an element in a list of handles might be one possible use. But I'll admit that's a bit contrived.
Can't think of anything besides kSquared's example. But conceptually there isn't that much difference between single-, double- or multi-level indirection anyway.
Illco
Illco
I don't think I've ever seen more than two levels of indirection unless there was an array in there somewhere. Admittedly, I've seen some really ugly indirections involving arrays.
The only times I ever used double-indirection with pointers is when I need to pass a pointer into a creation function, and have it point to the created object, and even in that case, I tend to pass a reference to a pointer instead or a pointer to pointer, as it makes things easier to read and understand, I feel. I can't think of an example that would use triple indirection offhand.
A contrived-but-not-unreasonable example:
int * bar[BAR_SIZE]; void GetBar( int *** foo ) { *foo = bar; }
2D array of pointers is one. In fact, if you wanted to pass a the pointer to the 2D array of pointers to a function so that it would be altered to point to a different 2D array of pointers you could have quadruple indirection.
Above double indirection it becomes progressively more irritating to allocate and deallocate with nested loops and so forth though, so this is a further reason (other than the dereferencing confusion) why it is not normally done.
Above double indirection it becomes progressively more irritating to allocate and deallocate with nested loops and so forth though, so this is a further reason (other than the dereferencing confusion) why it is not normally done.
This topic is closed to new replies.
Advertisement
Popular Topics
Advertisement
