Why has an assignment operator ever done something other than its matching constructor?

Question

I read some enhancement code and came across this:

inline sparse_vector &assign_temporary(sparse_vector &v) { swap(v); return *this; } template<class AE> inline sparse_vector &operator=(const sparse_vector<AE> &ae) { self_type temporary(ae); return assign_temporary(temporary); } 

It seems that mapping all constructors to assignment operators. Excellent. But why did C ++ ever decide to get them to do different things? All I can think of is scoped_ptr?

Answer 1

why did c ++ ever let them do different things?

Because the assignment works on a fully constructed facility. In resource management classes, this means that each pointer element already points to a resource. Contrast this with the constructor, where the members have no meaning until its execution.

By the way, in the very early days of C ++ T a(b); was actually defined as T a; a = b; T a; a = b; , but it turned out to be inefficient, so the introduction of a copy constructor.

Answer 2

Note that the name "assign_temporary" means that the assignment refers to an object that is temporary and therefore can be destroyed during the assignment process. The assignment operator accepts some regular object that you might want to use later, so it cannot destroy it during the assignment. In this code, Boost "assign_temporary" is synonymous with the rvalue reference assignment operator, and the assignment operator that you showed above is standard const (lvalue), so you expect this kind of mismatch between them.

I agree, however, the assignment operator is usually implemented using a copy and swap trick (create a copy using the copy constructor, and then replace it with the copy). However, the standard already defines the automatic implementation of the assignment operator by the compiler in the absence of an explicit definition, and therefore changing the default implementation can potentially violate existing code.

Answer 3

For this reason, some classes sometimes cannot be assigned or even copied. For example, using RAII, you can create a mutex class that opens a lock, and then closes the lock when it expires. If you were allowed to copy or assign such a class, you could possibly pass it outside the scope. This can lead to bad things in the hands of bad people.