问题：

使用“使用声明”（模板可变编译时信号槽实现）展开非类型模板参数包

百里星纬

2023-03-14

对更好的标题有什么建议吗？

在Qt中，有一个很好的信号和插槽功能。然而，它会告诉您是否可以在运行时（afc）期间将特定信号连接到特定时隙。

意图：

从模板创建一个包含“信号签名”（函数指针作为模板参数）的类，以允许将给定签名（传递参数的数量和类型）的“插槽”仅连接到具有类似签名的“已定义”信号；

必须简单易用。

现在的问题：我在ISignalSlotMap类中遇到一个“使用声明”的编译错误。模板多变量继承与可变参数类型-在这里它编译良好。

还有，有没有什么方法可以简化模板算法？

更新：第一个块可以在没有dll的情况下编译和运行

这可以在不链接到DLL的情况下进行编译

#include <iostream>
#include <type_traits>
#include <forward_list>
#include <memory>

//template wrapper
template <typename...>
struct TW
{};


//template to get Class type from pointer
template <class ReturnType, class ... ArgTypes>
constexpr ReturnType ClassFromPointer(void(ReturnType::*)(ArgTypes...));


//template to get pack of arguments' types
template <class ReturnType, class ... ArgTypes>
constexpr TW<ArgTypes...> ArgTypesPackFromPointer(void(ReturnType::*)(ArgTypes...));

template <auto ptr>
using FuncClass = decltype(ClassFromPointer(ptr));

template <auto ptr>
using FuncPack = decltype(ArgTypesPackFromPointer(ptr));


template <class ... ArgTypes>
struct Invoker
{
    virtual void Invoke(ArgTypes ... args) = 0;
};


template <class ClType, class ... ArgTypes>
class InvokerImpl : public Invoker<ArgTypes...>
{
    ClType *ptr_;
    void(ClType::*pFunc_)(ArgTypes...);

public:
    InvokerImpl(ClType* pObj, void(ClType::*pFunc)(ArgTypes...))
        : ptr_(pObj),
        pFunc_(pFunc)
    {}

    virtual void Invoke(ArgTypes ... args)
    {
        (ptr_->*pFunc_)(args...);
    }
};

template <class ClType, class ... ArgTypes>
Invoker<ArgTypes...>* CreateInvoker(ClType* pObj, void(ClType::*pFunc)(ArgTypes...))
{
    return new InvokerImpl<ClType, ArgTypes...>(pObj, pFunc);
}

template <class Pack>
class SlotContainerTranslated;

template <template <class ...> class Pack, class ... ArgTypes>
class SlotContainerTranslated<Pack<ArgTypes...>>
{
    typedef std::unique_ptr<Invoker<ArgTypes...>> pInvoker;
    std::forward_list<pInvoker> slots_;

public:
    void AddInvoker(Invoker<ArgTypes...>* pInv)
    {
        slots_.push_front(std::move(pInvoker(pInv)));
    }

    void DispatchSignal(ArgTypes ... args)
    {
        auto start = slots_.begin();
        while (start != slots_.end())
        {
            (*start)->Invoke(args...);
            ++start;
        }
    }
};

template <auto memfuncptr>
class ISlotContainer : SlotContainerTranslated<FuncPack<memfuncptr>>
{
public:
    using SlotContainerTranslated<FuncPack<memfuncptr>>::AddInvoker;
    using SlotContainerTranslated<FuncPack<memfuncptr>>::DispatchSignal;
};


template <auto ... memfuncPtrs>
class ISignalSlotMap : SlotContainerTranslated<FuncPack<memfuncPtrs>>...
{
public:
    //  using SlotContainerTranslated<FuncPack<memfuncPtrs>>::AddInvoker...;
    //  using SlotContainerTranslated<FuncPack<memfuncPtrs>>::DispatchSignal...;

};
////////////////////////////////////////////////////////////////////////

struct AlienSignals
{
    void MindControl() {};
    void MindControlPrint(int a, double b, int c, int d, const char* str) {};
    void MindControlAdvise(int i, bool b) {};
};



struct Alien
{
    static Alien* Invade();
    virtual ISlotContainer<&AlienSignals::MindControlAdvise>& AccessSignal() = 0;

    /*//this is what usage is expected to be like
    virtual ISignalSlotMap<&AlienSignals::MindControl,
        &AlienSignals::MindControlAdvise,
        &AlienSignals::MindControlPrint>& AccessSignalMap() = 0;
        */

    virtual ~Alien() = default;
};

class AlienImpl : public Alien
{
    std::unique_ptr<ISlotContainer<&AlienSignals::MindControlAdvise>> signalMindControlAdvise_
    { new ISlotContainer<&AlienSignals::MindControlAdvise> };

