Download source - 1 KbOn several occassions I've had to execute a piece of code which used a global
variable that needed to be temporarily reassigned. The problem was that I wanted
the variable to return to its original value after the code had been executed.
So I would end up assigning it to some local variable, executing the code, and
then setting the global variable back to its original value held by the local
variable. Here's a sample of what I mean:
{
double* pTemp = g_pValue;
g_pValue = NULL;
FunctionWhichUsesGlobalValue( );
g_pValue = pTemp;
}
As may be evident, this implementation has a couple of problems. For one, if
the function throws an exception the global variable never regains its original
value. Another problem is that you have to remember to restore the value. For a
simple case like this one it's not difficult, but if you have multiple return points,
it means having to restore the value on all of them. This results in duplicate code
which is more difficult to maintain.
So how do we solve this problem? With a class, of course! If we store the variable's
original value inside a class, we can then make the destructor restore the variable's
value automatically. This would give us two key advantages:
- The variable would always regain its original value.
- We would not have to worry about explicitly restoring it.
Now, you probably think that the way to do this is with a template class... and you're
right. A template class accomplishes this task and turns the above code into something
like this:
{
CTemp<double*> temp = g_pValue;
g_pValue = NULL;
FunctionWhichUsesGlobalValue( );
}
That's quite an improvement, isn't it?! Well, it still has one minor problem which was
also prevalent in the first example: the fact that we have to know and specify the variable's
type. And while that is not too big of a deal, wouldn't it be better to not have to do it?
In other words, wouldn't it be nice to just say: CTemp temp = g_pValue
and the object would
then somehow know that g_pValue is a pointer to a double? Well, with template member
functions it can be done!
Template member functions work just like regular template functions. The compiler generates
them based on the type of the arguments on which they operate. So what is basically needed
is a class with a template constructor and a way for the constructor to store the value in
a generic member variable which the destructor can then properly restore. It's a bit tough
to explain the exact mechanism here but I think you'll understand it once you see its
implementation. The class is called CTemp
and applying it to the code above would make
it look like this:
{
CTemp temp = g_pValue;
g_pValue = NULL;
FunctionWhichUsesGlobalValue( );
}
Much nicer, don't you think?! Not only does this class do what the template version
did but it does it without you having to determine and then specify the variable's type
in the code. That's what I call putting the compiler to work for the programmer!
To use the class simply download the temp.h file into your C++ project, include it where
you need it, and enjoy!
I've done extensive work with C++, MFC, COM, and ATL on the Windows side. On the Web side, I've worked with VB, ASP, JavaScript, and COM+. I've also been involved with server-side Java, which includes JSP, Servlets, and EJB, and more recently with ASP.NET/C#.