Thread: string reference

Let's say I have a function that takes a reference to a string, is it safe to pass a c style string to this function? Or should I use a local copy so the constructor does it's job? I tested this and it works it just seems strange that I can pass a c string to a function that wants a const std::string&.

Thanks.

Originally Posted by Kirdra

Let's say I have a function that takes a reference to a string, is it safe to pass a c style string to this function? Or should I use a local copy so the constructor does it's job? I tested this and it works it just seems strange that I can pass a c string to a function that wants a const std::string&.

Thanks.

It works because there is an implicit conversion from c-string to std::string available, and the function takes a const reference. Had the reference not been const it would not have worked. A temporary std::string is constructed, a reference to this is passed to the function, then the temporary is destructed.

Originally Posted by Mozza314

If it's a temporary that will only be available for that function, what's the harm in modifying it?

Expectations of programmers calling the function. In an argument is passed by non-const reference, the common expectation is that any changes made in the function will be visible to the caller.

Let's say we have this;

Code:

#include <string>
#include <iostream>

void set_bye(std::string &s)
{
    s = "Bye";
}

int main()
{
      char x[] = "Hello";
      std:string y("Hello");

      set_bye(x);
      set_bye(y);

      std::cout << x << '\n';
      std::cout << y << '\n';
}

So, depending on what is passed, the value passed may change in some instances but not in others.

Implicit conversions make such cases problematical.

As you say, however, there are cases where doing such things is not harmful. There is some consideration in C++0x to relaxing such restrictions.

Originally Posted by grumpy

As you say, however, there are cases where doing such things is not harmful. There is some consideration in C++0x to relaxing such restrictions.

I'm not much in C++0x, but I don't like the idea of allowing (implicit and explicit) convertion to non-const reference. It's just confusing when you see code passing some values without caring about the results. When you see a local object which is ignored later, it is easily recognisable that the programmer did it purposedly.

Well. C++0x introduces r-value references, actually, which would allow you to pass a char array to a function accepting a r-value reference for a std::string.
The idea behind it is that r-value references will only bind to temporaries, so we're essentially saying: "This is a temporary, so we don't care about its value", and so the function can steal the temporary's resources instead of copying them.
That is the only relaxing of restrictions I know of.

Sorry for this stupid question..but how is char x[] a temporary?
Borland says it is ..but it is declared in main..and how does its value still remain "Hello"
Thanks

char x[] isn't a temporary, but when you pass it to a function which does not accept a char[], then the compiler will perform an implicit conversion (if possible), and this new variable that it creates will be a temporary. So in this example, the std::string created by an implicit conversion from the char array is a temporary.

oh thanks Elysia..i get it