The challenging 'Infinite loop' problem

Picked this one up from The C++ blog.

Consider the following program:

#include <iostream>

int main()
{
    int i;
    int array[4];
    for(i=0; i<=8; i++)
    {
        array[i]=0;
    }

  return 0;
}

Most people including myself expect this program to crash. This is not the case. The reason being the way everything is stored on stack. In simple representation, the storage is something like this:



So when i = 6, value of i is reset to 0 and the loop continues forever.

After digging some information on stack, heap, etc. I found some useful info in C++ in 24 hours:

Programmers generally deal with five areas of memory:

• Global name space
• The free store (a.k.a. Heap)
• Registers
• Code space
• The stack

Local variables are on the stack, along with function parameters. Code is in code space, of course, and global variables are in global name space. The registers are used for internal housekeeping functions, such as keeping track of the top of the stack and the instruction pointer. Just about all remaining memory is given over to the free store, which is sometimes referred to as the heap.

The problem with local variables is that they don't persist. When the function returns, the local variables are thrown away. Global variables solve that problem at the cost of unrestricted access throughout the program, which leads to the creation of code that is difficult to understand and maintain. Putting data in the free store solves both of these problems.

You can think of the free store as a massive section of memory in which thousands of sequentially numbered cubbyholes lie waiting for your data. You can't label these cubbyholes, though, as you can with the stack. You must ask for the address of the cubbyhole that you reserve and then stash that address away in a pointer.

The stack is cleaned automatically when a function returns. All the local variables go out of scope, and they are removed from the stack. The free store is not cleaned until your program ends, and it is your responsibility to free any memory that you've reserved when you are done with it.

The advantage to the free store is that the memory you reserve remains available until you explicitly free it. If you reserve memory on the free store while in a function, the memory is still available when the function returns.

The advantage of accessing memory in this way, rather than using global variables, is that only functions with access to the pointer have access to the data. This provides a tightly controlled interface to that data, and it eliminates the problem of one function changing that data in unexpected and unanticipated ways.

For this to work, you must be able to create a pointer to an area on the free store and to pass that pointer among functions. The pointer is created using new and once you are done with it you can free the memory using delete.

Reading string via cin and flushing input buffers

The following program shows three different approaches to read string via Cin. It also shows two different approaches for flushing input buffer.

//Program tested on Microsoft Visual Studio 2008 - Zahid Ghadialy
//Program to read input string and to flush input buffer
#include<iostream>
#include<string>
#include <istream>
#include <limits>

using namespace std;

int main()
{
  string s1;
  cout << "\nAPPROACH 1" <<endl;
  cout << "Input a string : ";
  cin >> s1;
  cout << "Entered string = " <<s1.c_str()<<endl;

  //Lets flush the buffer from Approach 1 here
  istream& in(cin);
  in.ignore( numeric_limits<std::streamsize>::max(), '\n' );

  cout << "\nAPPROACH 2" <<endl;
  cout << "Input a string : ";
  istreambuf_iterator<char> eos;  // end-of-range iterator
  istreambuf_iterator<char> iit (cin.rdbuf()); // stdin iterator
  string s2; 
  while (iit!=eos && *iit!='\n') s2+=*iit++;
  cout << "Entered string = " << s2 << endl;

  //Another approach for flushing the input
  int ch;
  while ((ch = cin.get()) != '\n' && ch != EOF);

  cout << "\nAPPROACH 3" <<endl;
  cout << "Input a string : ";
  char buf[BUFSIZ];
  if (cin.getline(buf, sizeof(buf)))
  {
    cout << "Entered string = " << buf << endl;
  }

  cout << endl;
  return 0;
}

The output is as follows:



More information:

• FAQ: How Do I flush input buffer
• How do I flush input stream
• istreambuf_iterator

Using #pragma message directive

Sometimes you would like to remind the user or yourself of something while compiling and there is an option to remind yourself using the #pragma message directive. See the following program:

//Program tested on Microsoft Visual Studio 2008 - Zahid Ghadialy
//Program to show how to remember things using #pragma message
#include<iostream>

using namespace std;

int someFunction(int a=0, int b=0)
{
#pragma message("TODO: Coding of someFunction()")
  return 0;
}

int main()
{
  someFunction();
  return 0;
}

In this case the user wants to remind himself that someFunction() needs to be coded at a later time and hence he uses a preprocessor message statement. The result is when compilation is done, a message will be output as shown below:

Using Preprocessor Statements #ifdef, #elif, #else and #endif

Sometimes it becomes necessary to write two (or more) different peices of behaviour in a common code. Depending of its mode/place/time/version the behaviour has to be changed. It can be done by the use of simple preprocessor statements. Consider the following program:

