new/delete operator, creating a class in the location as deleted class

You want "placement new". One link is http://www.glenmccl.com/tip_025.htm. A quick google will give you more.

I see if I can work up an example.

04.25.2008 at 09:40PM PDT, ID: 21444534

Rank: Master

Here's the example I promised

#include <cstddef> // for std::size_t
#include <memory>
#include <iostream>

class COne {
public:
// placement new takes an additional parameter, a void* in this case
static void* operator new(std::size_t size, void* location){ return ::operator new(size,location); }
// need a corresponding placement delete (only called when an exception is thrown)
static void operator delete(void *pMemory, void *ptr) { ::operator delete(pMemory,ptr); }
// global operator new hidden by placement new, so must define one here
static void* operator new(std::size_t size) { return ::operator new(size); }
// ditto for the global operator delete, hidden by the placement delete
static void operator delete(void *pMemory) { ::operator delete(pMemory); }
//
private:
char a;
};

class CTwo {
public:
// placement new and delete
static void* operator new(std::size_t size, void* location){ return ::operator new(size,location); }
static void operator delete(void *pMemory, void *ptr) { ::operator delete(pMemory,ptr); }
// Standard new and delete
static void* operator new(std::size_t size) { return ::operator new(size); }
static void operator delete(void *pMemory) { ::operator delete(pMemory); }
private:
double b;
};

void main() {
int sizeRequired = sizeof(CTwo); // since it is larger
unsigned char* allocation(new unsigned char[sizeRequired]);
COne* p = new (allocation) COne;
std::cout << "COne allocated at location " << std::hex << p << std::endl;
// >>No<< delete p; Don't delete here because that deletes the new unsigned char[sizeRequired] allocation
CTwo *pp = new (allocation) CTwo;
std::cout << "CTwo allocated at location " << std::hex << pp << std::endl;
delete pp;
}

Accepted Solution

04.25.2008 at 10:57PM PDT, ID: 21444678

// NEWDELETE.cpp : Defines the entry point for the console application.
//

#include "stdafx.h"

class A
{
      virtual long Increase() = 0;
      virtual long Decrease() = 0;
};

class B : public A
{
      virtual void Set(long n) = 0;
      virtual long Get() = 0;
};

class C : public A
{
public:
      C()
      {
      }
      virtual ~C()
      {
      }
      long Increase(){return -1;}
      long Decrease()
      {
            return -1;
      }
};

class D : public B
{
public:
      D() : m_count(0), m_n(99)
      {
      }
      virtual ~D()
      {
            //
            //new C class has to be created in place of this destructing class
            //so that static_cast<A*>(this) in both has to be same value
            // so that the line "n = pD->Decrease();} below has to return -1
            // instead of crashing.

            // I KNOW FOLLOWING WONT WORK BUT IF IT DID THAT IS WHAT WOULD BE MY SOLUTION!
            C* pC = new C;
            void* pThis = this;
            memcpy(pThis, pC, sizeof(C));
            delete pC;
      }
      long Increase(){return ++m_count;}
      long Decrease()
      {
            if (--m_count == 0)
                  delete this;
            return m_count;
      }
      void Set(long n)
      {
            m_n = n;
      }
      long Get()
      {
            return m_n;
      }
protected:
      long m_count;
      long m_n;
};

int _tmain(int argc, _TCHAR* argv[])
{

      D* pD = new D;
      long n = pD->Increase(); // 1 expected
      n = pD->Get(); // 99 expected
      pD->Set(7);
      n = pD->Get(); // 7 expected
      n = pD->Decrease(); // 0 expected
      n = pD->Decrease(); // crashes but can we allocate new class C in the destructor of C, to this location so this would work fine!!!
// n must be -1, and not crash!
      return 0;
}

04.26.2008 at 01:22AM PDT, ID: 21444891

Rank: Sage

Sorry, in a rush so I didn't get a chance to look at your code in depth, so some cursory observations...

>> long Decrease()
>> {
>> if (--m_count == 0)
>> delete this;
>> return m_count;
>> }

m_count will no longer be valid after the delete, you will be referencing unallocated memory.

>>// I KNOW FOLLOWING WONT WORK BUT IF IT DID THAT IS WHAT WOULD BE MY SOLUTION!
>> C* pC = new C;
>> void* pThis = this;
>> memcpy(pThis, pC, sizeof(C));
>> delete pC;

