Auto destruct

[JKop]

Using MSWindows as an example:

On MSWindows, there's a thing called the System Registry, which is a really
big database that holds all the settings of the OS. There's API's for
working with the registry. The two I will be concerned with are:

RegOpenKeyEx
RegCloseKey

Now, here's some code:

int main()
{
HKEY hkey;

RegOpenKeyEx( &hkey );

... //some stuff

RegCloseKey( hkey );
}
The only problem here is that if an exception is thrown during "some stuff",
then the key never gets closed. Here was my first solution:

class HKEYe
{
public:

HKEY hkey;
bool to_be_closed;

HKEYe() : to_be_closed(fa lse) {}

~HKEYe()
{
if (to_be_closed)
{
RegCloseKey(hke y);
}
}

operator HKEY&() { return hkey; }
operator const HKEY&() const { return hkey; }
HKEY* operator&() { return &hkey; }
const HKEY* operator&() const { return &hkey; }
};

int main()
{
HKEYe hkey;

RegOpenKeyEx( &hkey );

hkey.to_be_clos ed = true;

//... some stuff

RegCloseKey(hke y);
hkey.to_be_clos ed = false;

}
Now if an exception is thrown, then the key does get closed.

Anyway, my next thought was to make a template out of this. Has this been
done before? Anyway, here's my first attempt:
template<class T>
class AutoDestructive
{
public:

T t;
bool to_be_auto_dest ructed;

AutoDestructive () : t(), to_be_auto_dest ructed(false) {}
template<class A> AutoDestructive (A a) : t(a), to_be_auto_dest ructed
(false) {}
template<class A> AutoDestructive (const A a) : t(a),
to_be_auto_dest ructed(false) {}
template<class A, class B> AutoDestructive (A a, B b) : t(a,b),
to_be_auto_dest ructed(false) {}
template<class A, class B, class C> AutoDestructive (A a, B b, C c) : t
(a,b,c), to_be_auto_dest ructed(false) {}

virtual ~AutoDestructiv e() = 0;

operator T&() { return t; }
operator const T&() const { return t; }
T* operator&() { return &t; }
const T* operator&() const { return &t; }
};

class AutoDestructive _HKEY : public AutoDestructive <HKEY>
{
public:

~AutoDestructiv e_HKEY()
{
if (to_be_auto_des tructed) RegCloseKey(t);
}
};

int main()
{
AutoDestructive _HKEY hkey;

LONG error_code = RegOpenKeyEx(HK EY_CLASSES_ROOT ,
"*",
0,
KEY_QUERY_VALUE |KEY_SET_VALUE,
&hkey);

if (error_code == ERROR_SUCCESS)
{
hkey.to_be_auto _destructed = true;
}
}
Comments, questions, suggestions welcomed.

-JKop

[Alf P. Steinbach]

* JKop:

Now if an exception is thrown, then the key does get closed.

Anyway, my next thought was to make a template out of this. Has this been
done before?

Petri Marginean's ScopeGuard-class.

See the article about ScopeGuard (Andrei Alexandrescu & Petri Marginean) at
<url: http://www.cuj.com/documents/s=8000/cujcexp1812alex andr/>, source code
at <url: ftp://ftp.cuj.com/pub/2000/cujdec2000.zip> .

