具有继承父级函数的 C++ 类模板

Question

Lets assume this class using C++14 (and QtRO system in origin). https://pastebin.com/EVT4XJiz

#include <iostream>
#include <functional>
#include <memory>
 
class QTRO_1Source {
public:
    void hvEnabledChanged(bool) {};
    virtual bool hvEnabled() const = 0;
};
 
class QTRO_1SimpleSource : public QTRO_1Source {
public:
    bool hvEnabled() const override { return false; }
};
 
class QTRO_1 : public QTRO_1SimpleSource {
public:
    void write_hvEnabled(bool/*enabled*/) { }
};
 
 
template<typename ReplicaType, typename ValueType>
class ProxyProperty
{
public:
    using ReadFuncPtr = ValueType (ReplicaType::*)() const;
    using WriteFuncPtr = void (ReplicaType::*)(ValueType);
    using ChangeSigFuncPtr = void (ReplicaType::*)(ValueType);
    using UpdateHandlerFunctor = std::function<void(ValueType value)>;
    ProxyProperty(ReplicaType *replica,
                  ReadFuncPtr readFunc,
                  WriteFuncPtr writeFunc,
                  ChangeSigFuncPtr changeSignal,
                  UpdateHandlerFunctor updateHandler)
    {
        m_replica = replica;
        m_readFunc = readFunc;
        m_writeFunc = writeFunc;
        m_changeSignal = changeSignal;
        m_updateHandler = updateHandler;
    }
    template<typename T, typename HandlerT>
    void write(T value, HandlerT handler) {
        (m_replica->*m_writeFunc)(value);
    }
private:
    ReplicaType *m_replica;
    ReadFuncPtr m_readFunc;
    WriteFuncPtr m_writeFunc;
    ChangeSigFuncPtr m_changeSignal;
    UpdateHandlerFunctor m_updateHandler;
    int m_timeout{3000};
};
 
template<typename ReplicaType, typename ValueType, typename UpHandlerT>
auto createProxyProperty(ReplicaType *replica,
                         ValueType (ReplicaType::*readFunc)() const,
                         void (ReplicaType::*writeFunc)(ValueType),
                         void (ReplicaType::*changeSignal)(ValueType),
                         UpHandlerT upHandler)
{
    return std::make_unique<ProxyProperty<ReplicaType,ValueType> >(replica, readFunc, writeFunc, changeSignal, upHandler);
}
 
int main(int argc, char *argv[]){
    QTRO_1 model;
//    static auto p = createProxyProperty<QTRO_1, bool>(
    static auto p = createProxyProperty(
                &model,
                &QTRO_1::hvEnabled,
                &QTRO_1::write_hvEnabled,
                &QTRO_1::hvEnabledChanged,
        [](auto val) { std::cout<< "COSTAM"; }
    );
}

Now, when I'm using it with first line (giving both types) - it works. When I move type deduction on compiler - I receive this error error.

error: no matching function for call to 'createProxyProperty(QTRO_1*, bool (QTRO_1SimpleSource:: )() const, void (QTRO_1:: )(bool), void (QTRO_1Source::*)(bool), main(int, char**)::<lambda(auto:1)>)' 76 | );

Yes, all 3 methods are from different class in inheritance tree ( QTRO_1 from QTRO_1SimpleSource from QTRO_1Source ). I could - of course - wrap those methods in std::function.
I would like to make compiler deduce types for me. How to do it?

PS: Added minimal reproduction code.

Answer 1

ReplicaType gets deduced from 4 different arguments, and the results of deduction are conflicting. See compiler output:

note: candidate template ignored: deduced conflicting types for parameter 'ReplicaType' ('QTRO_1' vs. 'QTRO_1SimpleSource')

You can workaround it by employing 3 additional template parameter for class types in 2-4 function parameters:

template<typename ReplicaType, typename ValueType, typename UpHandlerT,
         class C1, class C2, class C3>
auto createProxyProperty(ReplicaType *replica,
                         ValueType (C1::*readFunc)() const,
                         void (C2::*writeFunc)(ValueType),
                         void (C3::*changeSignal)(ValueType),
                         UpHandlerT upHandler)
{
    return std::make_unique<ProxyProperty<ReplicaType,ValueType> >(replica, readFunc, writeFunc, changeSignal, upHandler);
}

See full example here .