    // Inherited via Alien
    virtual ISlotContainer<&AlienSignals::MindControlAdvise>& AccessSignal() override
    {
        return *signalMindControlAdvise_;
    }

    virtual ~AlienImpl() = default;
};

Alien * Alien::Invade()
{
    return new AlienImpl;
}


struct Human
{
    int id = 0;

    Human(int i)
        : id(i)
    {}

    void Print()
    {
        std::cout << "Human: " << id << "! " << std::endl;
    }

    void mPrint(int a, double b, int c, int d, const char* str)
    {
        std::cout << "Human: " << id << "! " << a << " " << b << " " << c << " " << d << " " << str << std::endl;
    }

    void Advise(int i, bool b)
    {
        auto colour = b ? "red" : "blue";
        std::cout << "Human: " << id << "! I will take " << i << " of " << colour << " pills" << std::endl;
    }
};

template <auto memfuncptr>
constexpr auto GetType()
{
    return memfuncptr;
}

template <auto memfunc>
using PtrType = decltype(GetType<memfunc>());

int main()
{
    Human person1{ 1 }, person2{ 2 }, person3{ 3 };

    std::unique_ptr<Alien>alien{ Alien::Invade() };
    alien->AccessSignal().AddInvoker(CreateInvoker(&person1, &Human::Advise));
    alien->AccessSignal().AddInvoker(CreateInvoker(&person2, &Human::Advise));
    alien->AccessSignal().AddInvoker(CreateInvoker(&person3, &Human::Advise));
    alien->AccessSignal().DispatchSignal(42, false);

    return 0;
}

UPDATE2：我发现问题在于扩展非类型模板参数包，所以“使用”可以工作。我仍然无法克服这个问题。

c非类型参数包扩展类似的问题，但与函数有关。我也找不到折叠表达式与继承的任何用法。

有一个答案显示了一种很有希望的方法：https://stackoverflow.com/a/53112843/9363996

但也有一些主要的缺点。一种是使用模板函数调用继承的函数。此示例编译并运行，但：

我不知道如何强制从模板生成方法，以防我想编译一个DLL接口；
这是非常不协调的，因为智能感知没有显示哪些参数是预期的，你必须明确指定函数指针。

例2

#include <iostream>

template <class ...>
struct TW {};

template <class ClType, class ... ArgTypes>
constexpr ClType ClassType(void(ClType::*)(ArgTypes...));

template <class ClType, class ... ArgTypes>
constexpr TW<ArgTypes...> ArgsType(void(ClType::*)(ArgTypes...));

template <auto pFunc>
using class_trait = decltype(ClassType(pFunc));

template <auto pFunc>
using args_trait = decltype(ArgsType(pFunc));

template <class, class>
struct _func_trait;

template <class ClType, template <class...> class Pack, class ... ArgTypes>
struct _func_trait<ClType, Pack<ArgTypes...>>
{
    typedef void(ClType::*FuncPtr)(ArgTypes...);
    typedef ClType ClassType;
    typedef Pack<ArgTypes...> Args;
};

template <auto pFunc>
struct func_traits : public _func_trait<class_trait<pFunc>, args_trait<pFunc>>
{};


template <auto L, class Pack>
struct ClassImpl;

template <auto L, template <class ...> class Pack, class ... ArgTypes>
struct ClassImpl<L, Pack<ArgTypes...>>
{
    void invoke(ArgTypes ... args)
    {
        (std::cout << ... << args) << std::endl;
    }
};

template <auto L, auto ...R>
class My_class;

template <auto L>
class My_class<L> : public ClassImpl <L, args_trait<L>>
{

};

template <auto L, auto ... R>
class My_class : public My_class<L>, public My_class<R...>
{
public:

    template <auto T, class ... ArgTypes>
    void Invoke(ArgTypes... args)
    {
        My_class<T>::invoke(args...);
        return;
    }

};



struct Signals
{
    void func1(int a, double b) {}

    void func2(const char*, const char*) {}

    constexpr void func3(int a, double b, int c, bool d);
};


int main()
{

    Signals s;
    My_class<&Signals::func1, &Signals::func2, &Signals::func3> mSignls;
    mSignls.Invoke<&Signals::func1>(4, 6.31);
    mSignls.Invoke<&Signals::func2>("Invoking funcion:", "function 2");

    return 0;
}

共有1个答案

俞俊逸

2023-03-14

最后我提出了解决方案，它的用法非常简单，正如我所希望的。

这是我的工作示例！

#include <tuple>
#include <iostream>

template <class ...>
struct TW {};

template <class ClType, class ... ArgTypes>
constexpr ClType ClassType(void(ClType::*)(ArgTypes...));

