const-reference

Experimenting with this question/answer https://stackoverflow.com/a/50649120/225186 I produced what seems to be a legal recursive self referential class that implements a circular list: struct node{ int val; node const& next; }; int main(){ node s{3, {4, s}}; assert(s.val == 3); assert(s.next.val == 4); assert(&s.next.next == &s); assert(s.next.next.val == 3); } However, when I try put this as a member of a larger class I get a warning from the compiler and the behavior changes. struct A{ node n; int i; A(int a, int b) : n{a, {b, n}}{} // warning here, also tried n{a, node{b, n}} }; int main()

This question already has answers here : How come a non-const reference cannot bind to a temporary object? (11 answers) Closed 5 years ago . Why reference can not capture temporary value while const reference and rvalue reference can capture and prolong object life. In other words while two first lines are legal but third not: const string &a = string("a"); string &&b = string("b"); string &c = string("c"); // why illegal? Quoting from N1377 Bjarne in his excellent text "The Design and Evolution of C++" discusses the motivation for prohibiting the binding of an rvalue to a non-const reference

What I am trying to do is, allow a pointer, reference or constant reference to be passed with the setter function: class A{ std::string * p; std::string st; public: A():p(0) {} A& setS(const std::string& s){ std::cout<<"called with const std::string&\n"; st = s; p = &st; return *this; } A& setS(std::string& s) { std::cout<<"called with std::string&\n"; p = &s; return *this; } A& setS(std::string* s) { std::cout<<"called with std::string*\n"; p = s; return *this; } }; int main(){ std::string s; A a; a.setS(std::move(s)) //const std::string& .setS("") //const std::string& .setS(s) //std::string&

Generally this discussion is up to the local function variable only: void foo (const int &i) { // use i till foo() ends } foo(3); But, does this rule applies to the class member also ? struct A { const int &a; A () : a(3) {} // version 1 A (const int &i) : a(i) {} // version 2 }; Now A used as, { return ()? new A : new A(3) : new A(some_local_variable); } Will the contents of a remain same through out the life time of the all 3 new ly allocated A ? The C++03 standard ( Section "12.2/5 Temporary objects" ) answers your question aptly: The temporary to which the reference is bound or the

Given the following code, where x is a dangling const reference to a vanished object, and is therefore undefined behavior. auto get_vec() { return std::vector<int>{1,2,3,4,5}; } const auto& x = get_vec().back(); It seems like neither GCC 7.3 , Clang 6.0 and MSVC is able to emit a warning, even with all warnings enabled. Does anyone know if it is any way to emit a warning in these cases? Is there any difference between const auto& and auto&& in these cases? Note, if back() would return by value, it wouldn't be undefined behavior as the lifetime temporary object x is extended to function scoop.

Section 12.2.5 in C++03 says " A temporary bound to a reference member in a constructor’s ctor-initializer (12.6.2) persists until the constructor exits " So I tried following program #include<iostream> using namespace std; struct foo { foo() { cout<<"foo c'tor"<<endl; } ~foo() { cout<<"foo d'tor"<<endl; } }; struct bar { const foo &ref; bar():ref(foo()) { cout<<"bar c'tor"<<endl; } }; int main() { bar obj; } The output I get is : foo c'tor foo d'tor bar c'tor Now according to standard, temporary generated by foo() in c'tor init-list of bar's c'tor will be destroyed after bar's c'tor so foo d