2

一部のデータを取得して処理する関数を作成する必要があります。このデータは、いくつかの方法で割り当てることができます（データセグメント、ヒープ、共有メモリセグメントなど）。

T *data;
if( global ) data = &d;
if( heap )   data = new T [ size ];
if( shm )    data = (T*) shmat( id, 0, 0 );
// processing data ...

動的に割り当てられる可能性があるので、それを処理する最良の方法は、または他の種類のスマートポインタdataを使用することだと思います。unique_ptrただし、常に動的に割り当てられるわけではありません。実行時にの削除機能を選択する必要がありますunique_ptrが、それは不可能です。

どのように定義して処理する必要がありますdataか？

4

5 に答える 5

6

カスタムデリータに実行時の値をとらせることができます！

struct MyCustomDeleter
{
   MemoryType type;
   template <typename T>
   void operator()(T* value) const
   {
      switch (type)
      {
         case MemoryType::heap:
             delete[] value;
             break;
         case MemoryType::shm:
             unmap_from_shm(value);
             break;
         // etc.
      }
   }
};

...

std::unique_ptr<T, MyCustomDeleter> ptr (new T[size], 
                                         MyCustomDeleter{MemoryType::heap});
于 2012-03-02T15:11:26.953 に答える
3

についてはよくわかりませんstd::unique_ptrが、使用できますstd::shared_ptr。そのカスタムデリータは、クラステンプレートパラメータに依存しません。

于 2012-03-02T15:10:38.443 に答える
3

KennyTmの良い答えに加えて、別の可能性は、関数ポインターを削除ツールとして使用し、実行時にさまざまな関数を提供することです。

typedef std::unique_ptr<T, void(*)(void*)> Ptr;
void delete_global(void*);
void delete_heap(void*);
// etc.

Ptr get(/* whatever */)
{
    if ( ... )
       return Ptr(data, delete_global);
    if (... )
       return Ptr(data, delete_heap);

    // etc.
}
于 2012-03-02T16:20:53.480 に答える
1

共有を使用する場合はshared_ptr<>、実行時に削除ツールを選択できます。コピーしない限り/...shared_ptrそれは。と同じように動作するはずunique_ptrです。

于 2012-03-02T15:10:46.040 に答える
1

選択した削除ツールで独自のスマートポインターを使用します。

enum DataPointerType
{
    Stack,
    Dynamic,
    SharedMem,
    ...
};

template <class T>
class DataPointer
{
public:
    DataPointer(T* pointer, DataPointerType type)
        : _ptr(pointer), _type(type)
    { }

    ~DataPointer()
    {
        switch (type) {
        case Stack: break;
        case Dynamic: delete _ptr; _ptr = nullptr; break;
        ...
        }
    }

    T& operator*() { return *_ptr; }
    const T& operator*() const { return *ptr; }

    T* operator->() { return _ptr; }
    const T* operator->() const { return ptr; }

private:
   T* _ptr;
    DataPointerType _type;

    // Prevent copying and destruction, dangerous
    DataPointer(const DataPointer& other);
    DataPointer& operator=(const DataPointer& other);
};
于 2012-03-02T15:08:49.353 に答える