While deducing this can be useful in some scenarios, it is prone to misuse. A simplified case is as follows:
template <typename T>
class Container {
public:
// …
template <typename Self>
auto data(this Self&& self) noexcept
{
return self.data_;
}
private:
T* data_;
};
Generally you want the data() member function to give you a const T* on a const container, but this implementation will always give you T*.
I nearly wrote such code in an article, and I actually saw similar code in a recently published C++ book.
I think a utility function (as well as education materials) is useful in such cases. Modelling forward_like, probably something like:
template <typename T, typename U>
constexpr auto forward_pointer_like(U* ptr)
{
constexpr bool is_adding_const =
is_const_v<remove_reference_t<T>>;
if constexpr (is_const_v<remove_reference_t<T>> !=
is_adding_const) {
if constexpr (is_adding_const) {
return const_cast<const U*>(ptr);
} else {
return const_cast<remove_const_t<U>*>(ptr);
}
} else {
return ptr;
}
}
Related idea: Should we just update as_const to make it generate a const T* given a T*? This could be an easy fix that allows us to simply use forward_like, but I am not sure whether it can break things.
What do you think? Did I miss something already existing in the standard?
--
Yongwei Wu
URL:
http://wyw.dcweb.cn/