>But it *is* the user's fault.
>The writer of the base class wrote a constructor with a template that
>uses template argument deduction for a value parameter. Outside of
>tools like `std::ref`, this makes it functionally impossible for this
>function to be instantiated with `T` as a reference type. We must
>therefore assume that the code inside that constructor *will not work*
>if `T` is a reference type.
>The writer of the derived class wants to call this constructor with a
>reference type. A thing that this constructor was written to
>explicitly disallow cannot happen and can cause it to fail.
>The desires of one user conflicts with the desires of the other. When
>user desires are conflicting, it's the users who must sort them out,
>not the language.
`std::ref` still can be instantiated with `T`(for example struct derived) as a reference type.
No conflicts occurred between users.
It is the conflict between function matching rules and passing objects by reference to the copy constructor.
#include <functional>
template <typename T>
void bindRefTest(T& value) {}
struct base {
public : base() {}
template <typename T> base(T x) {}
};
struct derived : public base {
public: derived() {}
derived(derived& that): base(that) {}
};
int main() {
derived d1;
derived d2 = d1;
auto func = std::bind(bindRefTest<derived>, std::ref(d1));
func();
return 0;
}