CareerCup

Only on Stack. Make new operator private.
Only on Heap. Make Destructor private.

For stack: make the constructor and destructor private, and provide friend or static functions that perform the same functionality.
For Heap: overload the new function and make it private.

What is the language/environment C, C++, C++ with GC, .NET, Java?

Thanks,
Laxmi

only on heap -> Destructor should be private. Reason, compiler can't call destructor. So, compiler stops creation of object on stack. This is applicable to all compilers.

Then how do you delete the object if destructor is private?

In order to prevent clients to create object on heap, you would need to make new/delete, placement new/delete operators private. And make all constructor and destructors private to avoid object creation on stack by client. Now one can't create any instance of your object. So you would need to provide a static method for object creation/deletion.

Here is an example:

class myclass
{
private:
    void* operator new(size_t);          // standard new
    void* operator new(size_t, void*);   // placement new
    void* operator new[](size_t);        // array new
    void* operator new[](size_t, void*); // placement array new
 
  myclass() {}
  ~myclass(){}

public:

myclass & createObject()
{
return new myclass();
}

void destroyObject() const
{
   delete this;
}
}

In order to prevent clients to create object on heap, you would need to make new/delete, placement new/delete operators private. And make all constructor and destructors private to avoid object creation on stack by client. Now one can't create any instance of your object. So you would need to provide a static method for object creation/deletion.

Here is an example:

class myclass
{
private:
    void* operator new(size_t);          // standard new
    void* operator new(size_t, void*);   // placement new
    void* operator new[](size_t);        // array new
    void* operator new[](size_t, void*); // placement array new
 
  myclass() {}
  ~myclass(){}

public:

myclass & createObject()
{
return new myclass();
}

void destroyObject() const
{
   delete this;
}
}

In order to prevent clients to create object on heap, you would need to make new/delete, placement new/delete operators private. And make all constructor and destructors private to avoid object creation on stack by client. Now one can't create any instance of your object. So you would need to provide a static method for object creation/deletion.

Here is an example:

class myclass
{
private:
    void* operator new(size_t);          // standard new
    void* operator new(size_t, void*);   // placement new
    void* operator new[](size_t);        // array new
    void* operator new[](size_t, void*); // placement array new
 
  myclass() {}
  ~myclass(){}

public:

myclass & createObject()
{
return new myclass();
}

void destroyObject() const
{
   delete this;
}
}

In order to prevent clients to create object on heap, you would need to make new/delete, placement new/delete operators private. And make all constructor and destructors private to avoid object creation on stack by client. Now one can't create any instance of your object. So you would need to provide a static method for object creation/deletion.

Here is an example:

class myclass
{
private:
    void* operator new(size_t);          // standard new
    void* operator new(size_t, void*);   // placement new
    void* operator new[](size_t);        // array new
    void* operator new[](size_t, void*); // placement array new
 
  myclass() {}
  ~myclass(){}

public:

myclass & createObject()
{
return new myclass();
}

void destroyObject() const
{
   delete this;
}
}