"New" and "delete" in a function

Writing a dll for file manipulation, I'm running into some issue.

To read bytes from a file via file.read I require a char* array of the desired length. Since the length is variable, I cannot use

char* ret_chars[next_bytes];

It gives the error that next_bytes is not a constant.

Another topic here in StackOverflow says to use:

char* ret_chars = new char[next_bytes];

Creating it with "new" requires to use "delete" later though, as far as I know.

Now, how am I supposed to delete the array if the return-value of this function is supposed to be exactly this array? Isn't it a memory leak if I don't use "delete" anywhere?

If that helps anything: This is a DLL I'll be calling from "Game Maker". Therefore I don't have the possibility to delete anything afterwards.

Hope someone can help me!

Solution

When you're writing a callback which will be invoked by existing code, you have to follow its rules.

Assuming that the authors of "Game Maker" aren't complete idiots, they will free the memory you return. So you have to check the documentation to find out what function they will use to free the memory, and then you have to call the matching allocator.

In these cases, the framework usually will provide an allocation function which is specially designed for you to use to allocate a return buffer.

Another common approach is that you never return a buffer allocated by the callback. Instead, the framework passes a buffer to your callback, and you simply fill it in. Check the documentation for that possibility as well.

Is there no sample code for writing "Game Maker" plugins/extensions?

It looks like the developers are indeed complete idiots, at least when it comes to design of plugin interfaces, but they do provide some guidance.

Note that you have to be careful with memory management. That is why I declared the resulting string global.

This implies that the Game Maker engine makes no attempt to free the returned buffer.

You too can use a global, or indeed any variable with static storage duration such as a function-local static variable. std::vector<char> would be a good choice, because it's easy to resize. This way, every time the function is called, the memory allocated for the previous call will be reused or freed. So your "leak" will be limited to the amount you return at once.

char* somefunc( void )
{
    static std::vector<char> ret_buffer;

    ret_buffer.resize(next_bytes);
    // fill it in, blah blah
    return &ret_buffer[0];
}
// std::string and return ret_string.c_str(); is another reasonable option

Your script in Game Maker Language will be responsible for making a copy of that result string before it calls your function again and overwrites it.