I have a project in which I have to allocate 1024 bytes when my program starts. In C program.

void* available = new char*[1024];

I write this and I think it is okay. Now my problem starts, I should make a function that receives size_t size (number of bytes) which I should allocate. My allocate should return a void* pointer to the first bytes of this available memory. So my question is how to allocate void* pointer with size and to get memory from my available.

I'm a student and I'm not a professional in C . Also sorry for my bad explanation.

CodePudding user response：

It looks like you're trying to make a memory pool. Even though that's a big topic let's check what's the minimal effort you can pour to create something like this.

There are some basic elements to a pool that one needs to grasp. Firstly the memory itself, i.e. where do you draw memory from. In your case you already decided that you're going to dynamically allocate a fixed amount of memory. To do it properly the the code should be:

char *poolMemory = new char[1024];

I didn't choose void* pool here because delete[] pool is undefined when pool is a void pointer. You could go with malloc/free but I'll keep it C . Secondly I didn't allocate an array of pointers as your code shows because that allocates 1024 * sizeof(char*) bytes of memory.

A second consideration is how to give back the memory you acquired for your pool. In your case you want to remember to delete it so best you put it in a class to do the RAII for you:

class Pool
{
  char *_memory;
  void *_pool;
  size_t _size;

public:
  Pool(size_t poolSize = 1024)
    : _memory(new char[poolSize])
    , _pool(_memory)
    , _size(poolSize)
  {
  }

  ~Pool() { delete[] _memory; } // Forgetting this will leak memory. 
};

Now we come to the part you're asking about. You want to use memory inside that pool. Make a method in the Pool class called allocate that will give back n number of bytes. This method should know how many bytes are left in the pool (member _size) and essentially performs pointer arithmetic to let you know which location is free. There is catch unfortunately. You must provide the required alignment that the resulting memory should have. This is another big topic that judging from the question I don't think you intent to handle (so I'm defaulting alignment to 2^0=1 bytes).

#include <memory>

void* Pool::allocate(size_t nBytes, size_t alignment = 1)
{
    if (std::align(alignment, nBytes, _pool, _size))
    {
        void *result = _pool;
        // Bookkeeping
        _pool = (char*)_pool   nBytes; // Advance the pointer to available memory. 
        _size -= nBytes;               // Update the available space. 
        
        return result;
    }
    return nullptr;
}

I did this pointer arithmetic using std::align but I guess you could do it by hand. In a real world scenario you'd also want a deallocate function, that "opens up" spots inside the pool after they have been used. You'd also want some strategy for when the pool has run out of memory, a fallback allocation. Additionally the initially memory acquisition can be more efficient e.g. by using static memory where appropriate. There are many flavors and aspects to this, I hope the initial link I included gives you some motivation to research a bit on the topic.