Sunday 22 October 2017
c++ - Rule-of-Three becomes Rule-of-Five with C++11?
Answer
Answer
So, after watching
rel="noreferrer">this wonderful lecture on rvalue references, I thought
that every class would benefit of such a "move constructor",
template
edit and of course a "move assignment
operator", template as Philipp points out in his answer, if it has dynamically allocated
other)
members, or generally stores pointers. Just like you should have a
copy-ctor, assignment operator and destructor if the points mentioned before
apply.
Thoughts?
I'd say
the Rule of Three becomes the Rule of Three, Four and
Five:
Each class
should explicitly define exactly one
of the following set of special
member
functions:
- None
- Destructor, copy
constructor, copy assignment operator
In addition, each class that explicitly defines a destructor may
explicitly define a move constructor and/or a move assignment
operator.
Usually, one of the following sets
of special member
functions is sensible:
- None (for many simple classes where the
implicitly generated special member functions are correct and
fast)
- Destructor, copy constructor, copy assignment
operator (in this case the
class will not be movable)
- Destructor, move constructor, move assignment operator (in this case the class
will not be copyable, useful for resource-managing classes where the underlying resource
is not copyable)
- Destructor, copy constructor, copy
assignment operator, move constructor (because of copy elision, there is no overhead if
the copy assignment operator takes its argument by value)
- Destructor, copy constructor, copy assignment operator, move
constructor,
move assignment operator
Note
that move constructor and move assignment operator won't be generated for a class that
explicitly declares any of the other special member functions, that copy constructor and
copy assignment operator won't be generated for a class that explicitly declares a move
constructor or move assignment operator, and that a class with a explicitly declared
destructor and implicitly defined copy constructor or implicitly defined copy assignment
operator is considered deprecated. In particular, the following perfectly valid C++03
polymorphic base class
class C
{
virtual ~C() { } // allow subtype
polymorphism
};
should
be rewritten as
follows:
class C
{
C(const C&) = default; // Copy constructor
C(C&&) =
default; // Move constructor
C& operator=(const C&) = default; //
Copy assignment operator
C& operator=(C&&) = default; // Move
assignment operator
virtual ~C() { } //
Destructor
};
A
bit annoying, but probably better than the alternative (automatic generation of all
special member functions).
In contrast to the
Rule of the Big Three, where failing to adhere to the rule can cause serious damage, not
explicitly declaring the move constructor and move assignment operator is generally fine
but often suboptimal with respect to efficiency. As mentioned above, move constructor
and move assignment operators are only generated if there is no explicitly declared copy
constructor, copy assignment operator or destructor. This is not symmetric to the
traditional C++03 behavior with respect to auto-generation of copy constructor and copy
assignment operator, but is much safer. So the possibility to define move constructors
and move assignment operators is very useful and creates new possibilities (purely
movable classes), but classes that adhere to the C++03 Rule of the Big Three will still
be fine.
For resource-managing classes you can
define the copy constructor and copy assignment operator as deleted (which counts as
definition) if the underlying resource cannot be copied. Often you still want move
constructor and move assignment operator. Copy and move assignment operators will often
be implemented using swap, as in C++03. If you have a move
constructor and move assignment operator, specializing
std::swap will become unimportant because the generic
std::swap uses the move constructor and move assignment
operator if available, and that should be fast
enough.
Classes that are not meant for resource
management (i.e., no non-empty destructor) or subtype polymorphism (i.e., no virtual
destructor) should declare none of the five special member functions; they will all be
auto-generated and behave correct and fast.
php - file_get_contents shows unexpected output while reading a file
I want to output an inline jpg image as a base64 encoded string, however when I do this : $contents = file_get_contents($filename); print &q...
No comments:
Post a Comment