Re: auto and decltype
On 12 Mar, 01:53, "Johannes Schaub (litb)" <schaub-johan...@web.de>
wrote:
restor wrote:
Hi,
In Boost, BOOST_AUTO is simply defined in terms of BOOST_TYPEOF:
#define BOOST_AUTO(Var, Expr) BOOST_TYPEOF(Expr) Var = Expr
I already know that the relation between c++0x auto and decltype is
not so simple. But I am wondering if auto can be expressed in terms of
decltype in any (even more complex) way. E.g. does replacing keyword
auto (in the meaning of type deduction, excluding function syntax)
with:
std::remove_cv<std::remove_reference<typeof(expr)>>
always produce the same result? Given all the CV and reference
combinations. Are the 4 variables' types deduced exactly the same in:
auto x1 = expr1;
const auto x2 = exp2;
auto const& x3 = expr3;
auto && x4 = expr4;
as in:
std::remove_cv<std::remove_reference<typeof(expr)>>x1 = expr1;
const std::remove_cv<std::remove_reference<typeof(expr)>>x2 = exp2;
std::remove_cv<std::remove_reference<typeof(expr)>>const& x3 = expr3;
std::remove_cv<std::remove_reference<typeof(expr)>>&& x4 = expr4;
? If not, is there any other (even more sophisticated way) to express
the "relation" between auto and decltype?
I think there is no way to express auto with decltype, because auto may be
used like
auto *p = expression; // declarator is more complicated.
auto p = { 1, 2 }; // initializer clause is not an expression
In the last case, "p" has type initializer_list<int>.
I guess that answers my question; but it does not address my concerns
that underly the question. Wherever auto and secltype are described to
the masses, it is a short information that hides a technical details
(which is probably good), but it does not reveal some particular
features that are likely to surprise users. I wish there were an
introduction to auto and decltype that would provide the following
ingormation:
1. decltype and auto may infer different types (or at least different
"reference" and different cv).
2. auto may deduce different "reference" and different cv taht you
expect.
3. decltype may mean two different things: (a) the type that was used
when declaring a variable e.g. typeof(Type::mem), or (b) the type of
an expression e.g. typeof((Type::mem)), which are likely to render
different types. Type::mem fas different type when thought of as a
"type", and different type when thought of as an expression.
This is the list of things that I fuond surprising about these
features (the definition of "surprising" is absolutly arbitrary, but I
suppose not only me might find it surprising). I suspect that there
may be more surprises, can anyone think of one?
Regards,
&rzej
--
[ See http://www.gotw.ca/resources/clcm.htm for info about ]
[ comp.lang.c++.moderated. First time posters: Do this! ]