Question

我正在尝试实现一个向量，该向量表示从基类继承的TimedCallback对象的列表。它们包含一些基本变量，还有一个主要功能是函数指针。该函数应该能够返回任何类型并具有任何参数。我将它们作为lambda传递给了函数，到目前为止还算不上什么问题。

这是相关代码：

std::vector<std::unique_ptr<TimedCallbackBase>> m_TimerCallbackList;

struct TimedCallbackBase {
    TimedCallbackBase() = default;
    virtual ~TimedCallbackBase() = default;

    template<typename T> T run()
    {
        return dynamic_cast< TimedCallback<T> & >(*this).Run();
    }
    template<typename T> std::string name()
    {
        return dynamic_cast< TimedCallback<T> & >(*this).Name;
    }
    template<typename T> TaskTimer time()
    {
        return dynamic_cast< TimedCallback<T> & >(*this).Time;
    }
    template<typename T> int repeatcount()
    {
        return dynamic_cast< TimedCallback<T> & >(*this).RepeatCount;
    }
};

template <typename Fu>
struct TimedCallback : TimedCallbackBase {
    TimedCallback(const std::string& name, const std::string& time, Fu f, int r) : Name(name), Run(f), Time(time), RepeatCount(r) {}
    std::string Name;
    Fu Run;
    TaskTimer Time;
    int RepeatCount;
};

template<typename Fu>
void Schedule(const std::string& name, const std::string& time, Fu f, int repeatCount = 0) {
    TimedCallback cb(name, time, f, repeatCount);
    if (!vec_contains(m_TimerCallbackList, cb)) {
        m_TimerCallbackList.push_back(cb);
    }
    else { Global->Log->Warning(title(), "Callback '"+name+"' already exists."); }
}

我的问题是这种方法。我无法正确运行func指针。

void _RunTimers() {
    if (m_TimerCallbackList.size() > 0) {
        for (auto &t : m_TimerCallbackList) {
            if (t != nullptr) {

                std::string _name = t.get()->name(); // wrong syntax, or signature?
                TaskTimer  _time = t.get()->time();
                int  _repeatcount = t.get()->repeatcount();
                //auto _run = t.get()->run(); ??

                Global->t("Callback name: " + _name);
                Global->t("Callback time: " + _time.GetRealTimeAsString());
                Global->t("Callback count: " + its(_repeatcount));
            }
        }
    }
    else { Global->Log->Warning(title(), "No timed tasks to run at this time."); }
}

我打算使用这样的代码：

Task->Schedule("testTimer", "10sec", [&]{ return Task->Test("I'm a 10sec timer."); });

_RunTimers();

我觉得我距离正确执行还差很远。我不想为_RunTimers（）指定任何模板；方法。请帮助我了解如何做到这一点。

修改：

我的意思是，我想完全有可能沿着

定义一堆typedef。

using int_func = std::function<int()>;

对于每种可能的情况，然后使我的包装器对象超载，但是我一直在寻找更具动态性和防更改性的东西。

编辑2：实施建议的更改后

注意：为避免歧义，我已将方法重命名。（这里不包括Test（）方法，而只是对字符串参数执行std :: cout了）

主要：

Callback myCallback = make_callback(&TaskAssigner::Test, "I'm a 5sec timer.");

Task->ScheduleJob("timer1", "5sec", myCallback, -1);
Task->RunScheduledJobs();

实用程序：

typedef double RetVal;
typedef std::function<RetVal()> Callback;

template <class F, class... Args>
Callback make_callback(F&& f, Args&&... args)
{
    auto callable = std::bind(f, args...);                  // Here we handle the parameters
    return [callable]() -> RetVal{ return callable(); };    // Here we handle the return type
}

struct TimedCallback  {
    TimedCallback(cstR name, cstR time, Callback f, int r)
        : Name(name), Run(f), Time(time), RepeatCount(r) {}

    RetVal operator()() const { return Run(); }

    bool operator==(const TimedCallback& other) {
        if (Name == other.Name && RepeatCount == other.RepeatCount) { return true; }
        return false;
    }

const bool operator==(const TimedCallback& other) const {
    if (Name == other.Name && RepeatCount == other.RepeatCount) { return true; }
    return false;
}

    std::string Name;
    Callback Run;
    TaskTimer Time;
    int RepeatCount;
};

TaskAssigner .h：

void ScheduleJob(const std::string& name, const std::string& time, const Callback& func, int repeatCount = 0);

void RunScheduledJobs();

