Here's the code. The question follows.
Code:
#pragma once
#define SAFE_DELETE(var) if ( var ) { delete var; var = 0; }
template<class T>
class Type
{
public:
//Default constructor
Type()
:is_good(false),
typePtr(0)
{/*Empty code block*/};
//Assignment constructor
Type(const T& val)
:is_good(false),
typePtr(0)
{
//Allocate memory with assigned value
typePtr = new T(val);
if ( *typePtr == val )
is_good = bool(true);
else
{
SAFE_DELETE(typePtr);
}
};
//Copy constructor
//Does not copy pointers. Copies values.
Type(const Type& copy)
:is_good(false),
typePtr(0)
{
//Allocate memory with copy values
typePtr = new T(*copy.typePtr);
if ( *typePtr == *copy.typePtr )
is_good = bool(true);
else
{
SAFE_DELETE(typePtr);
}
};
//Destructor
~Type()
{
is_good = false;
SAFE_DELETE(typePtr);
};
//Copy assignment
const Type& operator=(const Type& copy)
{
if ( typePtr )
{
is_good = bool(false);
SAFE_DELETE(typePtr);
}
typePtr = new T(*copy.typePtr);
is_good = copy.is_good;
return *this;
};
T& operator*()
{
return *typePtr;
};
T* operator->()
{
return typePtr;
};
operator bool()
{
return is_good;
};
private:
bool is_good;
//The pointer to the type
T* typePtr;
};
#undef SAFE_DELETE
Ok, first off. The SAFE_DELETE is defined then undefined, because most of my classes need a different version of it.
The point of the class is to wrap the handling of the pointer. Pretty much to disallow modifying the pointer without ugly code.
My thought on this is that with this class I can do something like the following.
Code:
Type<int> Test(100);
if ( Test )//check if the ptr is good
std::cout << *Test << std::endl;
//As opposed to
int * Test = new int(100);
if ( Test != 0 )
std::cout << *Test << std::endl;
delete Test;
I realize that there isn't much difference between them, but I thought I would see what you guys thought. Well Thank you.
EDIT:
Also, if I am not mistaken the only way to directly modify the pointer, or to prematurely delete would be to do this right?
Code:
Type<int> Test(100);
delete Test.operator->();//Am i right?