我正在开发一个小型内存工具，它可以跟踪分配和释放、对象大小、对象类型等。我用来跟踪源文件、行号和对象类型的方法是这样工作的:

#define DEBUG_NEW SourcePacket(__FILE__, __LINE__) * new
#define new DEBUG_NEW

SourcePacket 只是一个小类，它在构造期间接受一个 const char* 和一个 int。这些值通过 __FILE__ 和 __LINE__ 宏填充。对象类型是这样获取的:

template<typename T>
T* operator*(const SourcePacket& packet, T* p);

p 是指向新分配对象的指针，其类型使用 RTTI 发现。在运算符重载中，信息被获取并存储在跟踪器中，指针被传递给程序。大小和地址等更多信息在重载的 operator new 中获取。

现在，这个设置对我来说效果很好。它不适用于我不编译的代码，当然，但最好的事情之一是它可以很好地处理用户发出的新调用，这在使用经常引用的情况下不起作用

#define new new(__FILE__, __LINE__)

方法。我遇到的问题是，如果用户调用 operator new，程序根本无法编译。当然这是因为宏是这样展开的

return operator SourcePacket("blahblah.cpp", 20) * new(size);

代替

return SourcePacket("blahblah.cpp", 20) * new(size);

我真的看不出有什么办法解决这个问题。当然，我可以只删除 SourcePacket * new 过程，只让我的重载运算符 new 收集大小和地址，但这种做法违背了该工具的大部分目的。

(另外，请注意，我并不是要创建 Valgrind 或任何东西，而且我知道重载全局操作可能相当狡猾。这主要是出于教育目的。此外，我知道 OS-可以使用特定功能来发现其中的一些信息，但我只想使用标准 C++ 以使其跨平台和位独立(x86、x64 等)。到目前为止，它对我来说完美无缺在两种位风格的 Linux 和 Windows 版本上。)

不幸的是，似乎没有任何方法可以有条件地使用一种方式或另一种方式，具体取决于它是新的(或新的展示位置)还是新的运算符。使它起作用并不重要，但我很想知道是否有人找到了解决此限制的方法。

最佳答案

我们需要一个表达式，它在前缀为“operator”时有效，在没有前缀时有效。这意味着我们需要定义一个接受 SourcePacket 的操作符。它可能需要其他参数，但事实证明这是没有必要的。一元 operator * 会做得很好:

const SourcePacket& operator *(const SourcePacket& sp)  {
    return sp;
}

#define DEBUG_NEW *(SourcePacket(__FILE__, __LINE__)) * new
#define new DEBUG_NEW

由于我们无法将语句完全括起来，因此如果在除最简单的表达式之外的所有表达式中使用，仍然存在出错的可能性。

struct Chain {
  Chain() : next(0) {}
  Chain(Chain *n) : next(n) {}
  ~Chain() {delete next;}
  Chain* next; 
  Chain& operator *(Chain* b);
};
Chain& Chain::operator *(Chain* b) { 
   if (b != next) {
     if (next) { delete next; }
     next = b;
   }
   return *this; 
}

int main() {
  Chain fetters;
  /* since * is left associative, it tries to 
     call operator*(Chain&, const SourcePacket&)
     */
  fetters * new Chain();
  // This compiles
  fetters * (new Chain());
}

要解决这个问题，我们需要定义适当的运算符。对于返回类型，您可以定义模板类的层次结构，将左侧参数与 SourcePacket 配对，并在右侧参数中交换 ((a:A ⊙ b:SourcePacket) * c:C) = (a: A ⊙ c:C) * b:SourcePacket，其中 ⊙ 是一些二进制 C++ 运算符)。像下面这样的东西，但没有它无疑拥有的错误。

template <typename L, typename Rslt=L, typename R=const SourcePacket> 
struct PairedTraits {
    typedef L Left;
    typedef R Right;
    typedef Rslt Result;
    typedef PairedTraits<Result> ResultTraits;
};

template <typename L, typename Traits = PairedTraits<L> >
struct Paired {
    typedef typename Traits::Left Left;
    typedef typename Traits::Right Right;
    typedef typename Traits::Result Result;
    typedef Paired<typename Traits::Result, typename Traits::ResultTraits> ResultPaired;

    Left& left;
    Right& right;

    Paired(Left& l, Right& r) : left(l), right(r) {} 
    operator Left&() {return left;}

    template <typename A>
    ResultPaired  operator*(const C& c) const
    {return ResultPaired(this->left * c, this->right); }
};

template <typename L, typename Traits = PairedTraits<L> >
struct MultPaired : Paired<L, Traits> {
    typedef Paired<L, Traits> Base;
    typedef Paired<typename Traits::Result, typename Traits::ResultTraits> ResultPaired;

    MultPaired(typename Traits::Left& l, typename Traits::Right& r) : Base(l, r) {} 

    template <typename A>
    ResultPaired  operator*(const C& c) const
    {return ResultPaired(this->left * c, this->right); }
};

template <typename L, typename Traits = PairedTraits<L> >
struct ModPaired : Paired<L, Traits> {
    typedef Paired<L, Traits> Base;
    typedef Paired<typename Traits::Result, typename Traits::ResultTraits> ResultPaired;

    ModPaired(typename Traits::Left& l, typename Traits::Right& r) : Base(l, r) {} 

    template <typename A>
    ResultPaired operator*(const C& c) 
    {return ResultPaired(this->left % c, this->right); }
};

template <typename L, typename Traits = PairedTraits<L> >
struct DivPaired : Paired<L, Traits> {
    typedef Paired<Traits> Base;
    typedef Paired<typename Traits::Result, typename Traits::ResultTraits> ResultPaired;

    DivPaired(typename Traits::Left& l, typename Traits::Right& r) : Base(l, r) {} 

    template <typename A>
    ResultPaired operator*(const C& c) const
    {return ResultPaired(this->left / c, this->right); }
};

Paired 的 child 可以返回一个 Result (left ⊙ c, 或者 left ⊙ (right * c), 这基本上使得 *(const SourcePacket&, T) right associative) 而不是 Paired。例如:

template <typename L, typename Traits = PairedTraits<L> >
struct DivPaired : Paired<L, Traits> {
    typedef Paired<L, Traits> Base;

    MultPaired(typename Traits::Left& l, typename Traits::Right& r) : Base(l, r) {} 

    template <typename A>
    Result  operator*(const C& c) const
    {return this->left / (this->right * c); }
};

关于c++ - 用户调用 operator new 时的分配/对象详细信息拦截和收集问题，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/4270185/