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/