put class with pointer that is malloc allocated into map container

Question

I'd like to use the map for key/member search, the problem is that the class contains a member of buffer allocated by the malloc call.

struct Key {
    int key1;
    int key2;
    bool operator < (Key & a) { .... } 
};

struct Entity {
    unsigned char *data; 
};

typedef std::map(Key, Entity) TMap;

Then I can insert data with key like:

Tmap map;
Key key;
Entity ent;
ent.data = malloc(size);
key.key1 = xx;
key.key2 = xx;

map.insert( ...(key,ent));

---

The problem is that I'd like the "ent.data" pointer automatically freed when map is deleted. Also at the same time, I want I can access the "data" when do a map find operation to read the buffered data.

I tried to add destructor to the struct Entity, but it seems it leads to some duplicated free issue.

What's the solution?

[Solution]: 1. use shared_ptr:

typedef std::tr1:shared_ptr(unsigned char) CharPtr;

struct Entity {
  CharPtr data;
}

ent.data = CharPtr((unsigned char*)malloc(size), free);

Or another solution. Use Vector as Eugene Homyakov mentioned.

Answer 1

1. You should be using new and not malloc in c++. And
2. You should use Smart pointers instead of raw pointers/naked pointers inside your container.

STL containers do not take the responsibility of deallocating an element which is allocated on the freestore. Which means you would have to deallocate them explicitly. The best way to achieve this is using smart pointers, Using smart pointers you do no have to free the dynamic memory explicitly but the elements themselves take care of deallocating its own resources.

The RAII/SBRM feature of C++ was explicitly designed for avoiding problems such as the one you are facing.

Answer 2

Classic approach would be to implement copy constructor, assignment operator and destructor in Entity. It is also recommended to put allocation code inside Entity, too.

However, there is much simpler solution here: use vector<unsigned char> instead of dynamically allocated memory:

struct Entity { std::vector<unsigned char> data; }

• You can access the memory via &data[0]
• It is guaranteed that vector's elements are linear in memory
• It will be automatically deleted when Entity is deleted
• It will be properly copied when Entity is copied
• You can “allocate” and “reallocate” simply by calling data.resize(newsize)

Also you don't even need the insert:

Key key;
// initialize key
Entity& ent = map[key]; // automatically creates Entity for the key
// work with ent now 
ent.data.resize(bufferSize);
unsigned char* dataPtr = &ent.data[0];

Answer 3

Entity needs to contain a member that indicates the size of the data was allocated. It also needs a destructor and a copy constructor. It'd be best if you added a couple of member functions to allocate and free data.

struct Entity {
  Entity() : data_(NULL), length_(0) {}

  Entity( size_t length ) : data_(NULL), length_(0)
  { 
    allocate( length );
  }

  Entity( const Entity& other )
  {
    free();
    allocate( other.length );
    std::copy( other.data_, other.data_ + other.length_, data_ );
  }

  void allocate( size_t length )
  {
    free();
    data = malloc( length );
    if( data != NULL ) {
      length_ = length;
    }
  }

  void free()
  {
    if( length_ != 0 ) { 
      free( data_ ); 
    }
  }

  ~Entity() { free(); }

private:
  unsigned char *data_,
  size_t length_;
};

typdef std::map<struct Key, struct Entity> TMap;

You'll probably want to also provide accessor functions to retrieve a pointer to the data and length of Entity.

Finally, since you're using C++ you shouldn't be using raw pointers. Consider using std::unique_ptr instead. Also, it is preferable to use new and delete instead of malloc and free.

Answer 4

One simple solution is replace your malloc-ed pointer to array of unsigned char, with a std::vector<unsigned char>. Voilá, it just works.

PS1: Or, seeing as you're apparently providing your own comparision, it works if you define good comparision operator.

PS2: If you absolutely want to use malloc then you can define a custom allocator and use that with std::vector; it's a template parameter.

Cheers & hth.,