Why doesn't placement new work for you?

NB. If you use placement new you MUST explicitly call the destructor on your class yourself, failure to do so will leave any resources allocated by your class or any member objects undestructed, which will result in leaks.

04.26.2008 at 06:06AM PDT, ID: 21445406

Rank: Master

Evilrx is right, when using placement new, the destructor must be called explicitly, such as
p->~COne();

So the main in my example looks like this
void main() {
int sizeRequired = sizeof(CTwo); // since it is larger
unsigned char* allocation(new unsigned char[sizeRequired]);
COne* p = new (allocation) COne;
std::cout << "COne allocated at location " << std::hex << p << std::endl;
// >>No<< delete p; Don't delete here because that deletes the new unsigned char[sizeRequired] allocation
p->~COne(); // Must call destructor explicitly to free allocated resources
CTwo *pp = new (allocation) CTwo;
std::cout << "CTwo allocated at location " << std::hex << pp << std::endl;
pp->~CTwo();
delete pp;
}

Thanks for catching that, Rx!

If you can get a copy of "Effective C++ Third Edition" by Scott Meyers, read item 52 "Write placement delete if you write placement new". Scott spends 6 pages on the subject. Its the best discussion of this that I have read.

04.26.2008 at 06:26AM PDT, ID: 21445449

Rank: Master

>> n = pD->Decrease(); // 0 expected
This causes Decrease() to call
delete this;
so that the next call
>> n = pD->Decrease(); // crashes but can we allocate new class C in the destructor of C, to this location so this would work fine!!!
has no instance and thus crashes, as you say.

Could you tell us the intention of your project? What would you like to accomplish?

04.26.2008 at 12:11PM PDT, ID: 21446556

Rank: Sage

>> Thanks for catching that, Rx!
No worries josgood.

>> If you can get a copy of "Effective C++ Third Edition" by Scott Meyers
http://www.ishiboo.com/~nirva/c++/eff/

-Rx.

04.26.2008 at 09:37PM PDT, ID: 21448155

My initial try was placement new, but was not working. If you can make this work fine.
I want to replace it in the destruction.

#include "stdafx.h"
#include <assert.h>
#include <new>

class A
{
virtual long Increase() = 0;
virtual long Decrease() = 0;
};

class B : public A
{
virtual void Set(long n) = 0;
virtual long Get() = 0;
};

class C : public A
{
public:
C()
{
}
virtual ~C()
{
}
long Increase(){return -1;}
long Decrease()
{
delete this;
                  return -1;
}
};

class CReplacer
{
public:
      CReplacer(void* p) : m_p(p)
      {
      }
      virtual ~CReplacer()
      {
            C* pC = new(m_p) C;
            assert(m_p == pC);
      }
private:
      void* m_p;
};

class D : public B
{
public:
D() : m_count(0), m_n(99)
{
}
virtual ~D()
{
CReplacer r(reinterpret_cast<void*>(this));
}
long Increase(){return ++m_count;}
long Decrease()
{
if (--m_count == 0)
delete this;
return m_count;
}
void Set(long n)
{
m_n = n;
}
long Get()
{
return m_n;
}
protected:
long m_count;
long m_n;
};

int main(int argc, char* argv[])
{
D* pD = new D;
long n = pD->Increase();
n = pD->Get();
pD->Set(7);
n = pD->Get();
      n = pD->Decrease();
n = pD->Decrease();
return 0;
}

////////////////////////////////////

THIS is not exactly what i want, but this also crashes at the end.
This one atleast goes to last line. Again my aim is to work the first one above

#include "stdafx.h"
#include <assert.h>
#include <new>

class A
{
virtual long Increase() = 0;
virtual long Decrease() = 0;
};

class B : public A
{
virtual void Set(long n) = 0;
virtual long Get() = 0;
};

class C : public A
{
public:
C()
{
}
virtual ~C()
{
}
long Increase(){return -1;}
long Decrease()
{
delete this;
                  return -1;
}
};

class CReplacer
{
public:
      CReplacer(void* p) : m_p(p)
      {
      }
      virtual ~CReplacer()
      {
            C* pC = new(m_p) C;
            assert(m_p == pC);
      }
private:
      void* m_p;
};

