C++ 在成员函数上调用线程

很抱歉给出了这么长的示例，但问题很简单。我使用的是基本的访问者模式，带有一个中介来管理几个具体的访问者：publicdatavisitor对象。conrete中介器SimulatorMediator用Visitor_pick对象填充列表，然后希望调用DataVisitor成员函数上的std:：thread。我尝试过几种变体，使用mem_fun1_t等，但运气不佳。无法编译。正确的语法是什么

有问题的调用应该在第205行-我想将线程附加到一元函数v->visit_SpreadData，然后填充threadVec。任何帮助都将不胜感激

#include <iostream>
#include <ostream>
#include <iterator>
#include <list>
#include <vector>
#include <algorithm>

#include <thread>

class PublishEvent;
class Subscriber
{
 public:
   virtual void update(const PublishEvent *e) = 0;
   ~Subscriber() = default;
};

class Publisher
{
 public:
   void attach(Subscriber*);
   void detach(Subscriber*);
   void notify(const PublishEvent*);

 protected:
   std::list<Subscriber*> subscribers_;

};
inline void Publisher::
notify(const PublishEvent *e)
{
   for (auto &s : subscribers_)
     s->update(e);
}

inline void Publisher::
attach(Subscriber *s)
{
   subscribers_.push_back(s);
}

inline void Publisher::
detach(Subscriber *s)
{
   // inefficient for large nubmer of susbscribers
   subscribers_.remove(s);
}

class Mediator;
class SpreadData;
class DataElement;
class DataVisitor : public Publisher, public Subscriber
{
 public:
   virtual ~DataVisitor() {}
   // visit method
   virtual void visit_SpreadData(SpreadData *SD) = 0;
   // from Publisher::
   void update(const PublishEvent *e) override;
   void setMediator(Mediator *m)
     {
    m_ = m;
     }
   float get_payload() const
     {
    return payload_;
     }
   void set_payload(float p)
     {
    payload_ = p;
     }

   virtual void gendata(DataElement*) = 0;

 protected:
   DataVisitor() {}

 private:
   Mediator *m_;
   float payload_;
};

class DataElement
{
 public:
   virtual ~DataElement() {};
   void Accept(DataVisitor&);
 protected:
   DataElement() {};
};

void DataElement::Accept(DataVisitor &d)
{
   d.gendata(this);
}
class SpreadData : public DataElement
{
 public:
   typedef std::vector<float> return_data_type;

   SpreadData() { initiate(); };
   SpreadData(std::string filename) { initiate();};

   void printdata() const
     {
    std::copy(data_.begin(),
              data_.end(),
              std::ostream_iterator<float>(std::cout, " : "));
    std::cout << std::endl;
     }
   return_data_type getdata() const
     {
    return data_;
     }

 private:
   void initiate()
     {
    for(int i=0;i<100;i++)
      data_.push_back(static_cast<float>(i));
     }

   return_data_type data_;

};

void DataVisitor::update(const PublishEvent *e)
{
   // implementation details
};

template<int N>
class Visitor_pick : public DataVisitor
{
 public:
   Visitor_pick()
     {set_payload(0.); }
   // from DataVisitor
   void visit_SpreadData(SpreadData*) override;
   // from DataVisitor
   void gendata(DataElement*);
};

template<int N>
void Visitor_pick<N>::visit_SpreadData(SpreadData *SD)
{
   SD->Accept(*this);
}

template<int N>
void Visitor_pick<N>::gendata(DataElement *d)
{
   // implementation details
   SpreadData *SD = dynamic_cast<SpreadData*>(d);
   SpreadData::return_data_type r = SD->getdata();
   set_payload(r[N]);
}

class Mediator
{
 public:
   virtual ~Mediator() = default;
   virtual void mediate(DataElement*) = 0;

 protected:
   Mediator() = default;
   virtual void CreateVisitors() = 0;

   std::list<DataVisitor*> visitors_;
};

class Mediator_1 : public Mediator
{
 public:
   Mediator_1()
     {
    CreateVisitors();
     }
   void mediate(DataElement*);
 private:
   void CreateVisitors();
};