std::vector<TimedCallback> m_TimerCallbackList;

TaskAssigner.cpp：

void TaskAssigner::ScheduleJob(const std::string& name, const std::string& time, const Callback& func, int repeatCount) {

    TimedCallback cb(name, time, func, repeatCount);

    if (!vec_contains(m_TimerCallbackList, cb)) {
        m_TimerCallbackList.emplace_back(cb);
    }
    else { Global->Log->Warning(title(), "Callback '" + name + "' already added."); }
}

void TaskAssigner::RunScheduledJobs() {
    if (m_TimerCallbackList.size() > 0) {
        for (auto &t : m_TimerCallbackList) 
        {
            RetVal value = t();
            //Global->t("Callback result: " + std::to_string(value));
            Global->t("Callback name: " + t.Name);
            Global->t("Callback time: " + t.Time.GetRealTimeAsString());
            Global->t("Callback count: " + its(t.RepeatCount));
        }
    }
    else { Global->Log->Warning(title(), "No timed tasks to run at this time."); }
}

当前问题：

编译器说：C3848：类型为'const std :: _ Bind ，const char（＆）[18]>'类型的表达式将丢失一些const-volatile限定符以进行调用< / strong> .....

我尝试进行研究，有人提到了VS 2013中有关绑定和自动的错误。解决方案包括键入签名而不是自动签名，或删除/添加适当的const（？）。不知道这是同一个错误还是我的实现仍然不正确。（错误：https://stackoverflow.com/a/30344737/8263197）

我不确定如何使用此typedef使RetVal支持任何值。我尝试过

template<typename T> struct CallbackReturnValue { CallbackReturnValue(T v) : value(v) {} T value; };

，但是我仍然需要模板化其他支持方法。我在这里误会什么？

Answer 1

似乎您正在尝试重新发明std::function（“通用多态函数包装器”）。与其处理模板和多个子类，不如尝试以下类似的方法。

typedef std::function<void()> Callback;

struct TimedCallback {
    TimedCallback(const std::string& name, const std::string& time, const Callback & f, int r) :
        Name(name),
        Run(f),
        Time(time),
        RepeatCount(r)
    {}

    // Not wise to differentiate names by case (run vs. Run),
    // but this form might be instructive as to how this
    // setup would fit into your existing _RunTimers().
    // By the way, _RunTimers is a reserved identifier.
    void run()
    {
        Run();
    }

    std::string Name;
    Callback Run;
    TaskTimer Time;
    int RepeatCount;
};

如果您需要回调返回的值，则需要更复杂的事情。但是，尝试一次迈出这一步。

经过一些澄清后，似乎打算将返回的值存储在某种容器中。为了使此工作有效，需要有一种可以将所有返回值转换为的类型（例如，使所有返回值都是从公共基类派生的类）。我将继续给出一种可行的方法。

第一步是定义公共返回类型。通过将其设置为typedef，我可以在以后的代码中抽象出这一选择。

typedef /* fill this in */ RetVal;

接下来，我们修改Callback和run()的定义以解决此类型。

typedef std::function<RetVal()> Callback;

RetVal run()
{
    return Run();
}

否则TimedCallback的定义保持不变，但是我将引入一个方便层，以使构造这些回调更加容易。受到“ make_pair和“ make_tuple”等令人敬畏的名字的启发：

template <class F, class... Args>
Callback make_callback(F&& f, Args&&... args)
{
    auto callable = std::bind(f, args...);               // Here we handle the parameters
    return [callable]() -> RetVal{ return callable(); }; // Here we handle the return type
}

啊，模板终于出现了！但是请注意，模板已本地化到此便捷功能；如果您的可调用对象已经采用方便的形式，则不必使用此模板。假设对象不是便利形式，这里是便利的示例用法。为了举例，我将假定一个字符串可以隐式转换为RetVal。

// Example function that takes a parameter.
std::string hello(const std::string & world)
{
    std::cout << "Hello " << world << "!\n";
    return world;
}

// Example main function to see that this can work.
int main()
{
    // Placeholder for m_TimerCallbackList.
    std::vector<TimedCallback> timer_list;

    // Instead of Task->Schedule(), I'll emplace on a vector.
    timer_list.emplace_back("testTimer", "10sec",
                            make_callback(hello, "Earth"),
                            1);

    // Instead of RunTimers(), I'll manually run the first callback.
    RetVal value = timer_list[0].run();
}

具有对象的向量，这些对象具有不同类型的函数指针

1 个答案: