How to do it

1. Open Region and Language settings in Windows 7 (You can invoke it by the command intl.cpl typed in the Run or Start Menu Search box).
2. Click the button Additional Settings.
3. Go to the Time tab.
4. Change the Long Time format to HH:mm:ss tt (That is, append a tt).
5. Now the AM/PM will be added to the time in system tray, on pressing Apply. However, the time will be still in 24 hour format.
6. To change it to 12 hour format, change the HH to hh (That is, hh:mm:ss tt).

How to do it

1. Make a new folder in Windows 7
2. Rename it to GodMode.{ED7BA470-8E54-465E-825C-99712043E01C}

The folder will have a name GodMode with the icon of control panel. It is the place you will find all the above utilities.

For example,

c = a + b;

As the operator + operates on two values, it can be easily overloaded.

Now look at the unary operator *. It operates on the variable name, not on the value.

b = *a;

where a is not a value, but a name.

Similarly the following operators can not be overloaded.

sizeof - The operator to find the size of a variable in memory

? -The ternary operator

:: – The scope resolution operator

. – The operator to access class members

-> – The operator to access class members from a class pointer type variable

* – The indirection operator

Image courtesy : http://www.usscouts.org

Auto pointers provide some kind of automatic garbage collection. That means the programmer doesn’t have the headache of deleting the pointer, thereby ensuring that there won’t be memory leaks due to his carelessness.

Unlike normal pointers, there can be only one owner for an auto pointer at a time, though ownership can be transferred.

An auto pointer can be created using the syntax

auto_ptr<T> variable name (new  T), where T is the class type to which the pointer belongs.

An example is

auto_ptr<int> myInt(new int(10));

To transfer the ownership, we can simply assign the above to another auto_ptr variable.

auto_ptr<int> myNewInt = myInt;

In this case, myNewInt points to the location where 10 is stored and myInt = NULL:

To assign an auto_ptr to a normal pointer, we can use the auto_ptr method release. Hence, the above functionality can be obtained in the following way also.

int* myNormalInt = myInt.release();

On calling release, the auto_ptr is set to NULL where as the memory location pointed by it is not destroyed, but assigned to the new variable.

To access the memory location pointed by the auto_ptr variable, we can use the method get().

A small example is described below.

First we create a simple class

// A simple class
class CMyClass
{
public:
   // Constructor
   CMyClass(int no)
   :m_No(no)
   {
   }
   // Display the member variable
   void Display()
   {
      cout << "No is << " << m_No << "\n";
   }
private:
   int m_No;
};

Now various operations using auto_ptr are shown below.

#include "stdafx.h"
#include <iostream>
#include <memory>
#include "assert.h"
using namespace std;

int _tmain(int argc, _TCHAR* argv[])
{
   // Create an auto_ptr
   auto_ptr<CMyClass> myClass(new CMyClass(10));
   // Assign the auto pointer to a new auto_ptr
   auto_ptr<CMyClass> myNewClass = myClass;
   // myClass will be NULL now
   assert(myClass.get() == NULL);
   // myNewClass now points to the location
   // where myClass pointed to
   myNewClass->Display();
   // myNewClass can be assigned to a normal
   // pointer as below
   CMyClass* myNormalClass = myNewClass.release();
   // myNewClass now points to NULL
   assert(myNewClass.get() == NULL);
   // myNormalClass now points to the location
   // myNewClass pointed to
   myNormalClass->Display();
   // Finally, we can delete myNormalClass.
   // Note that the auto_ptr variables do
   // not need deletion
   delete myNormalClass;
   myNormalClass = NULL;
   return 0;
}

Image courtesy : http://www.freeprintablecoloringpages.net

A couple of years ago, cppkid stepped into the world of technical blogging with free space provided generously by Wordpress with an idea to share what he was learning. He has now got his own home in the cyber world under the name techievibes.

He is always grateful to the support he has got and he hopes that it will continue in the future also. He once again expresses his sincere thanks to all who have provided support (through both criticism and praise).

See you with next post soon…..

double Round(const double value, const int digits)
{
   stringstream stream;
   // Store the number with required no. of decimal
   // places to stream
   stream << setprecision(digits) << value;
   // Convert stream to number
   double roundedValue = 0.0;
   stream >> roundedValue;
   return roundedValue;
}

