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.