Velocity Reviews - Computer Hardware Reviews

Velocity Reviews > Newsgroups > Programming > C++ > Why doesn't this modify the pointer?

Reply
Thread Tools

Why doesn't this modify the pointer?

 
 
Markus Dehmann
Guest
Posts: n/a
 
      02-18-2005
I guess this is a kind of newbie question (since most pointer questions are
newbie questions).

In the program below, modify(string* s) is supposed to change the content
that s points to. But the main() function shows that nothing is changed at
all!

What am I doing wrong?



#include <iostream>
#include <vector>
using namespace std;

class Modifier{
private:
vector<string> newStrings;
public:
void modify(string* s){
string newString = "test"; // toy example,
// could be *s transformed into upper case etc.
newStrings.push_back(newString);
s = &(newStrings[newStrings.size() - 1]); // point to new string
}
};

int main(){
Modifier m;
string s = "Hello World";
m.modify(&s);
cout << s << endl; // should be "test", but is still "Hello World"
return(EXIT_SUCCESS);
}


 
Reply With Quote
 
 
 
 
Ron Natalie
Guest
Posts: n/a
 
      02-18-2005
Markus Dehmann wrote:

> In the program below, modify(string* s) is supposed to change the content
> that s points to. But the main() function shows that nothing is changed at
> all!


That's because you don't change it.

> void modify(string* s){


This function gets the pointer to the string by value.

> s = &(newStrings[newStrings.size() - 1]); // point to new string


This does exactly what you say. It makes the local variable s point to the
new string, it has no affect on the value in the calling function (main).

It's unclear what you want to do here. If you want to assign the value of
the new string into the old string in the parent you can do:

*s = newString;

Which chages what s points to (that is, the string called s in the parent).

You'll have to give us a more concise description of what you are trying to accomplish.
 
Reply With Quote
 
 
 
 
Markus Dehmann
Guest
Posts: n/a
 
      02-18-2005
Ron Natalie wrote:

> Markus Dehmann wrote:
>
>> In the program below, modify(string* s) is supposed to change the content
>> that s points to. But the main() function shows that nothing is changed
>> at all!

>
> That's because you don't change it.
>
>> void modify(string* s){

>
> This function gets the pointer to the string by value.
>
>> s = &(newStrings[newStrings.size() - 1]); // point to new string

>
> This does exactly what you say. It makes the local variable s point to
> the new string, it has no affect on the value in the calling function
> (main).
>
> It's unclear what you want to do here. If you want to assign the value
> of the new string into the old string in the parent you can do:
>
> *s = newString;


That works. The *s instead of s does the trick.

I'm surprised though, that this is valid code. I thought newString will be
destroyed at the end of the modify function:

void modify(string* s){
string newString = "test";
*s = newString;
}

It goes out of scope. So, if I say *s=newString, and access s later, from
the main() function, isn't that undefined behavior, because s points to
someting that has gone out of scope?

(I was using the weird vector (newStrings) strategy in order to avoid that,
but it seems that's not necessary?)

Thanks
Markus

 
Reply With Quote
 
Victor Bazarov
Guest
Posts: n/a
 
      02-18-2005
"Markus Dehmann" <(E-Mail Removed)> wrote...
> Ron Natalie wrote:
>
>> Markus Dehmann wrote:
>>
>>> In the program below, modify(string* s) is supposed to change the
>>> content
>>> that s points to. But the main() function shows that nothing is changed
>>> at all!

>>
>> That's because you don't change it.
>>
>>> void modify(string* s){

>>
>> This function gets the pointer to the string by value.
>>
>>> s = &(newStrings[newStrings.size() - 1]); // point to new string

>>
>> This does exactly what you say. It makes the local variable s point to
>> the new string, it has no affect on the value in the calling function
>> (main).
>>
>> It's unclear what you want to do here. If you want to assign the value
>> of the new string into the old string in the parent you can do:
>>
>> *s = newString;

>
> That works. The *s instead of s does the trick.
>
> I'm surprised though, that this is valid code. I thought newString will be
> destroyed at the end of the modify function:
>
> void modify(string* s){
> string newString = "test";
> *s = newString;
> }
>
> It goes out of scope. So, if I say *s=newString, and access s later, from
> the main() function, isn't that undefined behavior, because s points to
> someting that has gone out of scope?


The 'newString' does go out of scope. However, before it dies, its *value*
is _copied_ into the object pointed to by 's'. So, when the original object
goes out of scope and is destroyed, a copy of its value lives on.

> (I was using the weird vector (newStrings) strategy in order to avoid
> that,
> but it seems that's not necessary?)


Probably. I can't say I know what you mean by "vector strategy", but it
sounds that it wasn't necessary if you can achieve the same thing through
simple copy-assignment.

V


 
Reply With Quote
 
Karl Heinz Buchegger
Guest
Posts: n/a
 
      02-18-2005
Markus Dehmann wrote:
>
> > It's unclear what you want to do here. If you want to assign the value
> > of the new string into the old string in the parent you can do:
> >
> > *s = newString;

>
> That works. The *s instead of s does the trick.


Yep.
But your further reply shows that you haven't understood what it does.

's' is a pointer to a string.
This pointer is passed from main, and points to the string 'main::s'
(That is variable s in main).

'*s' dereferences that pointer and thus you get a hand on the string
object itself.

*s = That string object (the one in main, because this is where this
pointer points to) gets a new value.

*s = newString; In particular it gets a copy of the value in newString

>
> I'm surprised though, that this is valid code. I thought newString will be
> destroyed at the end of the modify function:
>
> void modify(string* s){
> string newString = "test";
> *s = newString;
> }
>
> It goes out of scope.


It doesn't matter.
When newString runs out of scope, its value has long been copied to the string
object where s points to (and that is the string variable s in main).

> So, if I say *s=newString, and access s later, from
> the main() function, isn't that undefined behavior, because s points to
> someting that has gone out of scope?


In that function, s always points to the same memory object. And that is the
variable s in main(). It never points to something else.

When you say:
*s = ...
you are changing the object where s points to. You are not changing where
s points to. If you want to change where s (the pointer in modify()) points
to you simply would do
s = ...

(But note: 's' in modify() is a local variable, so changing where this pointer
points to has no effect on the caller)

--
Karl Heinz Buchegger
http://www.velocityreviews.com/forums/(E-Mail Removed)
 
Reply With Quote
 
 
 
Reply

Thread Tools

Posting Rules
You may not post new threads
You may not post replies
You may not post attachments
You may not edit your posts

BB code is On
Smilies are On
[IMG] code is On
HTML code is Off
Trackbacks are On
Pingbacks are On
Refbacks are Off


Similar Threads
Thread Thread Starter Forum Replies Last Post
Why do we have to modify default IE cookie settings here? =?Utf-8?B?QW5kcmV3?= ASP .Net 2 02-22-2007 03:36 AM
why why why why why Mr. SweatyFinger ASP .Net 4 12-21-2006 01:15 PM
findcontrol("PlaceHolderPrice") why why why why why why why why why why why Mr. SweatyFinger ASP .Net 2 12-02-2006 03:46 PM
Why ant copy task modify the ownership of the files david wolf Java 1 07-22-2006 09:12 AM
Why Can I Modify A const std::vector& ??? cppaddict C++ 12 06-09-2005 04:16 PM



Advertisments