Question

所以，我想知道如何使用各种跟踪机制在C ++中创建某种代码审计。

考虑以下类，其中两个独立的镜像A和B向侦听器提供消息。

class MirrorA
{
  void one(int a) {  m_mirrrorListener.three(a); }
};

class MirrorB
{
  void two(int b) {  m_mirrrorListener.three(b); }
};

class MirrorListener
{
  void three(int c) { std::cout << c << std::endl; }
};

现在，让我们说，出于某种原因，三个人需要知道它是由一个（）还是两个（）触发。

我们可以传递这样的值：

enum mirrorSource_t
{
  FROM_ONE = 1,
  FROM_TWO = 2
}

class MirrorA
{
  void one(int a) {  m_mirrrorListener.three(a, FROM_ONE); }
};

class MirrorB
{
  void two(int b) {  m_mirrrorListener.three(b, FROM_TWO); }
};

class MirrorListener
{
  void three(int c, mirrorSource_t source) { std::cout << c << " From " << source << std::endl; }
};

但是，当需要新信息时，我们必须更新三个签名及其调用。

那么，如果我们有一个单一的消息跟踪器（在其他类中引用为m_mirrorMessageTracker）可以跟踪任意数量的消息呢？

enum mirrorSource_t
{
  FROM_ONE = 1,
  FROM_TWO = 2
}

class MirrorMessage
{
  public:
    MirrorMessage(mirrrorSource_t t) :  source(t)  {}
    get() { return source; }

  private:
    mirrorSource_t  source;
};

class MirrorMessageTracker {
public:

  MirrorMessage& MirrorMessageTracker::trackEvent(mirrorSource_t value)
  {
    trackedMessages.push_back(MirrorMessage(value));
    return trackedMessages.back();
  }

  MirrorMessage&  MirrorMesssageTracker::getCurrentEvent()
  {
    return trackedMessages.back();
  }

  static MirrorMessageTracker& getInstance()
  { 
    if(!m_Tracker)
    {
       m_pTracker = new MirrorMessageTracker();
    }
    return *m_pTracker; 
  }

private:
    MirrorMessageTracker() { }; //  
    static MirrorMessageTracker* m_pTracker;
    std::vector<MirrorMessage> trackedMessages;  // assumption is that tracked messages are
                                                 // single-threaded and unwind in a LIFO manner.
};

class MirrorA
{
  void one(int a)
  {
    MirrorMessage createdMessage = m_MirrorMessageTracker.trackMessage(FROM_ONE);
    m_mirrrorListener.three(a);
  }
};

class MirrorB
{
  void two(int b)
  {
    MirrorMessage createdMessage = m_MirrorMessageTracker.trackMessage(FROM_TWO);
    m_mirrrorListener.three(b);
  }
};

class MirrorListener
{
  void three(int c) 
  {
    MirrorMessage& message = m_MirrorMessageTracker.getCurrentMessage();
    if (message.get() == FROM_ONE)
    {
      std::cout << c << std::endl;
    }
    else if (message.get() == FROM_TWO)
    {
      std::cout << c << c << std::endl;
    }
    else
    {
      std::cout << c << c << c << std::endl;
    }
  }
};

我希望在createdMessage超出一和二的范围后，从跟踪器中删除跟踪的消息。这可以通过特定类型的升压智能指针来完成吗？类似的东西：

  std::vector<boost::shared_ptr<MirrorMessage> > trackedMessages;

vector :: push_back会创建一个消息副本并将其放入向量中，所以我不确定是否可以使用共享指针。

Answer 1

实际创建单例的更常见模式是

  static MirrorMessageTracker& getInstance() { 
      static MirrorMessageTracker theMirrorMesageTracker;
      return theMirrorMesageTracker; 
  }

此外，您应该考虑通过执行这些操作MirrorMessageTracker禁止复制和分配private课程：

  private:
      MirrorMessageTracker() { };
      MirrorMessageTracker(const MirrorMessageTracker&); // <<<
      MirrorMessageTracker& operator=(const MirrorMessageTracker&); // <<<

单例容器中的RAII对象？

1 个答案: