Question for defining pointer.

[Franklin Li]

Hi All,

I have below function:
//************************************************** *******
struct Tnode {
std::string word;
int count;
Tnode *next;
};

Tnode* new_Tnode(std::string const &word) {
Tnode *node = new Tnode;
node->word = word;
node->count = 1;
node->next = 0;
return node;
}
void add_word(Tnode *&root, std::string const &word) {
Tnode *node = root;
while (1) {
Tnode *&next = node->next; //?????
if (next==0) {
next = new_Tnode(word);
break;
} else
node = next;
}
}
}

.....
//************************************************** ************************
**************

What's the diffrence for "Tnode *&next = node->next;" and "Tnode *next =
node->next;" ?

The same is: why pass Tnode *&root, not Tnode *root.

I tried remove & from above 2 sentences, and the program didn't work.

Thanks.

Franklin

[David White]

Franklin Li wrote:

Hi All,

I have below function:
//************************************************** *******
struct Tnode {
std::string word;
int count;
Tnode *next;
};

Tnode* new_Tnode(std::string const &word) {
Tnode *node = new Tnode;
node->word = word;
node->count = 1;
node->next = 0;
return node;
}
void add_word(Tnode *&root, std::string const &word) {
Tnode *node = root;
while (1) {
Tnode *&next = node->next; //?????
if (next==0) {
next = new_Tnode(word);
break;
} else
node = next;
}
}
}

....
//************************************************** ************************ **************

What's the diffrence for "Tnode *&next = node->next;" and "Tnode
*next = node->next;" ?
The former makes 'next' a reference to (or alias of) the pointer node->next,
so when you change 'next' you are really changing node->next. The latter
places a copy of the address at node->next in 'next', so changing 'next' has
no effect on node->next.
The same is: why pass Tnode *&root, not Tnode *root.
Same reason. The function can change the caller's argument if it's declared
*&, but the function can only change its own copy of the caller's argument
if it's declared *.
I tried remove & from above 2 sentences, and the program didn't work.

No, it wouldn't.

DW

[David Hilsee]

"Franklin Li" <pe*******@hotmai.com> wrote in message
news:de********@netnews.net.lucent.com...

Hi All,

I have below function:
//************************************************** *******
struct Tnode {
std::string word;
int count;
Tnode *next;
};

Tnode* new_Tnode(std::string const &word) {
Tnode *node = new Tnode;
node->word = word;
node->count = 1;
node->next = 0;
return node;
}
void add_word(Tnode *&root, std::string const &word) {
Tnode *node = root;
while (1) {
Tnode *&next = node->next; //?????
if (next==0) {
next = new_Tnode(word);
break;
} else
node = next;
}
}
}

....
//************************************************** ************************ **************

What's the diffrence for "Tnode *&next = node->next;" and "Tnode *next =
node->next;" ?

The same is: why pass Tnode *&root, not Tnode *root.

I tried remove & from above 2 sentences, and the program didn't work.

TNode * next = node->next;

This declares a pointer named "next" whose value is the same as node->next.
If you change the value of next, the value of node->next will remain
unchanged. So, the line

next = new_Tnode(word);

will not affect the value of node->next, just the value of next.

However...

TNode *& next = node->next;

This declares a reference to (an alias for) node->next. Therefore, the line

next = new_Tnode(word);

will change the value of node->next, which, as far as I can tell, is what is
intended.

I don't see why the root pointer is passed to add_word by reference instead
of by value. I don't see how it would make a difference.

--
David Hilsee

[Alipha]

Franklin Li wrote:

Hi All,

I have below function:
//************************************************** *******
struct Tnode {
std::string word;
int count;
Tnode *next;
};

Tnode* new_Tnode(std::string const &word) {
Tnode *node = new Tnode;
node->word = word;
node->count = 1;
node->next = 0;
return node;
}
void add_word(Tnode *&root, std::string const &word) {
Tnode *node = root;
while (1) {
Tnode *&next = node->next; //?????
if (next==0) {
next = new_Tnode(word);
A reference is an alias for its initializer. And so, the above
statement is the same as:
node->next = new_Tnode(word);

if next was not a reference, then modifying next would not affect
node->next.
break;
} else
node = next;
}
}
}
root is never modified, and so there's no point in root being a
reference.

....
//************************************************** ************************
**************

What's the diffrence for "Tnode *&next = node->next;" and "Tnode *next =
node->next;" ?

The same is: why pass Tnode *&root, not Tnode *root.

I tried remove & from above 2 sentences, and the program didn't work.
if that explaination wasn't sufficient, please re-read your book.
Thanks.

Franklin

[RainBow]

Re-stating the said/obvious:

void add_word(Tnode *&root, std::string const &word) {
Here, "root" is a reference to a pointer. You could just have written
"(Tnode **root," instead of "(Tnode *&root,".

When I write Tnode **root, it means root is a pointer to a pointer that
can point to root ADT.

Since C++ has this poerful concept of references, it is better to use
in this case - i.e prefer a reference to a pointer than a pointer to
pointer when in C++. A reference to a pointer also makes the job easier
as you dont have to dereference the reference (references can not be
de-referenced) and you just need to write name of reference. Like,
"root" instead of "*root". Makes things easier for maintenance. :-)

One last note : you can not have the reverse way : i.e. you can not put
a pointer to a reference. So, this is wrong "root &*arg".

-Viren
Franklin Li wrote: Hi All,

I have below function:
//************************************************** *******
struct Tnode {
std::string word;
int count;
Tnode *next;
};

Tnode* new_Tnode(std::string const &word) {
Tnode *node = new Tnode;
node->word = word;
node->count = 1;
node->next = 0;
return node;
}
void add_word(Tnode *&root, std::string const &word) {
Tnode *node = root;
while (1) {
Tnode *&next = node->next; //?????
if (next==0) {
next = new_Tnode(word);
break;
} else
node = next;
}
}
}

....
//************************************************** ************************
**************

What's the diffrence for "Tnode *&next = node->next;" and "Tnode *next =
node->next;" ?

The same is: why pass Tnode *&root, not Tnode *root.

I tried remove & from above 2 sentences, and the program didn't work.

Thanks.

Franklin