Understanding const reference in assignment when constructing object

Question

Today I see this piece of code and I'm wondering to know what it is exactly doing this const reference in an assignment where a new object is created. (I don't know how to name this kind of assignments.)

std::string const& p = s.c_str(); // s is a std::string

I understand that something like std::string const& p = s; will create a reference p to s, but in the line shown we are creating a new object (using the raw pointer from std::string::c_str).

I've made a MCVE in Coliru with this:

#include <iostream>
#include <string>

void foo(std::string const& s)
{
    std::string const& p = s.c_str(); // << here
    
    std::cout << s << " " << p << " " << &s << " " << &p << std::endl;
}

int main()
{
    foo("hello");
}

And, as expected the output is showing that a new object was created:

hello hello 0x7ffdd54ef9a0 0x7ffdd54ef950

So, my question is: Is this actually doing something I'm not able to see? Does it have any problem (like a dangling reference) in the code?

I once stumbled into a Q/A where the life-time of a temporary in a const reference was discussed. To me, it was surprising to learn that the life-time is in fact until end of scope where the const reference is defined in. Does a const reference class member prolong the life of a temporary?, Returning temporary object and binding to const reference, GotW #88: A Candidate For the “Most Important const” — Scheff's Cat
– Scheff's Cat, Commented Jan 18, 2022 at 9:49

Richard · Accepted Answer · 2022-01-18 10:54:06Z

4

From std::string::c_str's documentation, it returns:

a pointer to an array that contains a null-terminated sequence of characters (i.e., a C-string) representing the current value of the string object. That is, a const char*.

So when you wrote:

std::string const& p = s.c_str();

In the above statement, the const char* that was returned on the right hand side is used to create a temporary object of type std::string using a converting constructor that takes const char* as argument.

Next, the lvalue reference p on the left hand side is bound to that temporary obect. And in doing so, the lifetime of the temporary is extended.

To answer your last question, there is no dangling reference in your program.

edited Jan 18, 2022 at 10:54

answered Jan 18, 2022 at 9:13

Richard

47k7 gold badges40 silver badges94 bronze badges

Sign up to request clarification or add additional context in comments.

5 Comments

cbuchart Over a year ago

Yes, this is what I understood too, but have no idea what happened with the reference to the temporary object, if it produced a memory leak, or so.

Richard Over a year ago

@cbuchart There is no memory leak. The lifetime of the temporary is extended as mentioned at the end of my answer.

Jarod42 Over a year ago

Without life-time extension, the problem would be dangling reference, but still no memory leaks.

Richard Over a year ago

@Jarod42 Correct.

cbuchart Over a year ago

You're right, I've updated the question with this lapse

Vlad from Moscow · Accepted Answer · 2022-01-18 09:21:20Z

3

In fact this construction

std::string const& p = s.c_str();

does not differ essentially from

std::string const p( s.c_str() );

but is more confusing.

As for the output of this statement

std::cout << s << " " << p << " " << &s << " " << &p << std::endl;

then there are outputted two different addresses. The first one is the address of the parameter s and the second one is the address of the temporary object of the type std::string created in this declaration

std::string const& p = s.c_str();

by means of the conversion constructor

basic_string(const charT* s, const Allocator& a = Allocator());

edited Jan 18, 2022 at 9:21

answered Jan 18, 2022 at 9:11

Vlad from Moscow

313k27 gold badges204 silver badges358 bronze badges

2 Comments

Jarod42 Over a year ago

"more confusing" is opinion biased ;-) On the other side, it has the advantage to be sure that no extra copies happens (for example, in case the method returns already a const reference, instead of a temporary, especially when used with auto).

Sebastian Over a year ago

Or better std::string const&& ptemp( s.c_str() ); std::string const& p = ptemp;?

Collectives™ on Stack Overflow

Understanding const reference in assignment when constructing object

2 Answers 2

5 Comments

2 Comments

Your Answer

Linked

Hot Network Questions

Collectives™ on Stack Overflow

2 Answers 2

5 Comments

2 Comments

Your Answer

Sign up or log in

Post as a guest

Linked

Related