Re: [C++11] Initializer lists vs. 0 or 1 items
On 2011-08-25 14:31, Daryle Walker wrote:
Hi. I just started reading a copy of a C++ draft I got several months
ago (n3282.pdf, I think). I have some quick questions.
Let me mention, that this is not identical to the final draft.
1. Let's say my class can take several arguments of the same type. I
also want to take zero arguments, as a default constructor, and one
argument as a conversion.
template< typename T>
class my_complex
{
public:
my_complex() = default;
my_complex( T first );
my_complex( std::initializer_list<T> list );
//...
};
If I just use the initializer constructor, and get rid of the other
two, would I still need the braces when I use zero or one argument?
Or do I need all three constructors if I need brace-less construction
with zero or one arguments?
If you only have an initializer-list constructor, you need braces for
construction, unless this constructor is also a default constructor.
Your second form cannot be replaced by an initializer-list constructor,
if you want to constructs objects with parentheses as in
my_complex<int> ci(42);
To realize that your initializer-list constructor is also a default
constructor, just write
template <typename T>
class my_complex
{
public:
my_complex(T first);
my_complex(std::initializer_list<T> list = {});
//...
};
Let me remark that in your original description you are defining a
defaulted copy constructor, which behaves like a compiler-generated
default constructor, which does typically less than your user-provided
default constructor.
2. Maybe I missed something, or I haven't read the applicable section
yet, but what's with the
class my_class
{
public:
void f()&;
void f()&&;
};
construct? What's it do? What's it for? How does it differ from
returning a reference?
This is a class with reference-qualified member functions. It means that
you can only invoke these functions, if the object expression is an
lvalue (f()&), or an rvalue (f()&&). E.g. the expression
my_class().f()
will invoke f()&&, because my_class() is an rvalue, but given an lvalue
my_class mc, the expression
mc.f()
will invoke f()&. Ref-qualified member functions distinguish the value
category of the calling object expressions, similar to the fact that
functions with cv-qualifiers distinguish cv-qualifications of the
calling object expression.
HTH & Greetings from Bremen,
- Daniel Kr?gler
--
[ See http://www.gotw.ca/resources/clcm.htm for info about ]
[ comp.lang.c++.moderated. First time posters: Do this! ]