//Program tested on Microsoft Visual Studio 2008 - Zahid Ghadialy
//Program to show use of preprocessor macros for dynamic behaviour

#include<iostream>
#include<string>

using namespace std;

#define USE_CAR //Comment or Uncomment this if using preprocessor option

int main()
{
  int someNum = 3;
#ifdef USE_CAR
  string modeOfTransport("Use a Car");
#elif USE_BUS
  string modeOfTransport("Use a Bus");
#elif USE_TRAIN
  string modeOfTransport("Use a Train");
#else
  string modeOfTransport("Use any mode of transport");
#endif

  cout<<"Mode of Transport = "<<modeOfTransport<<" and someNum = "<<someNum<<endl;

  return 0;
}

The output is as follows:

In the program above, the statement in the start #define USE_CAR says that the code with USE_CAR should be used during compile time. Instead if USE_BUS is defined, that particular peice of code will be used. If nothing is defined then the behaviour with else will be used.

There is another way to use these preprocessor directives. It is by defining in the properties below. If defined this way then the statement should be omitted from the main program.

The output is as follows in this case:

For more information see this.

Passing Variable arguments in functions

Sometimes it becomes necessary to have variable number of arguments in the function. One way is to overload the function but that may be unnecessary for simple logic. We can use access variable-argument lists macros in the functions. Here is a simple example:

//Program tested on Microsoft Visual Studio 2008 - Zahid Ghadialy
//Program to show how to use variable number of arguments

#include<iostream>
#include <stdarg.h> //needed for va_ macros
using namespace std;

//List Should be terminated by -1 in our case
int Add(int a,...)
{
  int total = a;
  int l_ParamVal=0;

  //Declare a va_list macro and initialize it with va_start
  va_list l_Arg;
  va_start(l_Arg,a);

  while((l_ParamVal = va_arg(l_Arg,int)) != -1)
  {
    total+= l_ParamVal;
  }

  va_end(l_Arg);
  return total;
}

int main()
{
  cout<<"Result of Add(2) = "<<Add(2, -1)<<endl;
  cout<<"Result of Add(2, 3) = "<<Add(2, 3, -1)<<endl;
  cout<<"Result of Add(2, 3, 31) = "<<Add(2, 3, 31, -1)<<endl;
  cout<<"Result of Add(2, 3, 31, 77) = "<<Add(2, 3, 31, 77, -1)<<endl;

  cout<<endl;
  return 0;
}

These type of functions that take variable number of arguments are also referred to as 'Variadic Functions'. See more details here.

The output is as follows:

Passing unnamed arguments in functions

It is possible to pass an unnamed argument in C++ function. The unnamed argument indicates that argument is unused. Typically unnamed arguments arise from the simplification of code or from planning ahead for extensions. In either case, leaving the argument in place, although unused, ensures that the callers are not affected by the change. Simple example as follows:

//Program tested on Microsoft Visual Studio 2008 - Zahid Ghadialy
//Simple example of unnamed arguments
#include<iostream>

using namespace std;

void someFunc(int a, int)
{
  cout<<"Only a is defined to "<<a<<endl;
  cout<<"The second argument is dummy"<<endl;
}

int main()
{
  someFunc(15, 100); //100 is dummy

  cout<<endl;
  return 0;
}

The output is as follows:

Converting Decimal Integer to Hexadecimal String using C++

I often encounter situations where I want to convert an Integer value to a Hexadecimal value. Now if it was just for storing, it doesnt really matter as internally decimal and hex values are the same. If it was just printing, its again very straightforward. But the problem I have is to convert it into string value (or chars[]) and use them later. I found a simple program to do this. Here it is:

//Program tested on Microsoft Visual Studio 2008 - Zahid Ghadialy
//Example of program that does int to hex string
//Adapted from http://www.dreamincode.net/forums/showtopic19694.htm
#include<iostream>
#include <stack>

using namespace std;

string int2hex(unsigned int dec)
{
  int i = 0;
  stack <int>remainder;
  string hex, temp;
  char hexDigits[] = { "0123456789abcdef" };

  if(dec == 0)
    hex = hexDigits[0];

  while (dec != 0)
  {
    remainder.push(dec % 16);
    dec /= 16;
    ++i;
  }
  
  while (i != 0)
  {
    if (remainder.top() > 15)
    {
      temp = int2hex(remainder.top());
      hex += temp;
    }
    hex.push_back(hexDigits[remainder.top()]);
    remainder.pop();
    --i;
  }
  return hex;
}


