Pointers *&

[Yuri]

Hello,
I'm a c++'s newbie. In a BinarySearchTree data structure I found this
definition:
void insert( const Comparable & x, BinaryNode<Comparable> * & t ) const;
What does " *& " mean?
It' s a pointer to a reference? or what?
Thanks
Yuri

[Jakob Bieling]

"Yuri" <bo********@libero.it> wrote in message
news:Nq**********************@twister1.libero.it.. .

Hello,
I'm a c++'s newbie. In a BinarySearchTree data structure I found this
definition:
void insert( const Comparable & x, BinaryNode<Comparable> * & t ) const;
What does " *& " mean?
It' s a pointer to a reference? or what?

The other way round. It is a reference to a pointer, meaning that the
function 'insert' can directlt change the value of the pointer you are
passing to it.

hth
--
jb

(replace y with x if you want to reply by e-mail)

[MiniDisc_2k2]

"Yuri" <bo********@libero.it> wrote in message
news:Nq**********************@twister1.libero.it.. .

Hello,
I'm a c++'s newbie. In a BinarySearchTree data structure I found this
definition:
void insert( const Comparable & x, BinaryNode<Comparable> * & t ) const;
What does " *& " mean?
It' s a pointer to a reference? or what?
Thanks
Yuri

It's a very important feature that I've used a lot. You probably know what a
pointer is, it's the address of an object. By using the pointer, the data
inside the BinaryNode could be modified and passed back. Unfortunately, if
the function were to modify the address contained in t, that address
wouldn't be passed back. Thus, the reference (&) is needed. This allows the
address to be passed back if it is changed. Try this to demonstrate it on
yourself:

/* This results in an access violation: data space never allocated */
void Allocate(int* var)
{
var = new int;
}

int main()
{
int* a;
Allocate(a);
*a = 5; // access violation
return (0);
}

This is because the address to the new int is never passed back, so main()
has no knowledge of that new address. On the other hand:

/* This works */
void Allocate(int* &var)
{
var = new int;
}

int main()
{
int* a;
Allocate(a);
*a = 5; // works
return (0);
}

This works because of the reference. Because of the reference, main() has
the knowledge of the new address. Note this does cause a memory leak, but I
didn't worry about deleting my pointers in this simple example, as this
example is not to teach you about pointers but rather references.

--
MiniDisc_2k2
To reply, replace nospam.com with cox dot net.

[Stuart Golodetz]

"MiniDisc_2k2" <Ma******@nospam.com> wrote in message
news:Nk*****************@news2.east.cox.net...

"Yuri" <bo********@libero.it> wrote in message
news:Nq**********************@twister1.libero.it.. .

Hello,
I'm a c++'s newbie. In a BinarySearchTree data structure I found this
definition:
void insert( const Comparable & x, BinaryNode<Comparable> * & t ) const;
What does " *& " mean?
It' s a pointer to a reference? or what?
Thanks
Yuri

It's a very important feature that I've used a lot. You probably know what

a pointer is, it's the address of an object. By using the pointer, the data
inside the BinaryNode could be modified and passed back. Unfortunately, if
the function were to modify the address contained in t, that address
wouldn't be passed back. Thus, the reference (&) is needed. This allows the address to be passed back if it is changed. Try this to demonstrate it on
yourself:

/* This results in an access violation: data space never allocated */
Not here it doesn't result in an access violation, and memory for an int is
quite definitely allocated. The point is that you lose the pointer to the
memory when the function returns, so you've ended up with a memory leak.
Furthermore, the pointer passed in will be unchanged after the call, which
causes the problem you've highlighted below.
void Allocate(int* var)
{
var = new int;
}

int main()
{
int* a;
Allocate(a);
*a = 5; // access violation
*Now* there is undefined behaviour, which might or might not result in an
"access violation" (hopefully it will, but anything could happen). The
reason is that the value of a at this point is indeterminate. In other
words, you are dereferencing a pointer that points to a random place in
memory -> undefined behaviour.
return (0);
No brackets necessary around the 0:

return 0;
}

This is because the address to the new int is never passed back, so main()
has no knowledge of that new address. On the other hand:
The point in this instance is that you're modifying a local copy of a rather
than the one you passed to the function.
/* This works */
void Allocate(int* &var)
{
var = new int;
}

int main()
{
int* a;
Allocate(a);
*a = 5; // works
return (0);
}

This works because of the reference. Because of the reference, main() has
the knowledge of the new address.
To put it more precisely: Allocate now modifies the pointer you pass in
rather than a local copy of it, so the pointer a, which is local to main(),
is modified by the call (assuming, of course, that new succeeds). Thus
(assuming all went well), a points to a valid int when Allocate returns.

I know that didn't add a great deal, but I'm not sure I particularly like
the terminology "main() has the knowledge of the new address" (or even
"main() knows about the new address", I'm not into quibbling about grammar
particularly). The thing is that main(), as a C++ function, doesn't "know"
anything (it's not a living entity, right? :-)). I understand what you mean,
it's just a bit of a woolly way of putting it... :-) No offence intended,
incidentally, just trying to make it a little clearer to the OP.

HTH,

Stuart.
Note this does cause a memory leak, but I
didn't worry about deleting my pointers in this simple example, as this
example is not to teach you about pointers but rather references.

--
MiniDisc_2k2
To reply, replace nospam.com with cox dot net.

[Alex Leung]

A little mistake, it means that function 'insert' can directly change "the
pointer" itself.
"Jakob Bieling" <ne*****@gmy.net>
???????:be*************@news.t-online.com...

"Yuri" <bo********@libero.it> wrote in message
news:Nq**********************@twister1.libero.it.. .

Hello,
I'm a c++'s newbie. In a BinarySearchTree data structure I found this
definition:
void insert( const Comparable & x, BinaryNode<Comparable> * & t ) const;
What does " *& " mean?
It' s a pointer to a reference? or what?

The other way round. It is a reference to a pointer, meaning that the
function 'insert' can directlt change the value of the pointer you are
passing to it.

hth
--
jb

(replace y with x if you want to reply by e-mail)

[Mike Wahler]

Alex Leung <al**@hitogo.com> wrote in message news:3f085b86$2@shknews01...

A little mistake, it means that function 'insert' can directly change "the
pointer" itself.

Isn't that what Jakob said?

"the function 'insert' can directlt change the value
of the pointer you are passing to it."

-Mike

[Jerry Coffin]

In article <be**********@slb6.atl.mindspring.net>, mk******@mkwahler.net
says...

Yuri <bo********@libero.it> wrote in message
news:Nq**********************@twister1.libero.it.. .

Hello,
I'm a c++'s newbie. In a BinarySearchTree data structure I found this
definition:
void insert( const Comparable & x, BinaryNode<Comparable> * & t ) const;
What does " *& " mean?
It' s a pointer to a reference? or what?

Other way around. It's a reference to a pointer.

....and, in fact, a pointer to a reference isn't allowed.

--
Later,
Jerry.

The universe is a figment of its own imagination.

[Chris Ritchey]

"MiniDisc_2k2" <Ma******@nospam.com> wrote in message

/* This works */
void Allocate(int* &var)
{
var = new int;
}

int main()
{
int* a;
Allocate(a);
*a = 5; // works
return (0);
}

I had to do this today for the first time, the same program also has
me working with an array of **, as well for the first time, a very fun
program :) Anyways I have a question about *&.

lets say instead of Allocate(int* &var) it's Allocate(char* &var) and
var = new char[64]. now if a is still int* when I pass it to Allocate
I would think I would only have to pass it as Allocate((char*)a)...
however my compiler (sun's optimized compiler) is complaning and it
wants me to pass it as Allocate((char*&)a) to work. is this normal?

[Stuart Golodetz]

"Chris Ritchey" <re*****@yahoo.com> wrote in message
news:48**************************@posting.google.c om...

"MiniDisc_2k2" <Ma******@nospam.com> wrote in message

/* This works */
void Allocate(int* &var)
{
var = new int;
}

int main()
{
int* a;
Allocate(a);
*a = 5; // works
return (0);
}

I had to do this today for the first time, the same program also has
me working with an array of **, as well for the first time, a very fun
program :) Anyways I have a question about *&.

lets say instead of Allocate(int* &var) it's Allocate(char* &var) and
var = new char[64]. now if a is still int* when I pass it to Allocate
I would think I would only have to pass it as Allocate((char*)a)...
however my compiler (sun's optimized compiler) is complaning and it
wants me to pass it as Allocate((char*&)a) to work. is this normal?

Yes, it's normal. Perhaps the error message Comeau C++ gives is a little
clearer?

"ComeauTest.c", line 9: error: initial value of reference to non-const must
be an
lvalue
Allocate((char*)a);

I think this is the relevant bit from the Standard, but it really needs
someone else to clarify it, because my ability to explain lvalues and
rvalues is minimal... :-) As I understand it, an l-value is anything you can
take the address of. Beyond that, I'll leave it to someone else, because
I'll as like as not get it wrong.

"3.10-6
An expression which holds a temporary object resulting from a cast to a
nonreference type is an rvalue (this includes the explicit creation of an
object using functional notation (5.2.3))."

What I think is happening is that (char*)a [which is clearly a cast to a
non-reference type] creates a temporary char pointer [which is an rvalue]
pointing to the same address as does a. Now since you can't bind a temporary
to a non-const reference, you can't pass (char*)a as the parameter to the
function. If the function took a char pointer by value, or by
const-reference, you'd be fine.

In any case, casting like this is inherently dodgy, and you really shouldn't
be doing it. 'Nuff said.

HTH,

Stuart.

[Chris Ritchey]

> In any case, casting like this is inherently dodgy, and you really shouldn't

be doing it. 'Nuff said.

I agree, but I'm trying to build a char* from a linked link of linked
lists...
So what I'm doing is building the char*'s first for each of the inside
linked linsts, then allocating enough memory from the sum of all the
allocated char*. Thought i'd post some code just for kicks:
ComNode* current = members;
char** objGroups = new char*[numMembers];

cout << endl;
// The following loop is to generate strings for each ObjectGroup
created
// by each member, and to calculate the total size of the new
data chunk
for(int i = 0; i < numMembers, current != NULL; i++, current =
current->next)
{
objGroups[i] = (char*)current->member->StrToken();
cout << "|-------------------|" << endl;
cout << " MessageSize[" << i << "]: " << *((int*)objGroups[i])
<< endl;
cout << " NumberItems[" << i << "]: " <<
*(((int*)objGroups[i]) + 1) << endl;
messageSize += *((int*)objGroups[i]);
}
cout << "|-------------------|" << endl << endl;
// Begin Building the char*
toReturn = (int*)new char[(messageSize += 2 * SOF_INT +
SOF_GROUPTYPE + SOF_GROUPID)];
// Build the header for this char*
*toReturn = messageSize;
*(toReturn + 1) = numMembers;
data = toReturn + 2;