C++ 将Lambda表达式传递给C+中的std:：函数+；_C++_Lambda

C++ 将Lambda表达式传递给C+中的std:：函数+；

c++ lambda

C++ 将Lambda表达式传递给C+中的std:：函数+；,c++,lambda,C++,Lambda,我目前正在努力处理lambda表达式。我创建了一个ConcurrentDictionary，它用互斥体包装std:：map。现在我想导出与指定条件匹配的所有元素 template<typename MutexTypeT, typename Key_Type_T, typename Mapped_Type_T> class CConcurrentDictionary { public: ///Constructor CConcurrentDi

我目前正在努力处理lambda表达式。我创建了一个ConcurrentDictionary，它用互斥体包装std:：map。现在我想导出与指定条件匹配的所有元素

template<typename MutexTypeT, typename Key_Type_T, typename Mapped_Type_T>
class CConcurrentDictionary
{
    public:
        ///Constructor
        CConcurrentDictionary();

        class CSingleElement
        {
        public:

          ///the key
          Key_Type_T key = { };

          ///THe Mapped Type
          Mapped_Type_T mapped_type = { };

        };

     template<typename ...Args_T>
        std::vector<CSingleElement> exportSelectedData(
            const uint32_t u32MutexTimeout,
            std::function<bool(const CSingleElement, Args_T &&...)> compareFn,
            Args_T&&...CompareArgs...) const;

}

template<typename MutexTypeT, typename Key_Type_T, typename Mapped_Type_T>
   template<typename ...Args_T>
   auto CConcurrentDictionary<MutexTypeT, Key_Type_T, Mapped_Type_T>::exportSelectedData(
          const uint32_t u32MutexTimeout,
          std::function<bool(const CSingleElement, Args_T &&...)> compareFn,
          Args_T&&...CompareArgs...) const ->
      std::vector<CSingleElement>
      {
        //lock mutex...
        std::vector<CSingleElement> vecRes;
        for (const auto &single_element : dictionary)
        {
          if(compareFn(single_element, CompareArgs...))
          {
            //this element mathes the preconditions
            vecRes.push_back(single_element);
          }
        }

        return vecRes;
      }

模板
类CConcurrentDictionary
{
公众：
///建造师
CConcurrentDictionary（）；
类Csingle元素
{
公众：
///钥匙
Key_Type_T Key={}；
///映射类型
映射的_-Type_-T映射的_-Type={}；
};
模板
std:：矢量导出选定数据(
const uint32_t u32MutexTimeout，
std：：函数比较n，
参数（&…比较…）常数；
}
模板
模板
自动CConcurrentDictionary:：exportSelectedData(
const uint32_t u32MutexTimeout，
std：：函数比较n，
参数（&…比较…）常数->
向量
{
//锁定互斥锁。。。
向量向量；
for（常量自动和单个元素：字典）
{
if（compareFn（单个元素，CompareArgs…）
{
//该元素满足前提条件
向量推回（单个元素）；
}
}
返回向量；
}

但是当我试着这样使用这个类时

 class CTraceCmdDuration
  {

  public:


    ///Cmd Datatype
    using CmdType_T = uint32_t;

    class CCmdSummary
    {
    public:
      /**
       * SIngle Long Running Cmd Summary
       * @param CmdIdArg Cmd ID
       * @param u32MaxCmdDurationArg Max CmdDuration
       */
      CCmdSummary(const CmdType_T CmdIdArg, const uint32_t u32MaxCmdDurationArg);
      ///Id of this cmd
      const CmdType_T CmdId;

      ///Duration of this cmd
      const uint32_t u32MaxCmdDuration;
    };

/**
     * Exports all Cmds to a vector with took longer than u32MaxCmdDuration
     * @param u32MaxCmdDuration Maximal Cmd Processing duration time. Cmds that took longer than this will be exported
     * @param u32MutexTimeout Mutex Timeout
     * @return List with all long running cmds
     */
    std::vector<CCmdSummary> ExportLongRunningCmds(const uint32_t u32MaxCmdDuration, const uint32_t u32MutexTimeout) const;

}

  auto CTraceCmdDuration::ExportLongRunningCmds(const uint32_t u32MaxCmdDuration, const uint32_t u32MutexTimeout) const ->
      std::vector<CCmdSummary>
  {
    auto lambda = [u32MaxCmdDuration](const CombinedDictElement& singleElement)
        {
          const bool bRes = (u32MaxCmdDuration < singleElement.mapped_type.u32MaxProcessingDuration);
          return bRes;
        };
    auto vecRes = dict.exportSelectedData(u32MutexTimeout, lambda, u32MaxCmdDuration);
    return vecRes;
  }

类CTraceCmdDuration
{
公众：
///Cmd数据类型
使用CmdType\u T=uint32\u T；
类CCmdSummary
{
公众：
/**
*单个长时间运行的Cmd摘要
*@param CmdIdArg Cmd ID
*@param u32MaxCmdDurationArg最大CmdDuration
*/
CCmdSummary（const CmdType\u T CmdIdArg，const uint32\u T u32MaxCmdDurationArg）；
///此命令的Id
const CmdType\u T CmdId；
///此命令的持续时间
const uint32_t u32MaxCmdDuration；
};
/**
*将所有CMD导出到所用时间超过u32MaxCmdDuration的向量
*@param u32MaxCmdDuration最大Cmd处理持续时间。将导出耗时超过此时间的Cmd
*@param u32MutexTimeout互斥超时
*@包含所有长时间运行的cmds的返回列表
*/
std:：vector ExportLongRunningCmds（const uint32\u t u32MaxCmdDuration，const uint32\u t u32MutexTimeout）const；
}
auto-CTraceCmdDuration:：ExportLongRunningCmds（常量uint32\u t u32MaxCmdDuration，常量uint32\u t u32MutexTimeout）常量->
向量
{
自动lambda=[u32MaxCmdDuration]（常量组合dictElement和singleElement）
{
const bool bRes=（u32MaxCmdDuration


不幸的是，这不会产生匹配的函数调用错误
error: no matching function for call to 'NConcurrent_Container::CConcurrentDictionary<NMutex::CEmbos_Mutex, long unsigned int, NDebug::CTraceCmdDuration::CProcessingInfo>::exportSelectedData(const uint32_t&, NDebug::CTraceCmdDuration::ExportLongRunningCmds(uint32_t, uint32_t) const::__lambda0&, const uint32_t&) const'
     auto vecRes = dict.exportSelectedData(u32MutexTimeout, lambda, u32MaxCmdDuration);

错误：调用“NConcurrent\u容器：：CConcurrentDictionary:：exportSelectedData（const uint32\u t&，NDebug:：CTraceCmdDuration:：ExportLongRunningCmds（uint32\u t，uint32\u t）const:：\uu lambda0&，const uint32\u t&）const没有匹配的函数
自动向量=dict.exportSelectedData（u32MutexTimeout、lambda、u32MaxCmdDuration）；

我的lambda表达式有什么问题？
其思想是将允许的最大持续时间作为捕获传递，并将std:：map中存储的每个元素作为参数传递
还是你有更好的主意？
你能帮帮我吗
编辑：
Thx对于你的答案，如果我传递一个静态函数，这个效果很好
但是如何将lambda作为模板参数传递呢
static bool CompareDuaration(const CSingleElement&singleElement, const uint32_t u32MaxDuration);

  auto CTraceCmdDuration::ExportLongRunningCmds(const uint32_t u32MaxCmdDuration, const uint32_t u32MutexTimeout) const ->
      std::vector<CombinedDictElement>
  {
    auto vecRes = dict.exportSelectedData(u32MutexTimeout, lambda, u32MaxCmdDuration);
    return vecRes;
  }

静态布尔比较（const csingelement和singleElement，const uint32_t u32MaxDuration）；
auto-CTraceCmdDuration:：ExportLongRunningCmds（常量uint32\u t u32MaxCmdDuration，常量uint32\u t u32MutexTimeout）常量->
向量
{
自动向量=dict.exportSelectedData（u32MutexTimeout、lambda、u32MaxCmdDuration）；
返回向量；
}

这是有效的，但是
auto CTraceCmdDuration::ExportLongRunningCmds(const uint32_t u32MaxCmdDuration, const uint32_t u32MutexTimeout) const ->
      std::vector<CombinedDictElement>
  {

    auto lambda = [u32MaxCmdDuration](const CombinedDictElement& singleElement)
        {
          const bool bRes = (u32MaxCmdDuration < singleElement.mapped_type.u32MaxProcessingDuration);
          return bRes;
        };

    auto vecRes = dict.exportSelectedData(u32MutexTimeout, lambda, u32MaxCmdDuration);
    return vecRes;
  }

auto-CTraceCmdDuration:：ExportLongRunningCmds（常量uint32\u t u32MaxCmdDuration，常量uint32\u t u32MutexTimeout）常量->
向量
{
自动lambda=[u32MaxCmdDuration]（常量组合dictElement和singleElement）
{
const bool bRes=（u32MaxCmdDuration

给我一个编译错误
error: no match for call to '(CTraceCmdDuration::ExportLongRunningCmds(uint32_t, uint32_t) const::__lambda0) (CConcurrentDictionary<NMutex::CEmbos_Mutex, long unsigned int, CTraceCmdDuration::CProcessingInfo>::CSingleElement&, const long unsigned int&)'
       if(compareFn(singleElement, compareArgs...))

错误：调用“（CTraceCmdDuration:：ExportLongRunningCmds（uint32\u t，uint32\u t）const:：\u\u lambda0）（CConcurrentDictionary:：CSingleElement&，const long unsigned int&）不匹配”
if（compareFn（singleElement，compareArgs…）

它就像将lambda传递给模板一样，效果不太好。我遗漏了什么？问题
您遇到的问题可以归结为：
#include <functional>

template <typename ...Args>
void foo(std::function<bool(Args...)>) { }

int main()
{
    foo([](int, int) { return true; });
}

您会注意到，构造函数本身也是模板化的。编译器可以成功地将F
推断为lambda，但由于F
是构造函数的模板参数，因此无法推断类本身std:：function
的模板参数
此外，引用该构造函数：
[…]此构造函数不参与重载解析
除非f对于参数类型Args是可调用的。。。和返回类型R.[…]
这意味着此构造函数的存在取决于是否可以使用类模板参数Args…
调用F
，但由于这些参数未明确定义且无法推导，因此此构造函数无论如何都不可用
解决方案
由于您只在exportSelectedData
中使用该std:：function
，因此只需将其全部设置为模板参数（放弃std:：function
部分）：
现在想想兰姆达的签名。您返回一个布尔值，因此返回类型为bool（到目前为止还不错）。你拿
template <typename F>
function(F f);

template<typename Func, typename ...Args_T>
std::vector<CSingleElement> exportSelectedData(uint32_t u32MutexTimeout, Func compareFn, Args_T const&...) const;

auto lambda = [u32MaxCmdDuration](const CombinedDictElement& singleElement) { /* ... */ };

bool(CombinedDictElement) // take a CombinedDictElement and return a bool

exportSelectedData(u32MutexTimeout, lambda, u32MaxCmdDuration);

if (compareFn(singleElement, compareArgs...)) // ...

bool(CombinedDictElement, unsigned int) // take a CombinedDictElement and an unsigned int and return a bool

bool(CombinedDictElement)

auto lambda = [](const CombinedDictElement& singleElement, unsigned int u32MaxCmdDuration)

 exportSelectedData(u32MutexTimeout, lambda);