int main()
{
  unsigned int dec = 4294967295;
  string hex = int2hex(dec);
  cout<<"dec = "<<dec<<"  and hex = "<<hex.c_str()<<endl;
  dec = 123456789;
  hex = int2hex(dec);
  cout<<"dec = "<<dec<<"  and hex = "<<hex.c_str()<<endl;
  dec = 100;
  hex = int2hex(dec);
  cout<<"dec = "<<dec<<"  and hex = "<<hex.c_str()<<endl;
  dec = 15;
  hex = int2hex(dec);
  cout<<"dec = "<<dec<<"  and hex = "<<hex.c_str()<<endl;
  dec = 0;
  hex = int2hex(dec);
  cout<<"dec = "<<dec<<"  and hex = "<<hex.c_str()<<endl;
  cout<<endl;
  return 0;
}

The output is as follows:

Converting normal string/char to wide string/char and vice versa

When you are playing with wide charachters in C++, you sometimes need to covert it into normal charachters and vice versa. Here is a simple program that I picked up from somewhere but cant remember.

//Program tested on Microsoft Visual Studio 2008 - Zahid Ghadialy
//Program to convert from Wide to Narrow strings and Vice Versa
#include<iostream>
#include <sstream>

using namespace std;

wstring widen( const string& str)
{
  wostringstream wstm ;    
  const ctype<wchar_t>& ctfacet = use_facet< ctype<wchar_t> >( wstm.getloc() ) ;    
  for( size_t i=0 ; i<str.size() ; ++i )               
    wstm << ctfacet.widen( str[i] ) ;    
  return wstm.str() ;
} 

string narrow( const wstring& str )
{
  ostringstream stm ;    
  const ctype<char>& ctfacet = use_facet< ctype<char> >( stm.getloc() ) ;    
  for( size_t i=0 ; i<str.size() ; ++i )
    stm << ctfacet.narrow( str[i], 0 ) ;    
  return stm.str() ;}

int main()
{
  {      
    const wchar_t* wcstr = L"asdfg12345" ;    
    string cstr = narrow(wcstr);
    cout <<"\nOutput from wide to narrow = "<< cstr.c_str() << endl ;
  } 
  {
    const char* cstr = "zxcvb67890" ;    
    wstring wcstr = widen(cstr);
    wcout << L"\nOutput from narrow to wide = "<<wcstr.c_str() << endl ;
  }  
  return 0;
}

The output is as follows:

Advanced features of C++ functions

There are 3 advanced features of C++ functions as compared to C. They are Call by Reference, Function Overloading and Default Arguments. You can read more about them here.

A simple program showing all the three features as follows:

//Program tested on Microsoft Visual Studio 2008 - Zahid Ghadialy
//Example of pointer to const and const pointer
#include<iostream>

using namespace std;

//Call by reference
void swap(int& a, int &b)
{
  int temp = a;
  a = b;
  b = temp;
}

//Overloaded function: Call by reference (pointers)
void swap(int *a, int *b)
{
  int temp = *a;
  *a = *b;
  *b = temp;
}

//Pass by value with Default arguments
void doSwap(int a, int b = 1)
{
  swap(a,b);
  cout<<"After Local Swap: a = "<< a <<" b = "<< b <<endl;
}

int main()
{
  int a = 10, b = 17;
  cout<<"Before Swap : a = "<< a <<" b = "<< b <<endl;
  swap(a, b);
  cout<<"After Swap 1: a = "<< a <<" b = "<< b <<endl;
  swap(&a, &b);
  cout<<"After Swap 2: a = "<< a <<" b = "<< b <<endl;
  doSwap(a, b);
  doSwap(a);
  cout<<"After DoSwap: a = "<< a <<" b = "<< b <<endl;

  return 0;
}

The output is as follows:

Using Wide Charachters in C++

The normal 'char' is 8 bits. There is a 'wide char' (wchar_t) that is generally 16 bits. The width of wchar_t is compiler specific and can be as small as 8 bits. It is therefore recommended that it should not be used for creating portable programs.

A simple example as follows:

//Program tested on Microsoft Visual Studio 2008 - Zahid Ghadialy
//Simple example of printing and comparing wide charachters
#include<iostream>

using namespace std;

int main()
{
  wchar_t wide_charachter;
  wide_charachter = L'c';
  //using wcout for printing
  wcout<<"Wide Output of wide_charachter = "<<wide_charachter<<endl; 

  wstring wide_string; //wide string
  wide_string = L"A wide string";
  wcout<<"Wide Output of wide_string = "<<wide_string.c_str()<<endl;

  wstring new_wide_string(L"Another wide string");

  //comparing strings
  if(wcscmp(new_wide_string.c_str(),wide_string.c_str())== 0)
    cout<<"new_wide_string == wide_string"<<endl;
  else
    cout<<"new_wide_string != wide_string"<<endl;

  if(wcscmp(new_wide_string.c_str(),L"Another wide string")== 0)
    cout<<"new_wide_string == L\"Another wide string\""<<endl;

  return 0;
}

The output is as follows: