More C++ Idioms/Coercion by Member Template

= Coercion by Member Template =

Intent
To increase the flexibility of a class template's interface by allowing the class template to participate in the same implicit type conversions (coercion) as its parameterizing types enjoy.

Motivation
It is often useful to extend a relationship between two types to class templates specialized with those types. For example, suppose that class D derives from class B. A pointer to an object of type D can be assigned to a pointer to B; C++ supports that implicitly. However, types composed of these types do not share the relationship of the composed types. That applies to class templates as well, so a  object normally cannot be assigned to a   object.

There are cases where such conversions are useful, such as allowing conversion from  to. That is quite intuitive, but isn't supported without using the Coercion by Member Template Idiom.

Solution and Sample Code
Define member template functions, in a class template, which rely on the implicit type conversions supported by the parameter types. In the following example, the templated constructor and assignment operator work for any type U, for which initialization or assignment of a  from a   is allowed.

Another use for this idiom is to permit assigning an array of pointers to a class to an array of pointers to that class' base. Given that D derives from B, a D object is-a B object. However, an array of D objects is-not-an array of B objects. This is prohibited in C++ because of slicing. Relaxing this rule for an array of pointers can be helpful. For example, an array of pointers to D should be assignable to an array of pointers to B (assuming B's destructor is virtual). Applying this idiom can achieve that, but extra care is needed to prevent copying arrays of pointers to one type to arrays of pointers to a derived type. Specializations of the member function templates or SFINAE can be used to achieve that.

The following example uses a templated constructor and assignment operator expecting  to only allow copying Arrays of pointers when the element types differ.

Many smart pointers such as std::unique_ptr, std::shared_ptr employ this idiom.

Caveats
A typical mistake in implementing the Coercion by Member Template Idiom is failing to provide the non-template copy constructor or copy assignment operator when introducing the templated copy constructor and assignment operator. A compiler will automatically declare a copy constructor and a copy assignment operator if a class does not declare them, which can cause hidden and non-obvious faults when using this idiom.

Known Uses

 * std::unique_ptr
 * std::shared_ptr

Related Idioms

 * Generic Container Idioms