#include <stdio.h>
#include <string.h>
//------------------------------------
// A Standard Hello World Function
//------------------------------------
void HelloWorld1()
{
   //Here we simply use printf to display the text "1 - Hello World!"
   printf("1 - Hello World!\n");
}
//------------------------------------
// Displaying Hello World from a String
//------------------------------------
void HelloWorld2()
{
   //First we make an array of type char, 14 elements
   //long. Why 14? Since the \n is only a single
   //character (a carriage return character) shouldn't
   //we only need 13? Nope. Strings are terminated by
   //a NULL character. Without this we would run into
   //problems when manipulating them (such as reading
   //past the end into memory we dont own... Very bad.
   char String[14];
   //Now we use strcpy to copy the text to String
   strcpy(String, "Hello World!\n");
   //And print away
   printf("2 - %s", String);
}
//------------------------------------
// Allocating Memory for Hello World
//------------------------------------
void HelloWorld3()
{
   //Our variable is a pointer of type char. This means
   //it will store a value that points to a location in
   //memory. We assign pString to NULL by default even
   //though we dont really need to. Since we'll be
   //assigning pString a new value on the next line,
   //this is pointless, but its a good habit to always
   //set pointers to NULL before possible use.
   char * pString = NULL;
   //Now a pointer is useless unless it points to
   //something (other than NULL that is). So we want
   //it to point to a section of memory that we can
   //use to store our Hello World string. What we need
   //is 14 elements the size of a char. We use the 'new'
   //operator to acomplish this. Notice that 'new' returns
   //a pointer to the memory its giving us, so we say
   //say 'pString = new...' so that pString points there.
   pString = new char[14];
   //Now check this out. We can copy text to our new
   //memory using the pointer. Looks a lot like the
   //previous functions use doesnt it?
   strcpy(pString, "Hello World!\n");
   //Yup, its easy to use.
   printf("3 - %s", pString);
   //Now comes a very important part. We need to give back
   //the memory that we got by calling 'new'. If we forget
   //to delete allocated memory, we get whats called a
   //memory leak. If this function was called lots of times,
   //or it had allocated a lot of memory each time, our
   //program would quickly slow down and eventually crash.
   //Memory keeps getting allocated, and your system isnt
   //allowed to use it for anything else until its deleted.
   delete [] pString;
}
//------------------------------------
// Passing Hello World to a function
//------------------------------------
void HelloWorld4(char * pString)
{
   //This demonstrates passing a pointer to a function as an
   //argument. If you look in main() you will notice that this
   //function is called differently from the others:
   //HelloWorld4("4 - Hello World!\n");
   //Notice that we have to pass in something for pString to
   //point to. If you dont pass anything to this function when
   //its called, you will recieve an error.
   //Now we can just use this variable like it was declared here
   printf("4 - %s", pString);
}
//------------------------------------
// Combining some previous concepts and more
//------------------------------------
void HelloWorld5(char * pString)
{
   //We passed in a pointer to a string just like the last
   //example. But we also need a pointer to a string that
   //is going to contain everything we put together in a
   //minute.
   char * pAlteredString = NULL;
   //Allocate memory for pAlteredString. Its going to hold
   //the contents of what pString points to as well as 8 more
   //characters. But we dont know how big pString is! Thats
   //where we use strlen. It gets the length of a string.
   //strlen doesnt count the terminating NULL character so we
   //have to make room for that in our calculations. Hence the
   //+9 instead of the expected 8.
   pAlteredString = new char[strlen(pString) + 9];
   //Copy what pString points to over to the memory that
   //pAlteredString points to.
   strcpy(pAlteredString, pString);
   //Very simular to strcpy, we now use strcat to copy some
   //more text on the end of pAlteredString.
   strcat(pAlteredString, " World!\n");
   //Now print.
   printf("5 - %s", pAlteredString);
   //Of course, since we allocated memory, we have to delete it,
   //just like before.
   delete [] pAlteredString;
}
//------------------------------------
// Returning Hello World
//------------------------------------
char * HelloWorld6()
{
   //Notice that this function isnt of type void. Its return
   //value is a pointer of type char. In main we see this:
   //printf( "6 - %s", HelloWorld6() );
   //Since HelloWorld6 returns a pointer to char back to the
   //caller, we can use the function just like a char * variable
   //in this instance.
   //Return this text
   return "Hello World!\n";
}
//------------------------------------
// Error checking Hello World
//------------------------------------
int HelloWorld7(char * pString)
{
   //Here, we see a lot of the same things we saw before, used
   //in a slightly different manner. We're passed in a pointer
   //to char, and the return type is of type int. Previous
   //examples showed us how that works.
   //Here we check to make sure that something actually got
   //passed in. Remember that pString is just a pointer and in
   //a more complicated program, its possible that pString might
   //not be pointing to anything yet, which would make it very
   //evil for us to be using. This displays one important reason
   //for setting pointers to NULL when they're declared. It makes
   //it easy to check if theres any memory where its pointing.
   if (pString != NULL)
   {
      //If pString does point to something, then we print it
      printf("7 - %s", pString);
   }
   else
   {
      //If pString doesnt point to anything then we print this
      //error message.
      printf("Invalid parameter! pString is not an initialised pointer!\n");
      //Then we exit the function by calling return. We're going
      //to return the value 1. Go have a look in main to see how
      //we're going to handle what happens to this value.
      return 1;
   }
   //Just for kicks we're going to check to see if the text is
   //what we expect it to be. We use strcmp to compare pString
   //to what we're expecting.
   if (strcmp(pString, "Hello World!\n") != 0)
   {
      //If the text wasn't exactly "Hello World!\n", then we're
      //going to print an error about it and return 1 to the
      //calling function to report our error.
      printf("Invalid parameter! pString contains invalid data!\n");
      return 1;
   }
   //It looks like everything worked out fine. We're going to
   //return 0 to tell the calling function that everything is
   //going smoothly.
   return 0;
}
//------------------------------------
// Disecting Hello World
//------------------------------------
void HelloWorld8(char * pString, unsigned int len)
{
   //We pass two arguments to this function. The first is a
   //pointer to type char as we've seem a million times before.
   //The second is an integer (int) which is going to tell us
   //the length of the text that pString points to.
   //Looking in main we see:
   //HelloWorld8("Hello World! - With Garbage!!!\n", 12);
   //Notice that we're passing in a really long string, but that
   //only the "Hello World!" part gets displayed. That because
   //we're passing in the len value as 12, and this function will
   //only display that many characters of the string. Try changing
   //that value to see it in action...
   //We need to keep track of what element we're printing so we
   //need a variable for that.
   unsigned int i;
   //By default display which function number we're on first:
   printf("8 - ");
   //If someone set len up to be longer than the string they passed
   //in, that would get messy. We would be accessing memory that we
   //dont own, and thats something we never want to do. So we truncate
   //len if its longer than the total character in pString.
   if (len > strlen(pString))
      len = strlen(pString);
   //Now we loop through the text displaying 'len' # of characters. 
   for(i = 0; i < len; i ++)
   {
      //Since pString is a pointer to n elements of type char, we
      //can use the [] operator to move through the elements in
      //memory. Its exactly like the elements in an array, we're
      //just seeing it at a more naked level.
      printf("%c", pString[i]);
   }
   //Put a carriage return at the end of everything.
   printf("\n");
}
//------------------------------------
// Figuring out Hello World
//------------------------------------
void HelloWorld9(char * pString)
{
   //This is a lot like the previous function, but notice that
   //we have no idea how much we're supposed to display. We're
   //going to keep reading the memory pointed to by pString
   //until we reach the end. But how do we know when we get to
   //the end? NULL terminating character to the resuce!
   //We need to set our counting variable to 0 here since we're
   //not using a for loop to do it.
   unsigned int i = 0;
   //By default display which function number we're on first:
   printf("9 - ");
   //A do...while loop. This will keep looping until the
   //condition in the 'while' enclosing brackets is true.
   //In this case that means when the element of memory we
   //just moved to is NULL. Everything else works just like
   //in the previous example. Print each character then move
   //to the next element and repeat.
   do
   {
      printf("%c", pString[i]);
      i ++;
   }while(pString[i] != NULL);
}
//------------------------------------
// MAIN
//------------------------------------
int main (void)
{
   HelloWorld1();
   HelloWorld2();
   HelloWorld3();
   HelloWorld4("Hello World!\n");
   HelloWorld5("Hello");
   printf( "6 - %s", HelloWorld6() );
   if (HelloWorld7("Hello World!\n") != 0)
   {
      printf("HelloWorld7 function failed!\n");
      return 1;
   }
   HelloWorld8("Hello World! - With Garbage!!!\n", 12);
   HelloWorld9("Hello World!\n");
   return 0;
}