Re: Question on use of "placement" new
Martin T schrieb:
I do not like the solution where the flat data area starts "inside" the
object. I think you quite correctly point out that you would have to put
the element last and even then you're not really on the safe side.
I would rather place your fData2 member as a normal pointer inside the
object and have it reference memory just beyond the object. This way you
do not have to worry where your C++ implementation puts the fData2
member inside the object and its functionally still the same -- namely
that you have a "flat" object.
Also, there is the problem of telling the object how big the additional
memory is, which I've solved with a ctor taking the same argument as the
placement new.
I *think* my solution below is clearer, but note that this is the first
time I've ever done operator new/delete overloading so I may well have
overlooked something ...
Why the complicated way if there is a simple, easy and straight forward
solution?
class Foo1 {
int fData1;
Barr *fpData2;
public:
Foo1(int count)
: fpData2(new Barr[count])
{ }
~Foo1()
{
delete[] fpData2;
}
// operator= and copy constructor left as an exercise for
// the reader
};
This is easy, doesn't require any overloading of operators, and can be
used exactly the same way as the hacky approach.
class ShmMan {
// Use this as a base class, so make the operators protected
protected:
static void* operator new(size_t size) {
return ::malloc(size);
What happens if malloc fails?
Where is new[]?
class Flat : public ShmMan {
size_t datasize_;
char* data_;
private: // Explicitly disable the normal new operator
static void* operator new(size_t size);
public:
// provide matching pair of new and delete:
static void* operator new(size_t size, size_t datasize) {
return ShmMan::operator new(size + datasize);
}
static void operator delete(void* p, size_t datasize) {
ShmMan::operator delete(p);
}
You also need to make operator delete(void *p) available or you cannot
delete the objects.
// This ctor tells the object how big the additionally allocated
// memory is:
explicit Flat(size_t s) {
datasize_ = s;
// If this ctor is used, assume that there is sufficient
// memory allocated just "behind" this:
void* self = this;
void* beyond_self = static_cast<char*>(self) + sizeof(Flat);
data_ = static_cast<char*>(beyond_self);
memset(data_, 0, datasize_);
Why does that do the right thing?
}
// assign data to our "flat" object:
void assign_data(const char* str) {
if(data_ && str) {
memcpy(data_, str, std::min(datasize_, strlen(str)));
data_[datasize_-1] = '\0';
Why does that the right thing?
So long,
Thomas
--
[ See http://www.gotw.ca/resources/clcm.htm for info about ]
[ comp.lang.c++.moderated. First time posters: Do this! ]