Re: c_str from anonymous std::string
Andrew Tomazos wrote:
On Dec 13, 12:39 am, "MikeWhy" <boat042-nos...@yahoo.com> wrote:
Goran wrote:
On Dec 12, 8:57 am, Andrew Tomazos <and...@tomazos.com> wrote:
class X
{
operator std::string(); // stringify X instance
};
void f(const char*);
X x = ...
f(string(x).c_str());
According to the C++11 standard, will the destructor of std::string
be called before or after the call to f, or is it undefined?
My understanding is that such temporaries is destroyed when
statement is finished, which, here, is after the semicolon.
It should be further noted that "string(x)" here is an explicit
C-style typecast, syntactically identical to "((std::string)x)",
followed by copy construction of std::string, creating not just one,
but *two* temporary std::string.
$ cat < test.cpp
#include <iostream>
using namespace std;
class A
{
public:
A() { cout << "d"; }
A(const A& a) : x(a.x) { cout << "c"; }
int getx() const { return x; }
int x;
};
class B
{
public:
B(int i) : x(i) {}
operator A() { A a; a.x = x; return a; }
int x;
};
void f(int x) { cout << x << endl; }
int main(int argc, char** argv)
{
B b(argc);
f(A(b).getx());
}
$ g++ test.cpp
$ ./a.out
d1
I only count one d. :)
Due to the return value optimization...
<http://en.wikipedia.org/wiki/Return_value_optimization>
What a nasty bit of business. This isn't real code, is it? Just
some contrived nastiness to astonish and dismay job applicants?
Imagine how much less embarrassed you would be if you stated it this
way:
"I think that two temporaries will be created, won't they?"
and left it at that. ;)
Enjoy,
Andrew.
Cause for my embarrassment is wholly imaginary.
The following produced:
[[
Boo::operator ZooString()const
ZooString<0013FF48>::ZooString(const char *) {Boo}
ZooString<0013FF2C>::ZooString(const ZooString &) {Boo}
Boo
]]
Note the copy construction.
//================================
//================================
#include <iostream>
#include <string>
//================================
//================================
class ZooString
{
public:
ZooString(const char * s = "")
: str(s)
{ PrintTo(std::cout, "::ZooString(const char *)") << '\n';
}
ZooString(const ZooString & r)
: str(r.str)
{ PrintTo(std::cout, "::ZooString(const ZooString &)") << '\n';
}
const char * c_str() const
{
return str.c_str();
}
std::ostream & PrintTo(std::ostream & os, const char * msg) const
{
os << "ZooString<" << (void*)this << '>' << msg
<< " {" << str << '}';
return os;
}
private:
std::string str;
};
//================================
//================================
class Boo
{
public:
Boo(){}
Boo(const Boo &);
operator ZooString() const
{ std::cout << "Boo::operator ZooString()const\n";
return "Boo";
}
};
//================================
//================================
int main(int, char**)
{
Boo hoo;
std::cout << ZooString(hoo).c_str() << '\n';
return 0;
}