Const correctness of pointers against safe checks during initialization - c++

Question

Consider a class that allocates a block of memory to use:
typedef unsigned char byte;
class ByteBuffer
{
byte* const m_begin; // const pointer, non-const data
byte* const m_end; // const pointer, non-const data
byte* m_pData; // a non-const pointer, e.g. write-head
public:
ByteBuffer(size_t byteBufferSize)
: m_begin(new byte[byteBufferSize],
m_end(m_begin + byteBufferSize),
m_pData(m_begin)
{}
~ByteBuffer() { delete[] m_begin; }
};
If I want the code maintained, it's nice to ensure that m_begin and m_end are const so as to ensure any math operations regarding the size of the container will be correct (and that someone else coming in won't accidentally update the edges. But the drawback is that I can no longer initialize the data anywhere outside of the constructor's initialization list.
Rare as std::bad_alloc may be, I'm not convinced that calling new[] like I did above is a good idea. So my question is: how would we deal with wanting const pointers to memory to be managed in a class?
I would want the constructor to do something akin to this:
: m_begin(nullptr), m_end(nullptr), m_pData(nullptr)
{
// initialize here
// if initialization is successful, set const & non-const ptrs
}
Am I overthinking this? Does making m_begin a const unique_ptr make all the initialization woes go away somehow?

Answer 1

The above code is essentially the correct way to write it. However, you could consider using std::vector instead as you won't have to explicitly manage memory.
If fact, std::vector already define begin() and end() (which would replace m_pData in your code) and you won't really need m_end replacement as you don't manage the memory yourself.
The equivalent would be begin() + capacity() but as element are not initialized after end you should not access those anyway (probably undefined behavior from language point of view).
Otherwise small improvements are possible like:
Avoid m_ for member variable name. Not much useful.
Avoid p prefix for pointer to data.
In the initialization list, put comma on the beginning of a line (as you have done for :) instead of at the end of previous line. It make it easier to add, remove, move or comment out items when done that way.
If you don't want your object to be moveable or copyable, it is preferable to explicitly specify it:
public:
ByteBuffer(const ByteBuffer &) = delete;
ByteBuffer(ByteBuffer &&) = delete;
ByteBuffer &operator=(const ByteBuffer &) = delete;
ByteBuffer &operator=(ByteBuffer &&) = delete;
Alternatively, you could also use std::unique_ptr and then you won't have to free memory yourself. This could be useful when you class need to make multiple allocations or when an exception could be thrown after the allocation in the constructor.
The best solution really depends on what you want to do with your ByteBuffer class or even if you really need such a class (as you might use std::vector directly instead or doing a simple alias like:
using ByteBuffer = std::vector<unsigned char>;
If fact, the byte typedef might not even be that much useful if you use auto for your loops and iterators.
Speaking of const, I would generally recommend to have it to prevent undesired changes. However, sometime you need to reset those pointers to nullptr during destruction of somewhat complex classes where there could be some mutual destruction for example.
So by having simple classes that respect the SRP (single responsabilty principle), you essentially avoid that kind of problems.