template <class ClType, class ... ArgTypes>
constexpr TW<ArgTypes...> ArgsType(void(ClType::*)(ArgTypes...));

template <auto pFunc>
using class_trait = decltype(ClassType(pFunc));

template <auto pFunc>
using args_trait = decltype(ArgsType(pFunc));

template <class, class>
struct _func_trait;

template <class ClType, template <class...> class Pack, class ... ArgTypes>
struct _func_trait<ClType, Pack<ArgTypes...>>
{
    typedef void(ClType::*FuncPtr)(ArgTypes...);
    typedef ClType ClassType;
    typedef Pack<ArgTypes...> Args;
};

template <auto pFunc>
struct func_traits : public _func_trait<class_trait<pFunc>, args_trait<pFunc>>
{};


template <auto L, class Pack = args_trait<L>>
struct ClassImpl;

template <auto L, template <class ...> class Pack, class ... ArgTypes>
struct ClassImpl<L, Pack<ArgTypes...>>
{
    void invoke(decltype(L), ArgTypes ... args)
    {
        (std::cout << ... << args) << std::endl;
    }
};



template <class ... Impls>
struct ISignalMap : protected Impls...
{
    using Impls::invoke...;
};

template <auto ... L>
struct SignalsMap
{
    //just to see the pointers' values
    static constexpr std::tuple<decltype(L)...> t{ std::make_tuple(L...) };
    ISignalMap<ClassImpl<L>...> Signals{};
};

struct Signals
{
    void func1(int a, double b) {}
    void func12(int a, double b) {}

    void func2(double a, double b, int c) {}

    constexpr void func3(const char*) {}
};


int main(void)
{
    auto& ref = SignalsMap<&Signals::func1, &Signals::func2, &Signals::func3>::t;

    //add SignalsMap as member to your class and pass the pointers to
    //methods you need to be signals
    SignalsMap<&Signals::func1, &Signals::func2, &Signals::func3> sm;

    //first parameter is a pointer to a signal you want to invoke
    sm.Signals.invoke(&Signals::func2, 4.8, 15.16, 23);
    sm.Signals.invoke(&Signals::func1, 23, 42.108);
    sm.Signals.invoke(&Signals::func12, 23, 42.108);

    sm.Signals.invoke(&Signals::func3, "Eat this!");

    return 0;
}

类似资料：

可变参数模板未编译

当我编译时，我得到了这些错误：
C++11可变参数模板（函数模板、类模板）

在C++11之前，类模板和函数模板只能含有固定数量的模板参数。C++11增强了模板功能，允许模板定义中包含0到任意个模板参数，这就是可变参数模板。可变参数模板的加入使得C++11的功能变得更加强大，而由此也带来了许多神奇的用法。可变参数模板可变参数模板和普通模板的语义是一样的，只是写法上稍有区别，声明可变参数模板时需要在typename或class后面带上省略号...： template<ty
使用模板模板参数进行类模板特化

我试图在类型s. t上专门化一个类。它忽略了给定类型的恒定性。在这种情况下，该类型是一个模板模板参数：上面的代码在GCC 4.8.4和clang 5.0（with-std=c 11）中都抱怨bar在与匹配FOFType模板参数化的类一起使用时未定义。即使我删除了sfinae参数，仍然无法找到特化。这个问题的一个例子可以在这里找到:https://godbolt.org/g/Cjci9C.在上面
从模板化模板类和可变模板中声明“容器”对象

我需要声明一个可以存储不同类型容器的类。也就是说，如果它能处理STD：：Bitset和STD：：Array就好了。但是，这两个类需要不同的模板参数······是否可能（以及如何）使用模板化模板类和可变模板来声明此类类？示例（但错误）：
推导（非类型）模板参数类型的编译器方差

考虑以下示例：而且，如果我们将非类型模板参数的类型改为占位符类型，如下所示：然后，GCC接受，而Clang拒绝它（两者都拒绝，如上）。海合会演示，铿锵演示。 (1)GCC HEAD 11.0.0 202 10117和Clang HEAD 12.0.0（20210118）,。
在C非类型模板参数中使用decltype（auto）

我正在学习C 17非类型模板参数的新功能。我编写了一个简单的代码片段，如下所示：据我所知，福但是，语句使用clang、MSVC 19.27编译，但在GCC 10.2、MSVC 19.25编译时失败。我的问题是：为什么编译器的行为不同？标准对此有何规定？链接到编译器资源管理器：叮当声https://godbolt.org/z/66M695 海湾合作委员会https://godbolt.or

使用“使用声明”（模板可变编译时信号槽实现）展开非类型模板参数包

共有1个答案

相关问答

相关文章

相关阅读

相关工具

相关文档