Convert byte array into std data type

Question

Um, hello. I'm trying to write a custom stack memory allocator to help with my game programming, and have run into an issue. So, let's say my allocator has a char* buffer, and I want to get some memory for an int:

class MemoryStack
{
public:
MemoryStack(unsigned size)
{
mSize=size;
mTop=0;
mBuffer = new(std::nothrow) char [size];
}

char* allocate(unsigned size)
{
if (mTop + size > mSize)
return nullptr;
char* out = mBuffer+mTop;
mTop+=size;
return out;
}

private:
char* mBuffer;
unsigned mTop;
unsigned mSize;
};

int main ()
{
MemoryStack stack(1024);
int testval = 6;
int* ptr = (int*)stack.allocate(sizeof(int));
*ptr = testval;
std::cout<<*ptr;
}

Now, this works, and prints out 6. However, when I try something like:

int main ()
{
MemoryStack stack(1024);
std::string str = "HELLO :p";
std::string* strptr = (std::string*)stack.allocate(sizeof(std::string));
*strptr = str ;
std::cout<<*strptr;
}

...This gives me a Bad Ptr problem, and a segmentation fault, crashing my program. Can anyone explain why this is? Could this be because of some operator = overloading? And would there be any way to safely handle this? Thanks!

Edit: The following code is my currently final implementation after the help I received - it's not thoroughly tested, but seems to work as intended. I'll naturally modify it if any bugs are found, but as to help out anyone interested, here it is ^_^ Feel free to use it if you wish, although it's hardly the summit of computer science.

class MemoryStack;

/**Serves as a bookmark for the memory stack in order to allow to clear only part of the memory.*/
class MemoryBookmark
{
private:

    /**Private constructor may only be called by the memory stack object.*/
    MemoryBookmark(unsigned value)
    {
        mBookmark = value;
    }

    unsigned mBookmark;

public:
    friend class MemoryStack;

    /**Returns the index of the position that will be the new stack top pointer.*/
    decltype(mBookmark) getValue() const
    {
        return mBookmark;
    }
};

/**Acts as a basic memory stack to help reduce allocation costs, as well as add to the fun! Use with care, as destructors must be called manually.*/
class MemoryStack
{
private:
    char* mBuffer;
    size_t mTop;
    size_t mCapacity;
    size_t mAlignment;

public:

    /**Initialises the class, reserving _capacity_ bytes for use. It can not be resized for efficiency purposes.*/
    MemoryStack(unsigned capacity)
    {
        mCapacity = capacity;
        mTop = 0;
        mBuffer = new(std::nothrow) char[capacity];
        mAlignment = 4;
    }

    /**Frees the memory, invalidating all internal memory. Doesn't call destructors.*/
    ~MemoryStack()
    {
        if (mBuffer)
            delete[] mBuffer;
    }

    /**Creates an instance of the given type with Args if possible, using aligned internal memory.*/
    template <typename T, typename... Args>
    void create(T*& ptr, Args&&... args)
    {
        ptr = (T*)allocate(sizeof(T));
        if (!ptr)
            return;
        else
            new (ptr)T(std::forward<Args>(args)...);
    }

    /**Calls the destructor of the pointer. Must be used if destruction important.*/
    template<typename T>
    void destroy(T* ptr)
    {
        ptr->~T();
    }

    /**Allocates a piece of memory for use.*/
    void* allocate(size_t amount)
    {
        size_t bt = (size_t)(mBuffer + mTop);
        size_t alignoffset = mAlignment - (bt & (mAlignment - 1));
        alignoffset = alignoffset == mAlignment ? 0 : alignoffset;
        size_t size = amount + alignoffset;
        if (size + mTop > mCapacity)
            return nullptr;
        else
        {
            mTop += size;
            return (void*)(bt + alignoffset);
        }
    }

    /**Returns the amount of memory used.*/
    size_t size() const
    {
        return mTop;
    }

    /**Returns the size of the memory reserved for use.*/
    size_t capacity() const
    {
        return mCapacity;
    }

    /**Returns the number of bytes remaining for allocation.*/
    size_t remaining() const
    {
        return mCapacity - mTop;
    }

    /**Checks whether the internal memory was allocated successfully.*/
    bool isValid() const
    {
        return mBuffer != nullptr;
    }

    /**Creates a 'bookmark' which can be used to clear the stack until a given point.*/
    MemoryBookmark createBookmark() const
    {
        return MemoryBookmark(mTop);
    }

    /**Resets the stack. All data inside may now be overwritten. Doesn't call destructors.*/
    void reset()
    {
    mTop = 0;
    }

    /**Resets the stack up to a given bookmark. Again, no destructors called!*/
    void resetToBookmark(const MemoryBookmark bookmark)
    {
        mTop = bookmark.getValue();
    }

