temporary

Consider this: std::string foo(); void bar() { const std::string& r1 = foo(); static const std::string& r2 = foo(); } I know that the lifetime of the string resulting from the first call to foo() will be extended to the lifetime of r1 . What about the temporary bound to r2 , though? Will it live until the end of the scope or will it still be there when bar() is re-entered? Note: I am not interested whether a particular compiler does so. (I am interested in the one we use, and I can test easily with that.) I want to know what the standard has to say on this. The temporary is extended to the

The following scenario is given, to be interpreted as C++0x code: struct B { }; struct A { B b; }; int main() { B const& b = A().b; /* is the object still alive here? */ } Clang and GCC (trunk version as of 2011/02) behave differently: Clang lengthens the lifetime. GCC moves B to a new temporary object, and then binds the reference to that new temporary. I cannot find either behavior can be derived from the words of the Standard. The expression A().b is not a temporary (see 5.2.5). Can anyone please explain the following to me? Desired behavior (the intent of the committee) The behavior as you

Is there a convenient and functional ( with-... -like) way of temporary modifying environment variables when using shell-comand or start-process ? Thanks in advance, Per server-with-environment looks promising. server-with-environment is a Lisp macro in `server.el'. (server-with-environment ENV VARS &rest BODY) Evaluate BODY with environment variables VARS set to those in ENV. The environment variables are then restored to their previous values. VARS should be a list of strings. ENV should be in the same format as `process-environment'. process-environment is a List of overridden environment

I understand that doing something like the following: auto&& x = Matrix1() + Matrix2() + Matrix3(); std::cout << x(2,3) << std::endl; Will cause a silent runtime error if the matrix operations use expression templates (such as boost::ublas ). Is there any way of designing expression templates to prevent the compiler from compiling such code that may result in the use of expired temporaries at runtime? (I've attempted unsuccessfully to work around this issue, the attempt is here ) Is there any way of designing expression templates to prevent the compiler from compiling such code that may result

I was reading these two paragraphs of the FDIS (12.2p{4,5}): There are two contexts in which temporaries are destroyed at a different point than the end of the full-expression. The first context is when a default constructor is called to initialize an element of an array. If the constructor has one or more default arguments, the destruction of every temporary created in a default argument is sequenced before the construction of the next array element, if any. and The second context is when a reference is bound to a temporary. The temporary to which the reference is bound or the temporary that

(I asked a variation of this question on comp.std.c++ but didn't get an answer.) Why does the call to f(arg) in this code call the const ref overload of f ? void f(const std::string &); //less efficient void f(std::string &&); //more efficient void g(const char * arg) { f(arg); } My intuition says that the f(string &&) overload should be chosen, because arg needs to be converted to a temporary no matter what, and the temporary matches the rvalue reference better than the lvalue reference. This is not what happens in GCC and MSVC (edit: Thanks Sumant: it doesn't happen in GCC 4.3-4.5). In at

So I am calling a helper function, vertex_triangle , quite a bit to allow me to take in a vector<pair<T, T>> and wind them into ordered triangles, then put those in a vector in that order. I'm using this as my return object: template <Typename T> struct Triangle { Triangle(const pair<T, T>& first, const pair<T, T>& second, const pair<T, T>& third) { data[0] = first; data[1] = second; data[2] = third; } pair<T, T> data[3]; }; So my winding helper function looks like this: template<typename T> triangle<T> vertex_triangle(const size_t index, const vector<pair<T, T>>& polygon){ if (0 == index){