Not owned member variables: pointer vs reference

[giovannibotta]

Consider this:

class A {};

class B1 {
 public:
  B1(const A& a) : m_a(a) {}
 private:
  const A& m_a;
};

class B2 {
 public:
  B2(const A* a) : m_a(a) {}
 private:
  const A* const m_a;
};

I feel like the approach taken in B1 is ideal when m_a is always non nullable, while the one taken in B2 is only useful when m_a can be nullable, which also means there has to be logic to check for nullability every time m_a is used in B2.
Now let's consider:

B1 b1(A()); // legal but bad!
B2 b2(&A()); // compiler won't allow it!

I know certain compilers will complain in some cases when trying to reference a temporary, which is good, because in this case it would be a bug.
What are the guidelines on this? Is it ok to use const T& members? Can this case be mentioned?

[giovannibotta]

There is also a third way, which might be the winner:

class B3 {
 public:
  B3(not_null<const A*> a) : m_a(*a) {} // throw if null
 private:
  const A& m_a; // can never be null!
};

[thecoshman]

The choice of using T& or T* as the member is about semantics; T& is saying it is never null, T* is saying that it could be null. Is this what you are trying to ask about?

[gdr-at-ms]

In general, storing a reference as a member is going to get you into some uncomfortable situations (e.g. assignments, etc.).

[giovannibotta]

@thecoshman yes, but I think there are implications in using T* or T& as arguments/members that need to be explored, like the example about temporaries. I think this should be covered in the guidelines.

[galik]

I generally use member T& to express a permanent relationship for the lifetime of this object and use T* when the referred to object is changeable/nullable. I can't really think of an example of when these two would be interchangeable from a design perspective.

[giovannibotta]

I am more concerned about the type of the argument than the type of the member at this point. I think it should be pointed out that if a function/method retains a reference or pointer to one of its arguments, the argument should be a pointer, just to avoid temporaries being passed to it.

[hsutter]

We agree with the direction of @galik's comment.

[AndrewPardoe]

Discussed 21 Dec 2015

[AndrewPardoe]

As Bjarne suggests, potentially a new rule: Use T& for references to permanent relationships, T* for relationships that can be changed.

[AndrewPardoe]

Suggestion: A rule that says avoid non-static data members that are references. In cases like PIMPL, use const unique_ptr. If you can live with not_null, use not_null<T*>. Herb, can you PR this?

[MikeGitb]

@giovannibotta: If you want to prevent construction from temporaries, you can delete that constructor.