a pointer to a reference

[asdf]

C++ allows a reference to a pointer, but doesn't allow a pointer to a
reference, why?

[Kaz Kylheku]

Gianni Mariani wrote:

asdf wrote:

C++ allows a reference to a pointer, but doesn't allow a pointer to a
reference, why?

References are special beasts in that they may or may not take storage.

.... an attribute which they share with constants and lexical variables.

From an implementation perspective, it's impossible to point to
something that takes no storage.

That's completely irrelevant, since you can point to constants and
variables. When you take their address, the language implementation
ensures that something exists that allows the pointer to be
instantiated. I.e. it has to defeat certain optimizations from taking
place.

The same could be arranged for a pointer-to-reference mechanism.

The real reason why there isn't one is that it would be close to
useless, and supporting it would require additional syntax and
semantics to be present in references, which would basically reduce
them to having some of the functionality of pointers which they
deliberately do not have.

The best you can do is create a struct that contains a reference (and
hence storage) and point to it.

Wait a minute, didn't you say that references may not take storage? Doh!

[Marcus Kwok]

Kaz Kylheku <kk******@gmail .comwrote:

Marcus Kwok wrote:

>I tend to disagree. Once a reference has been seated, any use of it
really refers to the referenced object, so (p_ref = &ref_i) really means
(p_ref = &i), so it is a pointer to the referenced object, but not
really a pointer to the actual reference. Though, this may be splitting
hairs, and I can see how your interpretation can be seen as correct too,
since a reference doesn't really exist on its own.

Of course a reference exists on its own.

I contend that a reference can't exist without something to refer to.

Now a reference is simply an alias
for another variable, so p_ref==p,

This I agree with.

That is only an optimization.

I was just confirming the actions of the (snipped) code.

In the general case, references are real
run-time entities. They just aren't integrated into the type system as
first-class objects, that's all.

Yes.

Many situations require references to
occupy memory locations.

Right, but AFAIK the Standard does not.

In these examples, references must correspond to something in the
run-time:

extern int &return_referen ce(void);

If a reference isn't real, how does the above function return
something? If it was inlined, then the reference could disappear, but
how can that happen under an external call? The function can return the
location of some arbitrary object. That location can be captured by the
caller, who can then modify that object. The function can choose a
different object each time you call it; and the object can even be
dynamically allocated.

OK, but in each case, you have the reference and the thing it refers to.
The objects can exist without the references, but the references cannot
exist without the objects.

How about:

struct s {
int &r;
};

If a reference isn't real, shouldn't sizeof(s) be 1? How will the
program retrieve the member r from an arbitrary struct s? There could
be millions of dynamically allocated instances of struct s, all with
different references r.

The compiler cannot account for these with a compile-time alias trick.

OK, but I would consider this an implementation detail.

--
Marcus Kwok
Replace 'invalid' with 'net' to reply