将变量实例静默地绑定到C++中的类？

Question

所以我有一个我正在写的基于插件的系统。用户可以创建一个Plugin类的子类，然后它将在运行时加载并与系统的其他部分集成。当一个插件从系统运行时，它在一组插件的上下文中运行，我称其为Session。

我的问题是，在用户插件中，可以使用两个名为pf_ostream和pf_istream的流类来读/写数据到系统。我希望以某种方式将插件实例的会话变量绑定到pf_ostream和pf_istream，以便当用户实例化这些类时，它已经绑定到会话中（基本上我不希望他们看到会话内部）

我可能只是这样做有一个宏，包装调用构造函数，如：

#define MAKE_OSTREAM = pf_ostream_int(this->session) 

但我认为有可能是一个更好的办法。我在使用包装pf_ostream的Plugin内部的嵌套类时看过，但它看起来嵌套类不能以闭包方式访问封闭类变量。

有谁知道一个干净的方式来做到这一点？

Answer 1

您可以在构建过程中为嵌套类提供对其父类的引用。

class plugin_base { 
protected: 
    plugin_base(): _istream(*this) {} 
    class istream { 
    public: 
     istream(plugin_base& p): _plugin(p) {} 
     ... 
    private: 
     plugin_base& _plugin; 
    }; 
    istream _istream; 
}; 

class plugin: public plugin_base { 
    ... 
}; 

plugin_base的构造函数将在每次实例化其子类时由编译器自动调用。

Answer 2

可以使用具有Session的接口类。下面是一些耐人寻味：

class IContext 
{ 
public: 
    virtual ~IContext() {} 
    virtual Session* session() = 0; 
}; 


class Plugin : public IContext 
{ 
public: 
    Plugin(Session* session) : session_(session) {} 
    virtual ~Plugin() {} 
    virtual Session* session() {return session_;} 

protected: 
    Session* session_; 
}; 


class MyPlugin : public Plugin 
{ 
public: 
    MyPlugin(Session* session) : Plugin(session) {} 
    virtual ~MyPlugin() {} 
    void print() 
    { 
     pf_ostream pfos(this); 
     pfos << "Hello world!\n"; 
    } 
}; 


class pf_ostream 
{ 
public: 
    pf_ostream(IContext* context) : session_(context->session()) {} 
    // ... 

private: 
    Session* session_; 
    // ... 
}; 

注意插件作家现在如何使用pf_ostream pfos(this)，而不是pf_ostream pfos(this->session)，现在无视Session。 pf_ostream也不知道Plugin及其后代。

IContext可能不是这里最好的名字。也许IHasSession？ （IHasCheezburger ???）

Answer 3

下面是根据您在其中一条评论中提到的工厂构思提出的另一个答案。它采用Facade模式集中在绑定到一个Session一个System类的系统设备创建：

#include <boost/shared_ptr.hpp> 

class System 
{ 
public: 
    typedef boost::shared_ptr<pf_ostream> pf_ostream_ptr; 
    typedef boost::shared_ptr<pf_istream> pf_istream_ptr; 
    // Other system facilities... 

    System(Session* session) : session_(session) {} 

    pf_ostream_ptr makeOstream() 
     {return pf_ostream_ptr(new pf_ostream(session_));} 

    pf_istream_ptr makeIstream() 
     {return pf_istream_ptr(new pf_istream(session_));} 

private: 
    Session* session_; 
}; 


class Plugin 
{ 
public: 
    Plugin(System* system) : system_(system) {} 

    System& system() {return *system_;} 

private: 
    System* system_; 
}; 


class MyPlugin : public Plugin 
{ 
public: 
    MyPlugin(System* system) : Plugin(system) {} 

    void print() 
    { 
     pf_ostream_ptr pfos(system().makeOstream()); 
     *pfos << "Hello World!\n"; 
     // pfos will be deleted automatically at the end of this scope 
    } 
}; 

如果你有很多的系统设施，你应该明智地使用着的声明，以避免长时间的编译时间。此解决方案的缺点是将您的系统设施集中在一个依赖关系“焦点”（System类）中。如果System类在使用更多或更少系统设施的其他应用程序中重新使用，则可能需要更改该类。

编辑：

这里是你如何运用代理模式（以及PIMPL方法）来获取值语义的引用计数的流类：

#include <boost/shared_ptr.hpp> 

class pf_ostream 
{ 
public: 
    pf_ostream(Session* session); 
    pf_ostream& operator<<(int rhs); 
    // Use of default copy-constuctor and assignment operator 
    // will work fine because of shared_ptr. 

private: 
    struct Impl; 
    boost::shared_ptr<Impl> pimpl_; 
}; 

// In cpp file 

struct pf_ostream::Impl 
{ 
    Impl(Session* session) : session(session) {} 
    void insert(int rhs) {/*...*/} 
    Session* session; 
}; 

pf_ostream::pf_ostream(Session* session) : pimpl_(new Impl(session)) {} 

pf_ostream& pf_ostream::operator<<(int rhs) {pimpl_.insert(rhs); return *this;} 

用户将必须意识到代理对象的副本将引用相同的实际流。希望这可以帮助。