quote:Original post by SabreMan

quote:Original post by Sneftel
Another half-witted comment from a half-witted AP. "delete this" is completely legal syntax (though not what is required here).

True. Glaring typo aside, the syntax is legal, but the technique is immoral. What happens if the object is auto? What about references to the object - how do they know the object is `dead''?

quote:Original post by Sneftel
It's a limited technique, but occasionally a useful one. The few times I've used it, the following things have been true:

1. The class is a private inner class of another class.
2. The class has a private constructor.

class A{    bool zombie;    A(int x){zombie = (x<0);}    public:    static A* NewA(int x){        A* a = new A(x);         if(a->zombie){delete a; return NULL;} else return a;    }};

for(/*something*/) {  try {    particles.push_back(Particle(x,y));  } catch(CulledException&) {}} 

Particle::Particle(float x,float y) {  if(isCulled(x,y))    throw CulledException();  /* ... */}

#include "stdafx.h"#include <string.h>#include <iostream>class baseclass{public:	void setString(const char* const pStr)	{		if(pStr)			m_pString=strdup(pStr);		else 			throw("Invalid String");	}	void printString()	{		std::cout << "String:" << m_pString << std::endl;	}	virtual ~baseclass()	{		if(m_pString)			delete[] m_pString;	}private:	char* m_pString;};class subclass1 : public baseclass{public:	subclass1(const char* const pStr)	{		try{			setString(pStr);		}catch(...)		{			//ignore it - we can deal with - (bad..)		}	}};class errorclass : public subclass1{public:	errorclass()		:subclass1(NULL)	{	}};int main(int argc, char* argv[]){	errorclass e;  //e is never completely created	e.printString(); //bang.	return 0;}

quote:Original post by Sneftel
#1 means that you can avoid having references when you don''t want them, since you have full control over when stuff will be used.

quote:
#2 means that you never have to worry about stack objects.