Re: Constrained Forwarding(R-Value Reference)
Pedro Lamarao wrote:
lt& doesn't mean "reference to copyable", it means "reference to
lvalue".
As i can understand, temporary can not be assigned to "non-const
reference"
only due to the reference can be passed out of the temporary scope and
writing into non-existing stack of the terminated function for some
people
looks like more dangerous when reading from the non-existing memory or
calling functions with random entry point, that can be done with the
temporary assigned to "const reference".
This may have been the rationale for for the current rules for
reference binding.
The rationale being accepted the rules were set.
The current working paper has new syntax for references.
References declared with this new syntax have binding new rules.
I have said, that differences between "reference to lvalue of type" and
"reference to rvalue of type" has been introduced not due to existence of
"rvalue data type" or due to there are any real important noticable
differences between "reference to lvalue of type" and "reference to rvalue
of type", but only due to possible writing into wrong memory via "reference
to temporary".
I am sure and have listed some concrete arguments, that term "reference" and
its semantics is alredy well defined in C++, does not need to be replaced by
any other stuffs, at least in order to support moveable semantics.
These new rules, governing this new syntax, do allow for temporaries
to be bound to references.
This is really different questions between "temporaries to be bound to
references" and "existence of moveable data type".
It has been found that these new rules satisfy the desire for
expressing Moveable.
It is very shallow explanation ( somewhere somebody has found something ),
especially when concrete opposite agruments have been listed by me, that
these "new rules" _can not_ satisfy the desire for expressing Moveable.
You seem to disagree and we seem to not understand why.
This is really different questions between "temporaries to be bound to
references" and "existence of moveable data type".
I am sure and have listed some concrete arguments, that "term reference" and
"semantics of reference" is alredy well defined in C++, does not need to be
replaced by any other stuffs, _at least_ in order to only support moveable
semantics.
If we want to completely support "moveable data type and semantics" we must
"change direction" of "r-value reference" proposal.
You are telling me that "T const&" requires T to be Copyable.
If this is true, how can the following code be valid?
class resource {
public:
resource ();
private:
resource (resource const&);
resource& operator= (resource const&);
};
Here the class "resource" has been declared as non-copyable, but probably as
moveable, only if compiler can do auto generation of "move constructor:
resource (moveable resource const&)" (as for "copy constructor" do), else
the class "resource" as well non-copyable as non-moveable.
template <typename T>
void
foo (T const& t) { }
Here the function "foo<>" has no body and is declaring "t" is to be
copyable, but never used the fact.
void
f () {
resource r1;
foo(r1);
assuming
foo<resource>(r1);
Here "probably-moveable resource" has been passed as "reference to const
copyable", and it is correct, due to "foo<>" does not used the requirement
of "t" is to be copyable.
}
***
I think we need to allow explicit declarations of parameter of template or
function is to be exactly copyable or moveable?
template <test typename T>void foo (T const& t);
template <test moveable typename T>void foo (T const& t);
class T;
void foo (test T const& t);
void boo (test moveable T const& t);
Here compiler will test that concrete concrete "T" has public copy/move
ctor. It makes declarations more clear and more independent from its
implementation:
template <test typename T>
void
foo (T const& t);
it is the same as
template <typename T>
void
foo (test T const& t);
Here your example
foo<resource>(r1);
will not be compileable, due to "resource" is non-copyable.
--
Maksim A. Polyanin
http://grizlyk1.narod.ru/cpp_new
---
[ comp.std.c++ is moderated. To submit articles, try just posting with ]
[ your news-reader. If that fails, use mailto:std-c++@ncar.ucar.edu ]
[ --- Please see the FAQ before posting. --- ]
[ FAQ: http://www.comeaucomputing.com/csc/faq.html ]