Re: Linked list of references
er <er.ci.2020@gmail.com> wrote in
news:e6887c2a-99fb-4c07-a3a3-9cfaeaae9814@n1g2000yqm.googlegroups.com:
The lifetime prolonging rule only holds for the lexical scope of the
const reference, the class data member won't work. If you think how
the compiler writer should implement it, then you will understand the
reasons (hint: temporaries live on stack).
You have convinced me. We should still be able to prolong references
to -1, 2, -3 below
list2<T> l2 = list0<T>( -1 )( 2 )( -3 );
With numeric literals it is worse: they are rvalues and one cannot create
direct pointers or references to rvalues, so this means even more
temporaries which all get destroyed too soon.
since they are in the scope of l2. So then while replacing
struct tail_holder
{
T const& tail_;
};
by
struct tail_holder
{
T const tail_;
};
would be valid, there would be a dramatic increase in complexity.
Depends on what you mean by complexity. It seems you want to keep a lot
of stuff alive for longer than the language rules prescribe. C++ uses
dynamic memory for such things. For example, std::list uses dynamic
memory allocations for storing the data. If you try to avoid dynamic
memory, then the things will become very complex indeed. For example, to
make your example work properly one needs to ensure that each temporary
remains alive, by e.g. initializing a lexical scope const reference to
it:
const list0<T>& ref0 = list0<T>( x );
const list1<T>& ref1 = ref0( y );
list2<T> l2 = ref1( z );
This does not scale very well and at least in this toy case does not
offer much advantages over
int l2[] = {x, y, z};
hth
Paavo