    /**Sets the alignment of the reservations in memory.*/
    void setAlignment(size_t alignment)
    {
        mAlignment = alignment;
    }

    /**Returns the currently used alignment.*/
    decltype(mAlignment) getAlignment() const
    {
        return mAlignment;
    }
};

/**Test class.*/
class Test
{
public:
    Test(int val)
    {
        v = val;
        std::cerr << "Constructor\n";
    }

    ~Test()
    {
        std::cerr << "Destructor";
    }

    int v;
};

/**Test it! XD*/
int main()
{
    using namespace std;
    {
        MemoryStack stack(4096);

        Test* test=nullptr;
        int* i1, *i2;
        char* c1, *c2;
        stack.create(test,3);
        stack.create(i1, 2);
        stack.create(c1, 'a');
        stack.create(i2, 3);
        stack.create(c2, 'm');
        stack.destroy(test);
        stack.reset();
    }

    cin.get();
}

Just wondering if it is really necessary to roll your own. Isn't there some FOSS you can use which will let you get on with the fun stuff? There are lots of free game frameworks & memory allocators which are fully developed, well tested & well supported. Even if you can do better (no offence), do you want to take the time to do so? — Mawg
– Mawg, Commented Nov 28, 2014 at 13:39
Ah, you are probably right... But I'm a student above all, and it feels good to know how to do these things ^_^ Plus, this would leave me with more control, and allow me to extend these structures when needed. — user2898624
– user2898624, Commented Nov 28, 2014 at 13:46

Wintermute · Accepted Answer · 2014-11-28 18:16:59Z

1

An uninitialized region of memory does not a std::string make. You have to construct an object into the region with placement new like so:

std::string *strptr = (std::string*) stack.allocate(sizeof(std::string));
new (strptr) std::string;

It is worth thinking about doing this in a central place, such as a member function template in MemoryStack.

EDIT:

I forgot to mention this earlier, which is a pity because it is bloody important:

If you construct objects with placement new, you have to destruct them manually as well. They're not going to do it themselves because they don't have automatic storage duration, and you can't use delete because the memory wasn't allocated with new. The syntax is pretty straightforward:

strptr->~string();

It would be a good idea to make both parts of this a part of MemoryStack, for example like this:

class MemoryStack {
  ...

  template<typename T, typename... Args>
  T *create(Args&&... args) {
    T *ptr = allocate(sizeof(T));
    try {
      new(ptr) T(std::forward<Args>(args)...);
    } catch(...) {
      deallocate(ptr);
      throw;
    }

    return ptr;
  }

  template<typename T>
  void destroy(T *ptr) {
    ptr->~T();
    deallocate(ptr);
  }

  ...
};

to later write

std::string *strptr = stack.create<std::string>("foo");

...

stack.destroy(strptr);

or so. Pro tip: Build yourself a deleter you can use in conjunction with std::unique_ptr and std::shared_ptr to make exception safety easy.

edited Nov 28, 2014 at 18:16

answered Nov 28, 2014 at 13:29

Wintermute

44.3k5 gold badges84 silver badges85 bronze badges

Sign up to request clarification or add additional context in comments.

2 Comments

user2898624 Over a year ago

Oh my, thank you! This seems to act quite beautifully. I haven't used the placement new before, so will have to investigate regarding the performance implications and how to use it properly. But I just tried it now, and it does indeed work!

user2898624 Over a year ago

Oh my, I see. Thanks! I took your advice, and modified my code to allow for proper destructors. Sadly I'm not yet fully familiar with the advanced C++11 features, so I chose to keep the memory stack rather simple, although sufficient for my purposes. I'll put my final implementation in an edit above.

alonewenson · Accepted Answer · 2014-11-28 14:02:57Z

0

you are trying to allocate size of std::string std::string* strptr = (std::string*)stack.allocate(sizeof(std::string));

you probably meant something like std::string* strptr = (std::string*)stack.allocate(str.size()));

Wintermute's is a nice idea but it probably wont do what you want a. your allocate function will return nullptr b. the "new" will allocate a new memory area, not in your "heap"

probably won't crash though...

Draknghar: (i'm to young to add comments) changed my mind. it will work. but you didn't set mTop... something seems wrong in doing it that way. you already have you array and your trying to allocate new memory in it? why? just copy your string into it, and set mTop.

edited Nov 28, 2014 at 14:02

answered Nov 28, 2014 at 13:29

alonewenson

413 bronze badges

1 Comment

user2898624 Over a year ago

I just tried it, and it seems to work. The new they used seems to be placement new, I think. Thus, it should be within my memory stack. Thanks though!

Collectives™ on Stack Overflow

Convert byte array into std data type

2 Answers 2

2 Comments

1 Comment

Your Answer

Hot Network Questions

Collectives™ on Stack Overflow

2 Answers 2

2 Comments

1 Comment

Your Answer

Sign up or log in

Post as a guest

Related