The header files sstream and iomanip are needed for the above.

Please note that the variable value holds the number with original no. of decimal places and digits is the total number of digits needed (including the non-decimal digits) after rounding has taken place.

Round(10.37665, 3) gives 10.4 and Round(10.3745, 4) gives 10.37.

Note

If you want to store the number in scientific notation in stream, you can do

stream <<  scientific;

For fixed point format, do

stream <<  fixed;

The syntax is

int SetItemData(
   int nIndex,
   DWORD_PTR dwItemData
);

Parameters

• nIndex – Zero based row index of the list box
• dwItemData – 32 bit value to be stored in the row

The return value will be LB_ERR, if an error occurs.
The stored value can be retrieved using CListBox::GetItemData(). Again, the syntax is

DWORD_PTR GetItemData(
   int nIndex
) const;

where nIndex is the zero based index of the list box row, from where we have to get the data.
An example is given below.
for (int index = 0; index < myListBox->GetCount(); ++index)
{
   if (myListBox->GetItemData(index) == DWORD(-1))
   {
      myListBox->SetItemData(index, 0);
   }
}

The header file afxwin.h is needed for the above functions.

map<int, int> myMap, to get the element corresponding to 10, we can use

myMap[10]. This is perfectly ok as long as we have an element corresponding to 10. But, what if we don’t have one corresponding to 10?

There lies the problem. In this situation, myMap is already added with a default elemnent corresponding to 10 ([] operator provides no facility to validate if an element exists) and in the above situation, it is 0. As a result, a new (unwanted) element is added to the map (we can see that the size of map has been incremented by 1).

So a better alternative is to use the find() function associated with map. It does not add an element and if the element is not found, it will return map::end().

The example given below illustrates this.

#include <map>
#include <iostream>
using namespace std;

int main()
{
   map myMap;
   cout << "Size of myMap = " << myMap.size() << '\n';   // will be 0
   int content = myMap[0];
   // Now the size of myMap will be 1 as we used the [] operator
   // and the value of content = myMap[0] = 0
   cout << "Size of myMap = " << myMap.size() << '\n';   
   // Instead, if we use find, the size will not change.
   // It will look for the element only.
   map::const_iterator it = myMap.find(1);
   // Here the element has not been found. So it = myMap.end()
   cout << "Size of myMap = " << myMap.size() << '\n';   // will be 1 only 
   return 0;   
}

So the best practice is to avoid [] operator for accessing individual elements of a map.

void SomeFunction()
{
   int myVariable = 20;
}
int main()
{
   int myVariable = 10;
   SomeFunction();
   return 0;   
}

In the above example, if I put a break point in the function main after the statement int myVariable = 10; I can see the value of myVariable in the watch window as follows.

Now, if I put another break point in SomeFunction() after the statement int myVariable = 20;, when th execution flow reaches there, the watch window will show the value of myariable as 20 only.

So we have lost the value of myVariable declared in main(), eventhogh it lifetime is not over now.

How To Add a Permanent watch

We can still view the value of myVariable declared in main() inside the function SomeFunction(). For this, we will use the address of memory location (rather than the variable name) in which myVariable has been declared in main(). We can view the contents of this memory location as long as it has life in the program.

When the control reaches the break point in main(), take the address of myVariable using the & operator. Now we have a valid memory location address (a pointer). Still, it can be a raw pointer. So cast it to the correct type (int, in this case, as myVariable is of type integer) as

(int*)(address of myVariable)

Now see how the watch window shows the value we have stored, when the control reaches the second break point.

#include <iostream>
using namespace std;

// Function to be called when the new operator fails
void NewHandler()
{
   cout << "Out of memory" << '\n';
   exit(0);
}
 
int main()
{
   // Set the function to be called when new operator fails
   set_new_handler(NewHandler);
   while (true)
   {
      new int[50000000];   // Hope this will fail after a few iterations
      cout << "Successful so far" << '\n';
   }
   return 0;
}

In the above example, the function NewHandler() will be called when the memory allocation using new operator fails.

Some Background Info

set_new_handler will store the function NewHandler() in a static new handler pointer. This new handler is used by operator new.