class D : public B
{
public:
D() : m_count(0), m_n(99)
{
}
virtual ~D()
{

}
long Increase(){return ++m_count;}
long Decrease()
{
if (--m_count == 0)
delete this;
return m_count;
}
void Set(long n)
{
m_n = n;
}
long Get()
{
return m_n;
}
protected:
long m_count;
long m_n;
};

int main(int argc, char* argv[])
{
D* pD = new D;
long n = pD->Increase();
n = pD->Get();
pD->Set(7);
n = pD->Get();
      {
            CReplacer r(reinterpret_cast<void*>(pD));
            n = pD->Decrease();
      }
n = pD->Decrease();
return 0;
}

04.26.2008 at 09:39PM PDT, ID: 21448162

Again, I am not against placement new, I just could not have a success yet.

04.26.2008 at 09:48PM PDT, ID: 21448183

After looking at my problem again, if the following code runs without crash, it will do it for me.
Thanks.

#include "stdafx.h"
#include <assert.h>
#include <new>

class A
{
virtual long Increase() = 0;
virtual long Decrease() = 0;
};

class B : public A
{
virtual void Set(long n) = 0;
virtual long Get() = 0;
};

class C : public A
{
public:
C()
{
}
virtual ~C()
{
}
long Increase(){return -1;}
long Decrease()
{
delete this;
                  return -1;
}
};

class CReplacer
{
public:
      CReplacer(void* p) : m_p(p)
      {
      }
      virtual ~CReplacer()
      {
            C* pC = new(m_p) C;
            assert(m_p == pC);
      }
private:
      void* m_p;
};

class D : public B
{
public:
D() : m_count(0), m_n(99)
{
}
virtual ~D()
{

}
long Increase(){return ++m_count;}
long Decrease()
{
if (--m_count == 0)
delete this;
CReplacer r(reinterpret_cast<void*>(this));
return m_count;
}
void Set(long n)
{
m_n = n;
}
long Get()
{
return m_n;
}
protected:
long m_count;
long m_n;
};

int main(int argc, char* argv[])
{
D* pD = new D;
long n = pD->Increase();
n = pD->Get();
pD->Set(7);
n = pD->Get();
n = pD->Decrease();
n = pD->Decrease();
return 0;
}

04.26.2008 at 11:22PM PDT, ID: 21448335

is this all correct? coding? memory leak etc.
please make suggestions, corrections.
Thanks.

#include "stdafx.h"
#include "stdlib.h"
#include <assert.h>
#include <new>

class A
{
virtual long Increase() = 0;
virtual long Decrease() = 0;
};

class B : public A
{
virtual void Set(long n) = 0;
virtual long Get() = 0;
};

class C : public A
{
public:
C() : m_count(1)
{
}
virtual ~C()
{
}
long Increase(){return ++m_count;}
long Decrease()
{
              long n = --m_count;
              if (n == 0) {
                  delete this; // this->~C(); free(this); is better? same ?
              }
return n;
}
protected:
long m_count;
};

class D : public B
{
public:
D() : m_count(0), m_n(99)
{
}
virtual ~D()
{

}
long Increase(){return ++m_count;}
long Decrease()
{
              long n = --m_count;
              if (n == 0) {
this->~D();
                   void* p = realloc(reinterpret_cast<void*>(this), sizeof(C));
                   new(p) C;
              }
return n;
}
void Set(long n)
{
m_n = n;
}
long Get()
{
return m_n;
}
protected:
long m_count;
long m_n;
};

int main(int argc, char* argv[])
{
D* pD = new D;
long n = pD->Increase();
n = pD->Get();
pD->Set(7);
n = pD->Get();
      n = pD->Decrease();
n = pD->Decrease();
return 0;
}

04.27.2008 at 01:46AM PDT, ID: 21448537

Rank: Sage

Wow, lots of code. :)

Ok, if josgood hasn't already done so by the time I return (I'm sure he will have) I will try and look at this in detail later but unfortunately this weekend I am really busy with house maintenance (decorating) so it may not be until tomorrow morning. I would ask you , meanwhile, to clarify exactly what you are trying to do and why. What's the rational for this?

04.27.2008 at 09:50AM PDT, ID: 21449631

Rank: Sage