C++ 如何将变量参数传递给虚函数

我有一个工作的虚拟函数

add

，它使用以下设置：

using Func = std::function<std::vector<unsigned char>()>;      

class cfExecutor {
public:
    cfExecutor();
    virtual ~cfExecutor();
    /// Enqueue a function to be executed by this executor. This and all                     
    /// variants must be threadsafe.
    virtual void add(Func) = 0;                              
    virtual void add(std::vector<Variant> params, Func callback) = 0; 
};


class ManualExecutor : public cfExecutor                                                                            
{                                                                                                                   

    std::mutex lock_;             // avoid multiple entity updating the function container                          
    std::queue<Func> funcs_;      // functions queued for running                                                 

    public:                                                                                                         
    std::map<int8_t, Func> funcs; // Function container (priority,Func) - added functions to this Executors       

    ManualExecutor() {}                                                                                             
    ManualExecutor(ManualExecutor&& other):                                                                         
                    funcs(std::move(other.funcs))                                                                   
    {}                                                                                                              
    ~ManualExecutor() {}                                                                                            

    void add(Func callback);                                                                          
    void add(std::vector<Variant> params, Func callback);                     
};                                                                                                                  

使用Func=std:：function；
类执行器{
公众：
cfExecutor（）；
virtual~cfExecutor（）；
///将要由该执行器执行的函数排队。此和所有
///变体必须是线程安全的。
虚空添加（Func）=0；
虚拟void add（std:：vector params，Func callback）=0；
};
类别ManualExecutor：公共cfExecutor
{                                                                                                                   
std:：mutex lock \；//避免多实体更新函数容器
std:：queue funcs_；//排队等待运行的函数
公众：
std:：map funcs；//函数容器（优先级，Func）-将函数添加到此执行器
ManualExecutor（）{}
手动执行器（手动执行器和其他）：
funcs（std:：move（other.funcs））
{}                                                                                                              
~ManualExecutor（）{}
作废添加（Func回调）；
void add（std:：vector params，Func回调）；
};                                                                                                                  

然后我想向函数中添加可变参数-如下所示：

using Func = std::function<std::vector<unsigned char>(const auto&...args)>;  

使用Func=std:：function；

但是我得到隐式错误[隐式模板可能不是“虚拟的”]

我应该如何定义带有可变参数的加法函数

到目前为止，我已使用以下方法解决了此问题：

using Func = std::function<std::vector<unsigned char>(std::vector<Variant>)>;

template<typename ... Args >
using Func =std::function<std::vector<unsigned char>(const Args&...args)>;

template<typename ... Args >
class cfExecutor {                        
 public:   
     cfExecutor();                        
    virtual ~cfExecutor(); 
     virtual void add(Func<Args...>) = 0;

    };

使用Func=std:：function；

然后让lambda函数处理向量内部的接收参数-类似于这样：

auto lambdaFunction = [](std::vector<Variant> vec){        

    std::vector<unsigned char> result;                     
    cout << "- Hello from executor - lambdaFunction ";     
    std::cout << ": parameters : ";                        
    for(auto a: vec) {                                     
        std::cout << a << ",";                             
    }                                                      
    std::cout << std::endl;                                 

    std::string s("this is the result");                   
    result.insert(result.end(),s.begin(), s.end());        
    return result;                                         
};        

自动lambdaFunction=[]（std:：vector vec）{ std：：向量结果；

---

好吧，您还不能在函数原型中使用

'auto'

您可能希望执行以下操作：

using Func = std::function<std::vector<unsigned char>(std::vector<Variant>)>;

template<typename ... Args >
using Func =std::function<std::vector<unsigned char>(const Args&...args)>;

template<typename ... Args >
class cfExecutor {                        
 public:   
     cfExecutor();                        
    virtual ~cfExecutor(); 
     virtual void add(Func<Args...>) = 0;

    };

模板
使用Func=std:：function；
模板
类cfExecutor{
公众：
cfExecutor（）；
virtual~cfExecutor（）；
虚空添加（Func）=0；
};

看起来您想要传递一个绑定函数

这可以通过

std:：bind

完成。您不需要以任何方式更改

add

，也不需要添加基于

向量的重载。只需按如下方式调用它：

std::vector<unsigned char> myfunction (int, const char*, Foo&);

...
int i = 123;
const char* s = "abc";
Foo foo{1,2,3};
executor->add(std::bind(myfunction, i, s, foo));

事实上，您总是可以用
lambda
替换
bind
表达式，这样我的可读性更强。比较：

int foo;
std::bind(std::operator<<, std::cout, foo);

intfoo；
绑定（std:：operator当您使用
auto…
时，则
Func
不是具体类型。您需要将其作为模板别名，例如：
template using Func=std:：function；
是否要向同一cfExecuror添加具有不同签名的函数，或具有相同可变签名的函数，或其他？不同的签名s会很好，不过到目前为止，我只想有一个变量函数params@serup：你的目标是什么？你想用这个做什么？我觉得如果你用不同的方式来实现你的目标，你甚至不需要用
虚拟
函数来编写这个类。@Nawaz，我有几个不同的executors，其中一个名为ManualExecutor-它工作正常，但是现在我想向我添加到执行器的函数添加参数-执行器在promises/futuresNote中执行，模板别名中不需要
args
。我在将此cfExecutor作为父级的类中使用此原则时遇到问题t模板名称的使用无效-不确定此设置发生了什么，也许我不太了解您的解决方案-我在问题中添加了更多信息，您能看一下吗again@serup不确定你是如何通过lambda的，它可能需要在它的网站上单独发布一个帖子own@P0W，是的，我同意也许是另一个帖子——不知怎么的，关于转发存储在队列上的lambda函数的参数并不是那么简单，但是在队列上放置lambda函数以供以后执行是很容易的，但是关于参数/参数传输的整个事情隐藏在一些模板设置中，这是lambda不可能使用的-我想这就是我想要的-我将尝试d相应地修改我的代码-谢谢