Funkcja szablonu nie działa w przypadku pobierania wskaźnika od funkcji do elementu składowego

Ostatnio napisałem funkcję szablonu, aby rozwiązać niektóre powtórzenia kodu. To wygląda tak:

template<class T, class R, class... Args>
R call_or_throw(const std::weak_ptr<T>& ptr, const std::string& error, R (T::*fun)(Args...), Args... args) {
    if (auto sp = ptr.lock()) 
    {
        return std::invoke(fun, *sp, args...);
    }
    else 
    {
        throw std::runtime_error(error.c_str());
    }
}

int main() {
    auto a = std::make_shared<A>();
    call_or_throw(std::weak_ptr<A>(a), "err", &A::foo, 1);
}

Ten kod działa doskonale, dla class Aktórego wygląda tak:

class A {
public:
    void foo(int x) {

    }
};

Ale nie można skompilować dla takiego:

class A {
public:
    void foo(const int& x) {

    }
};

Dlaczego tak jest (dlaczego mam na myśli, dlaczego nie można wydedukować typu) i jak (jeśli w ogóle jest to możliwe) mogę sprawić, aby ten kod działał z referencjami? Przykład na żywo

Problem polega na tym, że masz potrącenia konfliktowe Argsmiędzy:

• R (T::*fun)(Args...)
• Args... args

Proponuję mieć kod bardziej ogólny (bez powielania pomiędzy R (T::*fun)(Args...)i
wersji const R (T::*fun)(Args...) consti inne alternatywy) z:

template<class T, class F, class... Args>
decltype(auto) call_or_throw(const std::weak_ptr<T>& ptr,
                             const std::string& error,
                             F f,
                             Args&&... args)
{
    if (auto sp = ptr.lock()) 
    {
        return std::invoke(f, *sp, std::forward<Args>(args)...);
    }
    else 
    {
        throw std::runtime_error(error.c_str());
    }
}

Argstypów nie można wywnioskować zarówno jako const&(z fundeklaracji parametrów), jak i bez odniesienia z argsdeklaracji. Prostą poprawką jest użycie dwóch oddzielnych pakietów parametrów typu szablonu:

template<class T, class R, class... Args, class... DeclaredArgs>
R call_or_throw(
    const std::weak_ptr<T>& ptr,
    const std::string& error,
    R (T::*fun)(DeclaredArgs...),
    Args... args);

Jako wadę mogę sobie wyobrazić nieco dłuższe komunikaty o błędach w przypadku złego użytkowania.

Zauważ, że Argstyp parametru szablonu jest wywnioskowany jak const int&w argumencie 3. funkcji &A::fooi wywnioskowany jak intw parametrze 4. funkcji 1. Nie pasują i powodują, że dedukcja nie udaje się.

Możesz wykluczyć czwarty parametr z odliczenia , np

template<class T, class R, class... Args>
R call_or_throw(const std::weak_ptr<T>& ptr, 
                const std::string& error, 
                R (T::*fun)(Args...), 
                std::type_identity_t<Args>... args) {
//              ^^^^^^^^^^^^^^^^^^^^^^^^^^                

RELACJA NA ŻYWO

_{PS: std::type_identityjest obsługiwany od C ++ 20; ale bardzo łatwo go wdrożyć.}