question about std::string/map

[lallous]

Hello,

I have:

std::map<std::string, std::string> m;
std::string s1;
char *p = "hello world", *p1 = "value";
(a) s1 = p;

is (a) okay if I later set "p = NULL" ? s1 would have its own copy of the
string now?

(b) m[p] = p1;

Is that okay? will that create a valid entry into the map?
Or should I use: map[s1] = "value"; ?

Btw, can someone tell me about std::string and its reference count issues?

 

[Kamil Burzynski]

std::map<std::string, std::string> m;
std::string s1;
char *p = "hello world", *p1 = "value";
(a) s1 = p;

is (a) okay if I later set "p = NULL" ? s1 would have its own copy of the
string now?

s1 will do its own copy

(b) m[p] = p1;

Is that okay? will that create a valid entry into the map?
Or should I use: map[s1] = "value"; ?

In m[p]=p1, at first string will be created with copy of p, then m[] will
get is as argument, second string will be created with copy of p1 and
then assigned to m[p]

This is equivalent:
string sp( p );
string sp1( p1 );
m[ sp ] = sp1;

Btw, can someone tell me about std::string and its reference count issues?

AFAIK std::string does not have to do reference counting (but it is
allowed to). If it does share string between its instances, it is
copy-on-write algorithm.

 

[Sharad Kala]

Hello,

I have:

std::map<std::string, std::string> m;
std::string s1;
char *p = "hello world", *p1 = "value";
(a) s1 = p;

is (a) okay if I later set "p = NULL" ? s1 would have its own copy of the
string now? Yes


(b) m[p] = p1;

Is that okay? will that create a valid entry into the map? Yes
Or should I use: map[s1] = "value"; ? No
Btw, can someone tell me about std::string and its reference count issues?

That's implementation dependent.
Say p1 and p2 are string objects and both contain the string "Sharad".
Then an implementation could use reference counting till no modifying operation
occurs on either of the strings.
Read Scott Meyers MEC++ which talks about such cases of reference counting.

Best wishes,
Sharad

 

[Kevin Goodsell]

Hello,

I have:

std::map<std::string, std::string> m;
std::string s1;
char *p = "hello world", *p1 = "value";

Don't do this. It makes use of a dangerous and deprecated language
feature - the implicit conversion of a string literal to a (non-const)
char pointer. Always use 'const char *' or 'const char *const' for
pointing to a string literal. This way the compiler will warn you if you
attempt to modify the string literal. Without it, your code will
silently invoke undefined behavior if you attempt to modify a string
literal.

(a) s1 = p;

is (a) okay if I later set "p = NULL" ? s1 would have its own copy of the
string now?

(b) m[p] = p1;

Is that okay? will that create a valid entry into the map?
Or should I use: map[s1] = "value"; ?

Btw, can someone tell me about std::string and its reference count issues?

I don't believe there are any such issues. Whether or not std::string
uses reference counting is an implementation issue, and transparent to
the programmer.

-Kevin