Click here to Skip to main content
Click here to Skip to main content
Go to top

Saving a variable temporarily

, 16 Nov 1999
Rate this:
Please Sign up or sign in to vote.
A safe, and convenient way to store variables temporarily
<!-- STEP 2. Include download and sample image information -->
  • Download source - 1 Kb
  • <!-- STEP 3. Add the article text.-->

    On 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:

         {
             // Hold value in local variable 
             double* pTemp = g_pValue; 
             
             // Reassign it to another value (temporarily) 
             g_pValue = NULL; 
             
             // Use it in some code 
             FunctionWhichUsesGlobalValue( ); 
             
             // Restore it back to what it was originally 
             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!

    License

    This article has no explicit license attached to it but may contain usage terms in the article text or the download files themselves. If in doubt please contact the author via the discussion board below.

    A list of licenses authors might use can be found here

    Share

    About the Author

    Alvaro Mendez
    Web Developer
    United States United States
    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#.

    Comments and Discussions

     
    GeneralMy vote of 4 PinmemberCIDev23-Sep-10 3:22 
    GeneralNice PinmemberStephen Hewitt26-Jan-06 15:20 
    Generalcode in saving vb Pinsussprincess marla sarmiento3-Feb-04 16:02 
    Questionwhy? PinsussJeff Reed4-Feb-00 12:14 
    AnswerRe: why? PinsussAlvaro Mendez8-Feb-00 9:31 
    GeneralRe: why? PinsussMike Junkin3-May-00 10:50 
    GeneralRe: why? PinsussAlvaro Mendez3-May-00 11:46 
    Mike,
     
    Thanks for your comments Mike. Let me address each of your points:
     
    A. I agree with you. However the example in my article does not show a function that changes a global variable as a side effect. Instead I show a case where I'm about to execute a piece of code which READS the value of a global variable and I purposely want the variable to be set to some specific value just for that. Once that code has executed, the global variable should go back to its original value.
     
    Hasn't that ever happened to you? You're about to execute a piece of code which you know reads the value of some global or member variable. However, in this case you want that piece of code to work with the variable set to, say 0. Then when that's over you want the variable to maintain its original value. Now, think how you'd solve that problem if you couldn't rely on a class like CTemp.
     
    B. Yes I agree that for local variables it's just as easy, and more efficient, to make a copy of it before passing it down.
     
    C. Again, I never intended this to be used for functions that change variables as side-effects. Rather, it's meant for setting a variable's value temporarily before a piece of code is executed and then restoring it after it's done.
     

    I'd like to illustrate this class's reason for being with a real-world example where it came in really handy for me:
     
    I don't know if you this but you can override CWinApp's DoMessageBox virtual function in case you need to provide special handling for calls to AfxMessageBox. Well, I had the misfortune of being handed a poorly written C++ DLL which used AfxMessageBoxes to display any error messages it encountered. My calling program would need to call that code iteratively and it could not be stopped for any error messages. It would simply report them and go on. Well, I solved the problem by overriding DoMessageBox and adding a boolean member variable to my CWinApp-derived class.
     
    Just before entering the iterative process I would create a CTemp variable, set the variable to false (no message boxes) and viola the process would run with no interruptions. Here's how it looked:
     
    {
    CMyApp* pApp = (CMyApp*)AfxGetApp();
    CTemp tMB = pApp->m_bMessageBoxes;
    pApp->m_bMessageBoxes = false;
     
    // Iterate through code (with no interruptions)
    ...
    }
     
    The beauty of this is that as soon as the code had finished running whether successfully or not, message boxes would again be enabled automatically. I didn't have to worry about resetting the variable inside exception-catch blocks, or keeping track of what the value was in some temporary variable of the same type.
     
    Now, you could argue that the DLL was poorly written to begin with and this could have all been avoided otherwise. I agree, but at that time changing the DLL was out of the question. There simply was too much code already depending on it and the project manager would not have allowed it. So this little class solved the problem cleanly and with minimum fuss.
     
    Regards,
    Alvar
    GeneralRe: why? PinsussSoeren18-May-00 6:11 
    GeneralRe: why? PinmemberBobbby5-Feb-01 21:55 
    AnswerRe: why? PinmemberStephen Hewitt26-Jan-06 15:22 

    General General    News News    Suggestion Suggestion    Question Question    Bug Bug    Answer Answer    Joke Joke    Rant Rant    Admin Admin   

    Use Ctrl+Left/Right to switch messages, Ctrl+Up/Down to switch threads, Ctrl+Shift+Left/Right to switch pages.

    | Advertise | Privacy | Mobile
    Web01 | 2.8.140922.1 | Last Updated 17 Nov 1999
    Article Copyright 1999 by Alvaro Mendez
    Everything else Copyright © CodeProject, 1999-2014
    Terms of Service
    Layout: fixed | fluid