Is it wrong to dereference a pointer to get a reference?

Question

I'd much prefer to use references everywhere but the moment you use an STL container you have to use pointers unless you really want to pass complex types by value. And I feel dirty converting back to a reference, it just seems wrong.

Is it?

To clarify...

MyType *pObj = ... MyType &obj = *pObj; 

Isn't this 'dirty', since you can (even if only in theory since you'd check it first) dereference a NULL pointer?

EDIT: Oh, and you don't know if the objects were dynamically created or not.

Answer 1

Ensure that the pointer is not NULL before you try to convert the pointer to a reference, and that the object will remain in scope as long as your reference does (or remain allocated, in reference to the heap), and you'll be okay, and morally clean :)

Answer 2

Initialising a reference with a dereferenced pointer is absolutely fine, nothing wrong with it whatsoever. If p is a pointer, and if dereferencing it is valid (so it's not null, for instance), then *p is the object it points to. You can bind a reference to that object just like you bind a reference to any object. Obviously, you must make sure the reference doesn't outlive the object (like any reference).

So for example, suppose that I am passed a pointer to an array of objects. It could just as well be an iterator pair, or a vector of objects, or a map of objects, but I'll use an array for simplicity. Each object has a function, order, returning an integer. I am to call the bar function once on each object, in order of increasing order value:

void bar(Foo &f) {     // does something }  bool by_order(Foo *lhs, Foo *rhs) {     return lhs->order() < rhs->order(); }  void call_bar_in_order(Foo *array, int count) {     std::vector<Foo*> vec(count);  // vector of pointers     for (int i = 0; i < count; ++i) vec[i] = &(array[i]);     std::sort(vec.begin(), vec.end(), by_order);     for (int i = 0; i < count; ++i) bar(*vec[i]);  } 

The reference that my example has initialized is a function parameter rather than a variable directly, but I could just have validly done:

for (int i = 0; i < count; ++i) {     Foo &f = *vec[i];     bar(f); } 

Obviously a vector<Foo> would be incorrect, since then I would be calling bar on a copy of each object in order, not on each object in order. bar takes a non-const reference, so quite aside from performance or anything else, that clearly would be wrong if bar modifies the input.

A vector of smart pointers, or a boost pointer vector, would also be wrong, since I don't own the objects in the array and certainly must not free them. Sorting the original array might also be disallowed, or for that matter impossible if it's a map rather than an array.