Czy można sparametryzować stałość funkcji elementu szablonu?

Question

Szablony decydują o parametryzacji sygnatury funkcji poza samą nazwą funkcji. Ale czy można również sparametryzować stałą funkcji składowej?

Trivial, minimalistyczny, bez matrycy przykład:

struct Foo { 
    Foo *  self()  { return this; } 
    Foo const * self() const { return this; } 
}; 

vs straw-man matrycy hipotetyczny:

struct Foo { 
    template<typename T> T self() std::constness_of(T) { return this; } 
}; 

Answer 1

Ale czy można również sparametryzować stałą funkcji członka?

Nie, nie możesz. Nie masz dostępu w sygnaturze funkcji do niejawnego obiektu, na który wskazuje this, więc nie można go w żaden sposób wysyłać na nim ani na szablonie. kwalifikatory cv w funkcjach składowych muszą być określone.

Aby uzyskać bardziej skomplikowane funkcje składowe, można wywołać jedno z nich (zazwyczaj non-const wywołując numer const, aby uniknąć UB), aby uniknąć powielania kodu.

---

Albo zawsze można napisać niebędącego państwem friend:

struct Foo { 
    template <class T, 
     std::enable_if_t<std::is_base_of<Foo, std::decay_t<T>>::value>* = nullptr 
     > 
    friend T* self(T& x) { return &x; } 
}; 

musimy SFINAE aby self() nie znaleziono dla niespodziewanych typów jak Wrapper<Foo>. Zauważ, że jest to znacznie dłużej niż twój oryginalny kod, więc ma to sens tylko w kontekście skomplikowanej logiki.

Czy na pewno być zabawny czy UFCS został przyjęty i teraz wszyscy napisać nasze const/innych niż const przeciążeń za pośrednictwem będącego członkiem friend ów, że nadal wywoływać jakby byli członkami.

Answer 2

Nie, ale jest obejście prosto do przodu, a może i więcej czytelny, zamiar jest jasny:

struct Foo { 
    template<typename T> 
    std::enable_if_t<std::is_const<T>::value,T> self() const { return this; } 
    template<typename T> 
    std::enable_if_t<!std::is_const<T>::value,T> self() { return this; } 
}; 

Answer 3

W a comment na inną odpowiedź Ci wyjaśnić, że

” celem jest dostosowanie constness funkcji do woli, bez konieczności duplikat kodu, gdzie nie jest to inaczej potrzebne

Poniżej jedna możliwość, wyrażająca zarówno wersje funkcji składowej const, jak i elementarną funkcję wzorcową.

Dla bardziej ogólnego przypadku należy przekazać argumenty.

Dwie alternatywy to wyrażanie funkcji składowej const pod względem funkcji składowej innej niż const lub odwrotnie. Ale jak pamiętam, wymaga to nieco brzydkiego rzucania. Albo jakąś brzydotę, nie jestem pewien (przepraszam, teraz siedzę na bardzo ograniczonym łączu internetowym).

#include <string> 

//--------------------------------------- Machinery: 

template< class Guide, class Result > 
struct With_const_like_t_ 
{ 
    using T = Result; 
}; 

template< class Guide, class Result > 
struct With_const_like_t_<Guide const, Result> 
{ 
    using T = Result const; 
}; 

template< class Guide, class Result > 
using With_const_like_ = typename With_const_like_t_<Guide, Result>::T; 


//--------------------------------------- Example usage: 

class Bork 
{ 
private: 
    std::string s_ = "42"; 

    template< class This_class > 
    static auto foo_impl(This_class& o) 
     -> With_const_like_<This_class, std::string>& 
    { return o.s_; } 

public: 
    auto foo() 
     -> decltype(foo_impl(*this)) 
    { return foo_impl(*this); } 

    auto foo() const 
     -> decltype(foo_impl(*this)) 
    { return foo_impl(*this); } 
}; 

#include <iostream> 
#include <typeinfo> 
using namespace std; 

auto main() 
    -> int 
{ 
    Bork v; 
    Bork const c; 
    v.foo() = "Hi there!"; 
    #ifdef TEST 
     c.foo() = "This assignment to `const` won't compile."; 
    #endif 
    cout << v.foo() << endl; 
}