Can a pointer move itself to a container?

Question

This is a continuation of this question but I don't want to use a custom deleter. I have the following interface:

struct Interface {
  Interface(const Interface &) = delete;
  auto operator=(const Interface &) -> Interface & = delete;
  ~Interface() = 0;
  protected:
    Interface() = default;
};

And an implementation:

struct Implementation : public Interface {
  Implementation(Pool &p) : m_pool{p} {}
  Pool &m_pool;
};

I also have a pool of Implementations:

struct Pool {
  auto get() -> std::unique_ptr<Interface>;
  std::vector<std::unique_ptr<Interface>> m_objects;
};

My question is if it is possible to have the Implementation, instantiated as a pointer to Interface, move itself into the pool when its destructor is called?

@Someprogrammerdude Edit: whoops, read it backwards once again. You're right, I got confused by the conflation of the pointer and the pointee. — Quentin, Feb 12 '19 at 12:22
Side-note (I suppose): what's that reference to `Pool` inside `Pool` itself? — Quentin, Feb 12 '19 at 12:28
Implementation has a reference to the Pool. When the destructor of Imp is called I want Imp to move itself into the pool. — ruipacheco, Feb 12 '19 at 12:31
But if you move Implementation to Pool in the destructor (or after) your pointer will be invalid.. — RedX, Feb 12 '19 at 12:38
IMHO, it would be simpler to use a custom deleter in the `unique_ptr`. That way only the unique pointer has to be aware of the pool not the object itself. — Serge Ballesta, Feb 12 '19 at 13:44
But OTOH I'd have to provide an object with a custom deleter to the user. — ruipacheco, Feb 12 '19 at 13:53
You could achieve this using a class-specific `operator new` and `operator delete` that operate with the pool, but then you have to really delete the objects when the pool is destroyed. — Gem Taylor, Feb 12 '19 at 13:53
@ruipacheco Much as I would like the points, you are better off reading up about these methods for yourself, and decide if they are appropriate in your case. — Gem Taylor, Feb 12 '19 at 14:08
@GemTaylor you don't have a specific idea on how it applies to my case? — ruipacheco, Feb 12 '19 at 14:18
With operator new and operator delete members in your class, any code that tries to new or delete an instance of your object calls your methods instead of the default methods, and your methods can interact with your pool. — Gem Taylor, Feb 12 '19 at 14:21
Possible duplicate of [C++ object-pool that provides items as smart-pointers that are returned to pool upon deletion](https://stackoverflow.com/questions/27827923/c-object-pool-that-provides-items-as-smart-pointers-that-are-returned-to-pool) — gkamal, Feb 14 '19 at 11:53

score 3 · Accepted Answer · answered Feb 12 '19 at 12:28

3

I think you can achieve it by creating a wrapper. It is kind of like borrowing an object from the pool which will then be put back into the pool once the wrapped object goes out of scope.

struct PooledObject {
  PooledObject(Pool& pool, std::unique_ptr<Interface> object) 
        : m_object(std::move(object)), m_pool(pool) {}
  ~PooledObject() {
       m_pool.put(std::move(m_object));
   }
  // implement -> for easy access to underlying object
  std::unique_ptr<Interface> m_object;
  Pool& m_pool;
};

struct Pool {
  auto get() -> PooledObject;
  void put(std::unique_ptr<Interface> object);
}

answered Feb 12 '19 at 12:28

gkamal

20,777
4
60
57

1

In that case it's better to use a custom deleter then? – ruipacheco Feb 12 '19 at 12:33
@ruipacheco Maybe that will work, you will need to update the deleter before returning the object from the pool and then again before putting it back. – gkamal Feb 12 '19 at 12:51
By deleted you mean the custom deleter? – ruipacheco Feb 12 '19 at 12:55

Can a pointer move itself to a container?

1 Answers1