C++ equivalent of C VLAs and subsequent issues with offsetof
I have two apologies to make up front. Firstly, my apologies for the
long post, and secondly my apologies for posting some C, but I hope
that you can understand the relevance to my C++ question.
I have a C++ class which is currently not strictly conforming as it
uses offsetof on a non-POD struct, but I was hoping that someone could
suggest what the best approach to making it conforming would be, with
going completely down the C route or introducing any extra performance
overheads.
The class is a shareable buffer implementation which is designed for
use as a private inner class for a string implementation in which the
primary goals are low memory overhead and fast copies, but
modification of strings after construction is not required (i.e. no
append, no resize and no functions returning modifiable iterators of
pointers to the controlled string). The implementation strategy is to
have a shareable unmodifiable buffer with a reference count.
Rather than go through the details one by one, I include the commented
code. There are two major things that I don't like about the current
implementation.
The first is the rather ugly definition of m_str, as a char[MAX_LEN].
The traditional "struct hack" uses char[1], but strictly this causes
undefined behaviour when you access m_str[n] for n > 0 even if the
class has been constructed in place with sufficient memory. It would
be nice if C++ supported C90 style VLAs.
The second is the use of offsetof which is technically illegal. To
make the class a POD-struct to allow the use of offsetof I would have
to lose the constructor and make the data members public. Needless to
say, this is very undesirable as it opens the internals to clients and
also runs the risk of clients attempting to allocate the full 2GB
struct.
Any suggestions would be greatly appreciated. The only other solution
that I could think of was to go the C route completely and define a
bunch of functions working on a struct pointers for which the struct
is not publicly defined but this is far from the desirable C++ style
that I was attempting to get with my initial C++ class.
For reference I have also supplied a C version which is, AFAIK,
compliant with ISO/IEC 9899:1999, which is slightly frustrating as I
would much prefer compliant C++ version without reverting to using C++
as a (not really any) better C.
// mybuffer.h
#ifndef MYBUFFER_H
#define MYBUFFER_H
#include <cstring>
class MyBuffer
{
public:
// Allocation and construction must happen through this special
// static member function...
static MyBuffer* Create(const char* init, std::size_t len)
{
return new (len) MyBuffer(init, len);
}
// ... but destruction and deallocation is fine with a
// standard delete expression
void operator delete(void* p)
{
::operator delete(p);
}
const char* c_str() const { return m_str; }
std::size_t length() const { return m_length; }
// This is a modified version of a private inner class
// which is responsible for doing a "delete buffer" when
// buffer->remref() returns zero. This is the reason for
// the slightly unconventional addref/remref semantics.
// for a general purpose uses, remref would probably delete
// this and the class would probably be used with a suitable
// "smart" pointer.
void addref() { ++m_refcount; }
int remref() { return --m_refcount; }
private:
// Private constructor, must only be constructed
// via the Create method.
MyBuffer(const char* str, std::size_t len)
: m_refcount(1), m_length(len)
{
if (str != 0 && len != 0)
{
std::memcpy(m_str, str, len);
}
}
// Calculate the true required size and allocate
// the correct amount of memory.
// Alert, UB! This is not a POD-struct so offsetof
// does not work.
void* operator new(std::size_t, std::size_t slen)
{
std::size_t truesize = offsetof(MyBuffer, m_str) + slen;
return ::operator new(truesize);
}
// Although this is a placement delete operator it happens
// to match the "other" allowed form of non-placement delete
// so we need have the "void*" only form of non-placement
// delete to disambiguate this. We needed non-placement
// delete anyway, so this is academic, really.
void operator delete(void* p, std::size_t)
{
::operator delete(p);
}
// Non-portable large value, could be set to a smaller,
// reasonable size if we want to choose a sensible
// restriction.
static const std::size_t MAX_LEN = 0x7ffffff0u;
// Non-static member variables. Note that as they are not
// seperated by an access specifier they are guaranteed to
// be assigned in ascending memory order. Unfortunately
// we are non-POD so that's it for guarantees.
int m_refcount;
// m_length can't be changed, once the correct memory has been
// allocated by our operator new, that's it.
const std::size_t m_length;
// C++ does not have C style VLAs, so we have to define the class
// in terms of the larges supported array.
char m_str[MAX_LEN];
};
#endif//MYBUFFER_H
// end of file
/* mycbuffer.h */
#ifndef MYCBUFFER_H
#define MYCBUFFER_H
#include <stddef.h>
typedef struct tagMyCBuffer MyCBuffer;
void MCB_AllocBuffer(MyCBuffer** ppbuf, const char* init, size_t len);
void MCB_FreeBuffer(MyCBuffer* pbuf);
size_t MCB_GetLength(const MyCBuffer* pbuf);
const char* MCB_GetStr(const MyCBuffer* pbuf);
void MCB_AddReference(MyCBuffer* pbuf);
int MCB_RemoveReference(MyCBuffer* pbuf);
#endif/*MYCBUFFER*/
/* end of file */
/* mycbuffer.c */
#include "mycbuffer.h"
#include "string.h"
#include "malloc.h"
struct tagMyCBuffer
{
int m_refcount;
size_t m_length;
char m_str[];
};
void MCB_AllocBuffer(MyCBuffer** ppbuf, const char* init, size_t len)
{
/* sizeof excludes the last member in structs with a VLA member,
** but includes any padding before the VLA member, so this is
** correct */
*ppbuf = malloc(sizeof(MyCBuffer) + len);
(*ppbuf)->m_refcount = 1;
(*ppbuf)->m_length = len;
memcpy((*ppbuf)->m_str, init, len);
}
void MCB_FreeBuffer(MyCBuffer* pbuf)
{
free(pbuf);
}
size_t MCB_GetLength(const MyCBuffer* pbuf)
{
return pbuf->m_length;
}
const char* MCB_GetStr(const MyCBuffer* pbuf)
{
return pbuf->m_str;
}
void MCB_AddReference(MyCBuffer* pbuf)
{
++pbuf->m_refcount;
}
int MCB_RemoveReference(MyCBuffer* pbuf)
{
return --pbuf->m_refcount;
}
/* end of file */
--
[ See http://www.gotw.ca/resources/clcm.htm for info about ]
[ comp.lang.c++.moderated. First time posters: Do this! ]