Note that for MSVC you'll have to replace use of standard __LINE__ with
Microsoft __COUNTER__ to make it work in general, at least if you're using the
"edit & continue" option of that compiler (it's a bit broken).

--
A: Because it messes up the order in which people normally read text.
Q: Why is it such a bad thing?
A: Top-posting.
Q: What is the most annoying thing on usenet and in e-mail?

[Niels Dybdahl]

> ...

Comments, questions, suggestions welcomed.

I prefer writing such a class like this:

class CRegKey {
public:
HKEY hkey;
CRegKey() {
if (RegOpenKeyEx( &hkey ))
throw...
}
~CRegKey() {
RegCloseKey( hkey );
}
};

int main()
{
{
CRegKey regKey;
...
}
};

The code for the class is so small that it is not worth making a template
for it. An invariant for the class is that the handle is open, so you do not
have to test if it is open, you do not have to remember to open it and you
do not have to remember to close it. As long as it is in scope it is open.

Niels Dybdahl

[Peter van Merkerk]

JKop wrote:

Using MSWindows as an example:

On MSWindows, there's a thing called the System Registry, which is a really
big database that holds all the settings of the OS. There's API's for
working with the registry. The two I will be concerned with are:

RegOpenKeyEx
RegCloseKey

Now, here's some code:

int main()
{
HKEY hkey;

RegOpenKeyEx( &hkey );

... //some stuff

RegCloseKey( hkey );
}
The only problem here is that if an exception is thrown during "some stuff",
then the key never gets closed. Here was my first solution:

class HKEYe
{
public:

HKEY hkey;
bool to_be_closed;

HKEYe() : to_be_closed(fa lse) {}

~HKEYe()
{
if (to_be_closed)
{
RegCloseKey(hke y);
}
}

operator HKEY&() { return hkey; }
operator const HKEY&() const { return hkey; }
HKEY* operator&() { return &hkey; }
const HKEY* operator&() const { return &hkey; }
};

int main()
{
HKEYe hkey;

RegOpenKeyEx( &hkey );

hkey.to_be_clos ed = true;

//... some stuff

RegCloseKey(hke y);
hkey.to_be_clos ed = false;

}
Now if an exception is thrown, then the key does get closed.

Anyway, my next thought was to make a template out of this. Has this been
done before? Anyway, here's my first attempt:
template<class T>
class AutoDestructive
{
public:

T t;
bool to_be_auto_dest ructed;

AutoDestructive () : t(), to_be_auto_dest ructed(false) {}
template<class A> AutoDestructive (A a) : t(a), to_be_auto_dest ructed
(false) {}
template<class A> AutoDestructive (const A a) : t(a),
to_be_auto_dest ructed(false) {}
template<class A, class B> AutoDestructive (A a, B b) : t(a,b),
to_be_auto_dest ructed(false) {}
template<class A, class B, class C> AutoDestructive (A a, B b, C c) : t
(a,b,c), to_be_auto_dest ructed(false) {}

virtual ~AutoDestructiv e() = 0;

operator T&() { return t; }
operator const T&() const { return t; }
T* operator&() { return &t; }
const T* operator&() const { return &t; }
};

class AutoDestructive _HKEY : public AutoDestructive <HKEY>
{
public:

~AutoDestructiv e_HKEY()
{
if (to_be_auto_des tructed) RegCloseKey(t);
}
};

int main()
{
AutoDestructive _HKEY hkey;

LONG error_code = RegOpenKeyEx(HK EY_CLASSES_ROOT ,
"*",
0,
KEY_QUERY_VALUE |KEY_SET_VALUE,
&hkey);

if (error_code == ERROR_SUCCESS)
{
hkey.to_be_auto _destructed = true;
}
}
Comments, questions, suggestions welcomed.

Congratulations , you just "invented" the RAII idiom. The std::auto_ptr
class in standard library is example of the RAII idiom. This idiom is
described in the book "The C++ Programming Language" from Bjarne
Stroustrup. Using the destructor to do proper clean up is a well known
C++ way to write exception safe code.

This idiom can be used for many more cases than just releasing memory or
handles. For example in a GUI application you could write a class that
in the constructor changes the cursor shape to an hourglass and in the
destructor restores the cursor to its previous shape.

void HeavyProcessing ()
{
WaitCursor wc;

// Do some stuff here....
// Exceptions or returns anywhere in the
// function will restore the cursor shape.
}

--
Peter van Merkerk
peter.van.merke rk(at)dse.nl

[Thore Karlsen]

On Thu, 05 Aug 2004 13:49:32 GMT, JKop <NU**@NULL.NULL > wrote:

[...]

Now if an exception is thrown, then the key does get closed.

Anyway, my next thought was to make a template out of this. Has this been
done before?

Yes. For registry keys, you have CRegKey in ATL 7.x. A more generic
solution can be found in the ScopeGuard class, as mentioned by Alf. You
can also take a look at the SmartAny library in the PowerTools package
at:

http://www.gotdotnet.com/team/cplusplus/

--
Be seeing you.

[JKop]

Alf P. Steinbach posted:

* JKop:

Now if an exception is thrown, then the key does get closed.
Anyway, my next thought was to make a template out of this. Has this been done before?
Petri Marginean's ScopeGuard-class.

See the article about ScopeGuard (Andrei Alexandrescu &

Petri Marginean) at
<url: http://www.cuj.com/documents/s= 8000/cujcexp1812alex andr/>, sourcecode
at <url: ftp://ftp.cuj.com/pub/2000/cujdec2000.zip> .

Note that for MSVC you'll have to replace use of standard __LINE__ with Microsoft __COUNTER__ to make it work in general, at least if you're using the "edit & continue" option of that compiler (it's a bit broken).

Seems to me that the only problem is that you can't
specify arguments to the function. I suppose an inline
function with global references/pointers would do the job,
but how and ever.
I might keep going with my template and see how it goes.

First thing though, is there any way for a derived class
to inherit the constructors of its base? eg.

class Base
{
public:

Base() {}
Base(int) {}
Base(double&) {}
};

class Derived : public Base
{

};

int main()
{
double k;

Derived monkey(k);
}
I know that you can do the following:

class Derived : public Base
{
public:

Derived() : Base() {}
Derived(int) : Base(int) {}
Derived(double& ) : Base(double&) {}
};

But this will be very tedious if there's dozens of
contructors in the base. For example, for my template
class, the base will have loads of constructors so that
you can actually use the constructor of the type you're
"protecting ".
-JKop

[JKop]

g++ cnt.cpp -ansi -pedantic -o c.exe

C:\WINDOWS\TEMP/ccgrbaaa.o(.tex t$_ZN15AutoDest ructiveIiED2Ev+ 0x16):cnt.cpp:
undefined reference to `AutoDestructiv e<int>::CleanUp ()'
Can some-one else please try compile it and see what happens.

Anyone know what's wrong with the code?
Here's the code:
typedef int HKEY;
const int ERROR_SUCCESS(5 );

void RegCloseKey(HKE Y hkey) {}
int RegOpenKeyEx(HK EY *hkey) { return ERROR_SUCCESS; }

template<class T>
class AutoDestructive
{
public:

T t;
bool to_be_auto_dest ructed;

AutoDestructive () : t(), to_be_auto_dest ructed(false) {}

virtual void CleanUp() = 0;

~AutoDestructiv e()
{
this->CleanUp();
}

operator T&() { return t; }
operator const T&() const { return t; }
T* operator&() { return &t; }
const T* operator&() const { return &t; }
};
class AutoDestructive _HKEY : public AutoDestructive <HKEY>
{
public:

virtual void CleanUp()
{
if (to_be_auto_des tructed)
{
RegCloseKey(t);
to_be_auto_dest ructed = false;
}
}
};
int main()
{
AutoDestructive _HKEY hkey;

int error_code = RegOpenKeyEx(&h key);

if (error_code == ERROR_SUCCESS)
{
hkey.to_be_auto _destructed = true;
}
}
-JKop

[Ioannis Vranos]

JKop wrote:

Using MSWindows as an example:

On MSWindows, there's a thing called the System Registry, which is a really
big database that holds all the settings of the OS. There's API's for
working with the registry. The two I will be concerned with are:

RegOpenKeyEx
RegCloseKey

Now, here's some code:

int main()
{
HKEY hkey;

RegOpenKeyEx( &hkey );

... //some stuff

RegCloseKey( hkey );
}
The only problem here is that if an exception is thrown during "some stuff",
then the key never gets closed. Here was my first solution:

class HKEYe
{
public:

HKEY hkey;
bool to_be_closed;

HKEYe() : to_be_closed(fa lse) {}

~HKEYe()
{
if (to_be_closed)
{
RegCloseKey(hke y);
}
}

operator HKEY&() { return hkey; }
operator const HKEY&() const { return hkey; }
HKEY* operator&() { return &hkey; }
const HKEY* operator&() const { return &hkey; }
};

int main()
{
HKEYe hkey;

RegOpenKeyEx( &hkey );

hkey.to_be_clos ed = true;

//... some stuff

RegCloseKey(hke y);
hkey.to_be_clos ed = false;

}
Now if an exception is thrown, then the key does get closed.

System specific stuff but a generic issue. :-) Check "Resource
Acquisition is Initialisation" technique (RAII in short) even in my
messages of the past. :-)


Regards,

Ioannis Vranos

http://www23.brinkster.com/noicys

[Alf P. Steinbach]

* JKop:

Seems to me that the only problem is that you can't
specify arguments to the function.

You can.

--
A: Because it messes up the order in which people normally read text.
Q: Why is it such a bad thing?
A: Top-posting.
Q: What is the most annoying thing on usenet and in e-mail?

[JKop]

> ~AutoDestructiv e()

{
this->CleanUp();
}

The probem is with the above.

The following doesn't compile either:

class Base
{
public:

virtual void Monkey() = 0;

~Base()
{
this->Monkey();
}
};

class Derived : public Base
{
public:

virtual void Monkey()
{

}
};

int main()
{
Derived checker;
}
WHY?
-JKop