9

假设我有一个 X 类：

struct X
{
   ...
};

我有一个全局向量 V：

vector<X*> V;

我想将 X 的新实例添加到 V 当且仅当它是动态分配的（作为完整的最派生对象，而不是子对象）：

int main()
{
    X x; // not added to V
    new X; // added to V

    struct D : X {};
    new D; // not added to V
}

有没有办法做到这一点？也许通过某种方式重载/覆盖operator new？

4

3 回答 3

8 
struct X {
public:
    static void* operator new(std::size_t size) {
        void* p = ::operator new(size);
        if (size == sizeof(X))
            V.push_back(static_cast<X*>(p));
    }
    static void operator delete(void* p, std::size_t size) {
        if (size == sizeof(X))
            V.erase(std::remove(V.begin(), V.end(), p), V.end());
        ::operator delete(p, size);
    }
};

请注意，有时V指向内存的元素还不是或不再是实际的X. 用户可以绕过这些功能，但他们必须尝试。

如果您有另一个继承X但具有相同大小的类（因此除了可能“空”基类之外没有其他子对象），例如struct Y : public X {};，上面的代码将认为new Y正在分配一个X. 如果这是一个问题，您还需要将operator newand添加operator void到每个此类 class Y。我认为没有更通用的解决方案。

于 2013-05-29T14:13:47.793 回答
6

建立在aschepler的方法上，但现在使用虚拟基类来重定向D的构造函数调用（不向向量添加实例）。

主要思想是进行两步注册：首先，注册对 ( ) 的任何调用（operator new无论是 forX还是派生类）。然后，在构造时，根据最派生的类型进行选择，添加到它是否已被动态分配并且它不是派生类。unordered_setX::dyn_alloc_setXthisV

必须从最派生的类型调用虚拟基类的构造函数，因此您可以使用它来区分构造之间D和X构造期间。

#include <unordered_set>
#include <typeinfo>
#include <vector>
#include <iostream>
#include <algorithm>

struct X;
std::vector<X*> V;

struct virt_base_class
{
    friend struct X;
private:
    virt_base_class(X* p);  // this can only and will only be called by X
public:
    virt_base_class()  // this will be called by any class derived from X
    {}
};

struct X
    : protected virtual virt_base_class
{
private:
    friend class virt_base_class;
    static std::unordered_set<X*> dyn_alloc_set;
    static bool dynamically_allocated(X* p)
    {
        return dyn_alloc_set.count(p) > 0;
    }    

public:
    X()
        : virt_base_class(this)
    {}

    static void* operator new(std::size_t size) {
        void* p = ::operator new(size);
        if (size == sizeof(X))
            dyn_alloc_set.insert( static_cast<X*>(p) );
        return p;
    }
    static void operator delete(void* p, std::size_t size) {
        if (size == sizeof(X))
        {
            dyn_alloc_set.erase( static_cast<X*>(p) );
            V.erase( std::remove(V.begin(), V.end(), static_cast<X*>(p)),
                     V.end() );
        }
        ::operator delete(p);
    }
};


virt_base_class::virt_base_class(X* p)
{
    if( X::dynamically_allocated(p) )
        V.push_back(p);
}

struct D : X
{};  // D::D will implicitly call virt_base_class::virt_base_class()


std::unordered_set<X*> X::dyn_alloc_set;


int main()
{
    X x;
    X* p = new X;
    D d;
    D* pd = new D;

    std::cout << V.size();
}

更新：使用thread_local存储来避免unordered_set：

struct X
    : protected virtual virt_base_class
{
private:
    friend class virt_base_class;
    static thread_local X* last_dyn_allocated;
    static bool dynamically_allocated(X* p)
    {
        return p == last_dyn_allocated;
    }

public:
    X()
        : virt_base_class(this)
    {}

    static void* operator new(std::size_t size) {
        void* p = ::operator new(size);
        if (size == sizeof(X))
        {
            last_dyn_allocated = static_cast<X*>(p);
        }
        return p;
    }
    static void operator delete(void* p, std::size_t size) {
        if (size == sizeof(X))
        {
            X* pp = static_cast<X*>(p);
            if(last_dyn_allocated == pp)
                last_dyn_allocated = nullptr;

            V.erase( std::remove(V.begin(), V.end(), pp),
                     V.end() );
        }
        ::operator delete(p);
    }
};

thread_local X* last_dyn_allocated = nullptr;
于 2013-05-29T14:23:35.187 回答
1

我认为你想要的最好的近似是强制使用工厂来动态分配对象：

#include <algorithm>
#include <utility>
#include <vector>

class X {
  static std::vector<X*> dynamic_xs;

  static void* operator new(std::size_t size) {
    return ::operator new(size);
  }

public:
  ~X() {
    auto end = std::end(dynamic_xs);
    auto pos = std::find(std::begin(dynamic_xs), end, this);
    if (pos != end) {
      if (pos != --end) {
        std::iter_swap(pos, end - 1);
      }
      dynamic_xs.pop_back();
    }
  }

  template <typename... Args>
  friend X* make_x(Args&&... args) {
    X* p = new X(std::forward<Args>(args)...);
    dynamic_xs.push_back(p);
    return p;
  }
};

std::vector<X*> X::dynamic_xs;

客户端可以实例化 stack-allocated X，但动态分配会导致访问错误，因为operator newis private。

于 2013-05-29T14:42:43.057 回答