void Mediator_1::CreateVisitors()
{
   visitors_.push_back(new Visitor_pick<37>());
   visitors_.push_back(new Visitor_pick<42>());
   visitors_.push_back(new Visitor_pick<47>());
   visitors_.push_back(new Visitor_pick<52>());
   visitors_.push_back(new Visitor_pick<57>());
}
void Mediator_1::mediate(DataElement *SD)
{
   typedef std::mem_fun1_t<void,DataVisitor,SpreadData*> Visitor_fn;
   std::cout << "Mediating hard..." << std::endl;
   std::vector<std::thread> threadVec;
   for(auto &v : visitors_)
     {
    // Use Visitor_fn to spawn thread on
    // unary function v->visit_SpreadData,
    // place at back of threadVec
     }

   for_each(threadVec.begin(), threadVec.end(),
        std::mem_fn(&std::thread::join));
   for(auto &v : visitors_)
     std::cout << "Payload: " << v->get_payload() << std::endl;
}

int main(int argc, char **argv)
{

   SpreadData *SD = new SpreadData();
   Mediator_1 *M = new Mediator_1();
   M->mediate(SD);

   delete SD;
   delete M;

   return 0;
}

#包括
#包括
#包括
#包括
#包括
#包括
#包括
类通风孔；
类订户
{
公众：
虚拟void更新（const*e）=0；
~Subscriber（）=默认值；
};
类发布者
{
公众：
无效附加（认购人*）；
无效（认购人*）；
无效通知（常数*）；
受保护的：
std：：列出订阅者；
};
内联无效发布服务器：：
通知（const*e）
{
用于（自动&s：订阅者）
更新（e）；
}
内联无效发布服务器：：
附加（订户*s）
{
订阅者向后推；
}
内联无效发布服务器：：
分离（订户*s）
{
//对于大数量的用户来说效率低下
（a）删除；
}
班级调解员；
类数据；
类数据元素；
类DataVisitor:公共发布者、公共订阅者
{
公众：
虚拟~DataVisitor（）{}
//访问方法
虚拟无效访问_SpreadData（SpreadData*SD）=0；
//出版者：：
无效更新（const*e）覆盖；
void setMediator（Mediator*m）
{
m_um=m；
}
float get_payload（）常量
{
返回有效载荷；
}
无效设置_有效载荷（浮动p）
{
有效载荷=p；
}
虚拟void gendata（数据元素*）=0；
受保护的：
DataVisitor（）{}
私人：
调解人*m；
浮动有效载荷；
};
类数据元素
{
公众：
virtual~DataElement（）{}；
无效接受（DataVisitor&）；
受保护的：
数据元素（）{}；
};
void DataElement:：Accept（DataVisitor&d）
{
d、 性别（本）；
}
类：公共数据元素
{
公众：
typedef std:：向量返回\数据\类型；
SpreadData（）{initiate（）；}；
SpreadData（std:：string文件名）{initiate（）；}；
void printdata（）常量
{
std:：copy（数据开始（），
数据_u2;.end（），
std:：ostream_迭代器（std:：cout，“：”）；
std:：cout getdata（）；
设置_有效载荷（r[N]）；
}
阶级调解人
{
公众：
virtual~Mediator（）=默认值；
虚空中介（数据元素*）=0；
受保护的：
Mediator（）=默认值；
虚拟void CreateVisitors（）=0；
std：：列出访客；
};
类调解员_1：公共调解员
{
公众：
调解人_1（）
{
创建访客（）；
}
无效中介（数据元素*）；
私人：
void CreateVisitors（）；
};
void Mediator_1:：CreateVisitors（）
{
访客。推回（新访客拾取（））；
访客。推回（新访客拾取（））；
访客。推回（新访客拾取（））；
访客。推回（新访客拾取（））；
访客。推回（新访客拾取（））；
}
void Mediator_1:：mediate（数据元素*SD）
{
typedef std:：mem_fun1_t Visitor_fn；
std:：cout 1.仔细阅读编译器错误消息2.注释内容以缩小问题范围像
mem\u fn
这样的帮助程序被弃用，而支持
bind
你真的应该对此进行分解。你发布的90%代码不需要解释你的问题。我只会使用
auto param=dynamic\u cast（SD）；if（param）threadVec.emplace_back（&DataVisitor:：visit_SpreadData，v，param）；
。实际上不需要
mem_fun
甚至
bind
。不过，让元素的数量定义线程的数量至少是值得怀疑的。@dauchic：检查标准，
std:：mem_fn（）
肯定不在D章中（兼容特性）但20.10.如果代码只添加了C++标准的最新修订，则会被拒绝：“MyMyfn（））/Cype >。似乎您混淆了<代码> STD:：MyMyFn（）/St> >代码> STD:：MyMyFune（）：/Calp>，<代码> STD:MeMyFunyRever（）/<代码>，这实际上是不推荐的。