建議如何從包含的類中調用在容器類中定義的回調函數？

Question

想象一下，你有一個類層次結構如下所示：

class Robot 
{ 
public: 
    void OnTaskCompleted() {} 

private: 
    Task *m_pTask; 
}; 

class Task 
{ 
public: 
    virtual void DoTask() = 0; 
}; 

class TidyUp : public Task 
{ 
public: 
    void DoTask() 
    { 
     // When TidyUp task is compeleted invoke OnTaskCompleted() from here. 
    } 
}; 

我需要調用OnTaskCompleted()從TidyUp::DoTask()。推薦的方法是什麼？

我想避免：

• 使OnTaskCompleted（）靜態
• 傳遞機器人指針任務

Answer 1

static路由不可行，除非程序中只有一個Robot，並且該機器人的一個實例可以靜態使用。

將Robot傳遞給任務可能沒問題，但它可能會泄露太多信息並禁止使用機器人以外的對象的任務用法。

第三種方法是爲完成通知製作一個類似界面的類，將其擴展到Robot，並從任務中調用它。不幸的是，通過推動你進入虛擬繼承領域，C++並不是特別容易。

你可以採用POSIX線程庫中常見的回調方法（傳遞一個void指針和一個接受void指針的函數指針），但這不是太C++ - ish。最後，如果您使用的是C++ 11，那麼您可以使用anonymous functions，它可以非常優雅地解決該問題，方法是在不使用外部庫的情況下封裝一個函數和它在其中運行的對象，例如促進。

這裏是第三種方法（link to ideone）的一個簡單的例子：

#include <iostream> 
#include <string> 
using namespace std; 

class WithNotification { 
public: 
    virtual void notify()=0; 
}; 

class Robot : public virtual WithNotification { 
private: 
    string name; 
public: 
    Robot(const string& n) : name(n) {} 
    virtual void notify() {cout << name << " has been notified" << endl; } 
}; 

class Task { 
private: 
    WithNotification& onFinished; 
public: 
    Task(WithNotification& f) : onFinished(f) {} 
    void run() { 
     cout << "The task is running" << endl; 
     onFinished.notify(); 
    } 
}; 

int main() { 
    Robot r1("Quick"); 
    Robot r2("Brown"); 
    Task t1(r1); 
    Task t2(r2); 
    t1.run(); 
    t2.run(); 
} 

Answer 2

我會去傳遞一個指針。但是，如果你打算使用Task不僅Robot考慮制定TaskDelegate接口用於發送通知：

class TaskDelegate 
{ 
public: 
    virtual void onTaskFinished(Task *sender) = 0; //implement in successors 

protected: 
    ~TaskDelegate() {} //don't allow deletion via interface pointer 
}; 

現在你Task類看起來像：

class Task 
{ 
    Task(TaskDelegate *delegate) {...} 
    ... 
}; 

繼承Robot是一個delegate

class Robot : public TaskDelegate {...} 

因此Task能夠通知實現的所有對象TaskDelegate接口

Answer 3

沒有任何方法可以解決這個問題，而不需要傳遞任何東西給包含的類。最簡單的方法是讓Robot從包含OnTaskCompleted方法的純虛擬基類繼承，並且讓Task類具有指向該虛擬基類的指針或引用，並將Robot實例傳遞給包含的Task類。 Robot類不是從基類繼承的，而是可以將其作爲模板參數傳遞給模板化的Task類。

另一種解決方案是將Task作爲模板類，並通過this->OnTaskCompleted函數作爲模板參數。就像：

template<class Callback> 
class Task 
{ 
public: 
    void DoTask() 
    { 
     // ... 

     Callback(); 
    } 
}; 

class Robot 
{ 
public: 
    Robot() 
    { 
     m_pTask = new Task<this->OnTaskCompleted>; 
    } 

    // ... 
}; 

如果這最後一種方法的作品，我其實並不知道，因爲我還沒有嘗試過。

正如你所看到的，無論從我的和其他的答案，有很多方法來做到這一點。他們中沒有一個實際上是一個「官方」或「推薦」的方式來做到這一點。但幾乎所有這些都需要你通過一個類或一個對象到類Task類。

Answer 4

根據XEO的建議，我已經做了這樣的事情：

#include <iostream> 
#include <functional> 

typedef std::tr1::function<void (int)> CallbackFunc; 

class Task 
{ 
public: 
    Task(CallbackFunc callbackFunc) : m_callbackFunc(callbackFunc) {} 
    virtual ~Task() {} 
    virtual void DoTask() = 0; 
protected: 
    CallbackFunc m_callbackFunc; 
}; 

class TidyUp : public Task 
{ 
public: 
    TidyUp(CallbackFunc callbackFunc) : Task(callbackFunc) {} 
    void DoTask() { 
     std::cout << "I love tidying up!" << std::endl; 
     m_callbackFunc(6); // When TidyUp task is compeleted invoke OnTaskCompleted() from here. 
    } 
}; 

class Robot : private Uncopyable 
{ 
public: 
    Robot() : m_pTask(new TidyUp(std::bind(&Robot::OnTaskCompleted, this, std::placeholders::_1))) {} 
    ~Robot() { delete m_pTask; } 
    void DoTask() { m_pTask->DoTask(); } 
    void OnTaskCompleted(int nCleannessLevel) { std::cout << "Done! Cleanness Level: " << nCleannessLevel << std::endl; } 
private: 
    Task *m_pTask; 
}; 

int main() 
{ 
    Robot robot; 
    robot.DoTask(); 
    return 0; 
}