Advanced C Programming – Sample Programs

/*------------------------------------------------------------------------------------------------ 
 *   Author         : Emertxe (https://emertxe.com) 
 *   Date           : Wed 08 Mar 2016 16:00:04 IST
 *   File           : c_t010_ch1_datatypes.c
 *   Title          : C basic datatypes
 *   Description    : A simple program exploring the basic C data types. C supports two basic 
 *                    datatypes hold integral and real objects as int and float (single precision). 
 *                    The char falls under the integral category
 *----------------------------------------------------------------------------------------------*/
#include 
int main()
{
    int account_number;
    float ammount;
    char currency;
    account_number = 1024;
    ammount = 100.5;
    currency = '$';
    printf("Mr. Xyz with account number %d owes me %f %cn", account_number, ammount, currency);
    return 0;
}

/*------------------------------------------------------------------------------------------------- 
 *   Author         : Emertxe (https://emertxe.com) 
 *   Date           : Wed 08 Mar 2016 16:00:04 IST
 *   File           : c_t011_ch1_char_datatype.c
 *   Title          : Character datatype handling
 *   Description    : The character datatype is generally used to store printable symbol on screen 
 *                    in variable. This program demonstrates that char literals are stored as ascii 
 *                    values. You can note that, the char datatype can be used to store numbers 
 *                    too!! which when printed shows the corresponding  ASCII symbol on screen.
 *------------------------------------------------------------------------------------------------*/
#include 
int main()
{
    char ch1 = '0';
    char ch2 = 'A';
    char ch3 = 65;
    printf("The character is %c with decimal equivalent %dn", ch1, ch1);
    printf("The character is %c with decimal equivalent %dn", ch2, ch2);
    printf("The character is %c with decimal equivalent %dn", ch3, ch3);
    return 0;
}

/*------------------------------------------------------------------------------------------------ 
 *   Author         : Emertxe (https://emertxe.com) 
 *   Date           : Wed 08 Mar 2016 16:00:04 IST
 *   File           : c_t012_ch2_escape_characters.c
 *   Title          : Character datatype handling
 *   Description    : The character datatype is generally used to store printable symbol on screen 
 *                    in variable. This program demonstrates that char literals are stored as ascii 
 *                    values. You can note that, the char datatype can be used to store escape 
 *                    character too!! which when printed shows the corresponding ASCII symbol on 
 *                    the screen.
 *-----------------------------------------------------------------------------------------------*/
#include 
int main()
{
    char ch1 = '7'; // Octal 7
    char ch2 = 'x8'; // Hexadecimal 8
    char ch3 = 'xA'; // Hexadecimal A which is equivalent to n
    /* This line should print the values of ch1 and ch2 with a new line */
    printf("ch1 = %d, ch2 = %d%c", ch1, ch2, ch3);
    return 0;
}

/*------------------------------------------------------------------------------------------------
 *   Author         : Emertxe (https://emertxe.com) 
 *   Date           : Wed 08 Mar 2016 16:00:04 IST
 *   File           : c_t013_ch1_type_modifiers.c
 *   Title          : C basic datatypes
 *   Description    : A simple program exploring the basic C data types. C supports two basic 
 *                    datatypes hold integral and real objects as int and float (single precision). 
 *                    The char falls under the integral category. Any variable defined with integral 
 *                    datatypes can be modified for its signedness and width properties. This 
 *                    example demonstrates the width modification.
 *-----------------------------------------------------------------------------------------------*/
 
#include 
 
int main()
{
     short int count1;
     int long count2;
     short count3;

     /* Let's assume a 32 bit system */
     printf("count1 can now store only %u bytesn", sizeof(count1));
     printf("count2 can now store only %u bytesn", sizeof(count2));
     printf("count3 can now store only %u bytesn", sizeof(count3));
 
     return 0;
}

/*----------------------------------------------------------------------------------------------- 
 *   Author         : Emertxe (https://emertxe.com) 
 *   Date           : Wed 08 Mar 2016 16:00:04 IST
 *   File           : c_t014_ch1_type_modifiers.c
 *   Title          : C basic datatypes
 *   Description    : A simple program exploring the basic C data types. C supports two basic 
 *                    datatypes hold integral and real objects as int and float(single precision). 
 *                    The char falls under the integral category.Any variable defined with integral 
 *                    datatypes can be modified for its signedness and width properties. This 
 *                    example demonstrates the sign modification.
 *-----------------------------------------------------------------------------------------------*/
#include 
int main()
{
    char num1;
    unsigned char num2;
    num1 = -1;
    num2 = -1;
    /* Instruct the printf to print the number in decimal for which default is signed */
    printf("num1 = %dn", num1);
    /* Instruct the printf to print the number in unsigned decimal */
    printf("num2 = %un", num2);
    /* The type conversion fundamental come into picture here */
    /* The smaller type get promoted to bigger when opertion happens between them */
    printf("num1 = %dn", num1 & 0xFF);
    printf("num2 = %dn", num2 & 0xFF);
    return 0;
}

/*------------------------------------------------------------------------------------------------ 
 *   Author         : Emertxe (https://emertxe.com) 
 *   Date           : Wed 08 Mar 2016 16:00:04 IST
 *   File           : c_t015_ch1_type_modifiers.c
 *   Title          : C basic datatypes
 *   Description    : A simple program exploring the basic C data types. C supports two basic 
 *                    datatypes hold integral and real objects as int and float (single precision). 
 *                    The char falls under the integral category. Any variable defined with integral 
 *                    datatypes can be modified for its signedness and width properties. This 
 *                    example demonstrates the storage modification of variable.
 *------------------------------------------------------------------------------------------------*/
#include 
int main()
{
    /* 
    * Request the compiler to provide a CPU register space if available
    * The allocation become auto on failure to get register space
    */ 
    register int i;
    for (i = 0; i < 10; i++)
    {
        puts("hello");
    }
    return 0;
}

/*------------------------------------------------------------------------------------------------ 
 *   Author         : Emertxe (https://emertxe.com) 
 *   Date           : Wed 08 Mar 2016 16:00:04 IST
 *   File           : c_t016_ch1_type_modifiers.c
 *   Title          : C basic datatypes
 *   Description    : A simple program exploring the basic C data types. C supports two basic 
 *                    datatypes hold integral and real objects as int and float (single precision). 
 *                    The char falls under the integral category. Any variable defined with integral 
 *                    datatypes can be modified for its signedness and width properties. This 
 *                    example demonstrates the storage modification of variable.
 *-----------------------------------------------------------------------------------------------*/
#include 
int main()
{
    /* 
    * Request the compiler to provide a CPU register space if available
    * The allocation become auto on failure to get register space
    */ 
    register int number;
    printf("Enter a number: ");
    /* Cannot access the address of a variable specified with register keyword */
    scanf("%d", &number);
    printf("You entered: %d", number);
    return 0;
}

/*------------------------------------------------------------------------------------------------ 
 *   Author         : Emertxe (https://emertxe.com) 
 *   Date           : Wed 08 Mar 2016 16:00:04 IST
 *   File           : c_t017_ch1_if.c
 *   Title          : Flow control statement - if condtion
 *   Description    : As we all know that a program generally execute in an sequence unless and 
 *                    until we have some condition to change the flow of execution. C Programming 
 *                    Language supports different flow conditions. This program demonstrates if 
 *                    condition.
 *-----------------------------------------------------------------------------------------------*/
#include 
int main()
{
    int number;
    printf("Enter a number: ");
    scanf("%d", &number);
    if (number < 5) { printf("number is less than 5n"); } /* The below syntax is to valid since it has only one statement under test condtion */ if (number > 5)
        printf("number is greater than 5n");
    /* Would would be using the below syntax if you have mutli statments under test condtion */
    if (number == 5)
    {
        printf("number is equal to 5n");
        printf("Done. So simple right!!n");
    }
    return 0;
}

/*----------------------------------------------------------------------------------------------- 
 *   Author         : Emertxe (https://emertxe.com) 
 *   Date           : Wed 08 Mar 2016 16:00:04 IST
 *   File           : c_t019_ch1_if_else_if.c
 *   Title          : Flow control statement - if condtion
 *   Description    : As we all know that a program generally execute in an sequence unless and 
 *                    until we have some condition to change the flow of execution. C Programming 
 *                    Language supports different flow conditions. This program demonstrates if 
 *                    else if condition.
 *-----------------------------------------------------------------------------------------------*/
#include 
int main()
{
    int number;
    printf("Enter a number: ");
    scanf("%d", &number);
    if (number < 5) { printf("number is less than 5n"); } /* Any number of else if conditional check can be done */ else if (number > 5)
    {
        printf("number is greater than 5n");
    }
    /* Not manditory */
    else
    {
        printf("number is equal to 5n");
    }
    return 0;
}

/*-----------------------------------------------------------------------------------------------
* Author : Emertxe (https://emertxe.com)
* Date : Wed 08 Mar 2016 16:00:04 IST
* File : c_t020_ch1_switch.c
* Title : Flow control statement - switch statements
* Description : As we all know that a program generally execute in an sequence unless and
* until we have some condition to change the flow of execution. C Programming
* Language supports different flow conditions. This program demonstrates switch
* statements.
*-----------------------------------------------------------------------------------------------*/
#include 
    int main()
    {
    char user_input;
    printf("Enter an alphabet [Please enter lower case]: ");
    scanf("%c", &user_input);
    switch (user_input)
    {
    case 'a':
    printf("%c is an voweln", user_input);
    break;
    case 'e':
    printf("%c is an voweln", user_input);
    break;
    case 'i':
    printf("%c is an voweln", user_input);
    break;
    case 'o':
    printf("%c is an voweln", user_input);
    break;
    case 'u':
    printf("%c is an voweln", user_input);
    break;
    default:
    printf("%c is not a voweln", user_input);
    break;
    }
    printf("Please make sure you check the next examplen");
    return 0;
    }

/*-------------------------------------------------------------------------------------------------
* Author : Emertxe (https://emertxe.com)
* Date : Wed 08 Mar 2016 16:00:04 IST
* File : c_t022_ch1_switch.c
* Title : Flow control statement - switch statements
* Description : As we all know that a program generally execute in an sequence unless and
* until we have some condition to change the flow of execution. C Programming
* Language supports different flow conditions. This program demonstrates switch
* statements.
*------------------------------------------------------------------------------------------------*/
#include 
    int main()
    {
    char user_input;
    printf("Let me tell you what you typed [Try me]: ");
    scanf("%c", &user_input);
    switch (user_input)
    {
    /* You can provide a range as shown below */
    case 'a' ... 'z':
    printf("You entered a lower case alphabetn");
    break;
    case 'A' ... 'Z':
    printf("You entered an upper case alphabetn");
    break;
    case '0' ... '9':
    printf("You entered a numbern");
    break;
    default:
    printf("Oops :( you caught me!!n");
    break;
    }
    return 0;
    }

/*------------------------------------------------------------------------------------------------- 
 *   Author         : Emertxe (https://emertxe.com) 
 *   Date           : Wed 08 Mar 2016 16:00:04 IST
 *   File           : c_t023_ch1_switch.c
 *   Title          : Flow control statement - switch statements
 *   Description    : As we all know that a program generally execute in an sequence unless and 
 *                    until we have some condition to change the flow of execution. C Programming 
 *                    Language supports different flow conditions. This program demonstrates switch 
 *                    statements.
 *------------------------------------------------------------------------------------------------*/
#include 
int main()
{
    int number;
    printf("Please enter a number: ");
    scanf("%d", &number);
    switch (number)
    {
        /* The labels should not contain a variable (i.e a run time expression) */
        case number + 1:
            printf("You entered %fn", number);
            break;
        case number + 2:
            printf("You entered %fn", number);
            break;
        default:
            printf("Try again!!n");
            break;
    }
    return 0;
}

/*------------------------------------------------------------------------------------------------- 
 *   Author         : Emertxe (https://emertxe.com) 
 *   Date           : Wed 08 Mar 2016 16:00:04 IST
 *   File           : c_t024_ch1_switch.c
 *   Title          : Flow control statement - switch statements
 *   Description    : As we all know that a program generally execute in an sequence unless and 
 *                    until we have some condition to change the flow of execution. C Programming 
 *                    Language supports different flow conditions. This program demonstrates switch 
 *                    statements.
 *------------------------------------------------------------------------------------------------*/

#include 

int main()
{
    float number;

    printf("Please enter a number: ");
    scanf("%f", &number);

    /* The switch expression should always be an integral expression */
    switch (number)
    {
        /* The labels should always evaluate to integral values */
        case 1.5:
            printf("You entered %fn", number);
            break;
        case 2.5:
            printf("You entered %fn", number);
            break;
        default:
            printf("Try again!!n");
            break;
    }

    return 0;
}

/*------------------------------------------------------------------------------------------------- 
 *   Author         : Emertxe (https://emertxe.com) 
 *   Date           : Wed 08 Mar 2016 16:00:04 IST
 *   File           : c_t025_ch1_switch.c
 *   Title          : Flow control statement - switch statements
 *   Description    : As we all know that a program generally execute in an sequence unless and 
 *                    until we have some condition to change the flow of execution. C Programming 
 *                    Language supports different flow conditions. This program demonstrates switch 
 *                    statements.
 *------------------------------------------------------------------------------------------------*/

#include 

int main()
{
    int number;

    printf("Please enter a number: ");
    scanf("%d", &number);

    switch (number)
    {
        /* The compiler evaluates this as 11 while compilation and find its as duplicate label */
        case 10 + 1:
            printf("You entered %fn", number);
            break;
        case 11:
            printf("You entered %fn", number);
            break;
        default:
            printf("Try again!!n");
            break;
    }

    return 0;
}

/*------------------------------------------------------------------------------------------------ 
 *   Author         : Emertxe (https://emertxe.com) 
 *   Date           : Wed 08 Mar 2016 16:00:04 IST
 *   File           : c_t026_ch1_switch.c
 *   Title          : Flow control statement - switch statements
 *   Description    : As we all know that a program generally execute in an sequence unless and 
 *                    until we have some condition to change the flow of execution. C Programming 
 *                    Language supports different flow conditions. This program demonstrates switch 
 *                    statements.
 *----------------------------------------------------------------------------------------------*/

#include 

int main()
{
    int number;

    printf("Please enter a number: ");
    scanf("%d", &number);

    switch (number)
    {
        /* The default lable can be put anywhere in the body */
        default:
            printf("Try again!!n");
            /* Make sure you have a break here, else it will lead to fall through */
            break;
        case 10 + 1:
            printf("You entered %fn", number);
            break;
        case 11:
            printf("You entered %fn", number);
            break;
    }

    return 0;
}

/*------------------------------------------------------------------------------------------------ 
 *   Author         : Emertxe (https://emertxe.com) 
 *   Date           : Wed 09 Mar 2016 16:00:04 IST
 *   File           : c_t027_ch1_while.c
 *   Title          : Flow control statement - while loop
 *   Description    : As we all know that a program generally execute in an sequence unless and 
 *                    until we have some condition to change the flow of execution. C Programming 
 *                    Language supports different flow conditions. This program demonstrates while 
 *                    loop.
 *-----------------------------------------------------------------------------------------------*/
#include 
int main()
{
    int user_input;
    int i = 0;
    printf("Enter an the length of the number series: ");
    scanf("%d", &user_input);
    if (user_input < 1)
    {
        printf("Invalid inputn");
        return 1;
    }
    printf("The series is: ");
    /* The condtion is evaluated before entering the loop */
    while (i < user_input)
    {
        printf("%d ", i++);
    }
    printf("n");
    return 0;
}

/*----------------------------------------------------------------------------------------------- 
 *   Author         : Emertxe (https://emertxe.com) 
 *   Date           : Wed 09 Mar 2016 16:00:04 IST
 *   File           : c_t028_ch1_while.c
 *   Title          : Flow control statement - do while loop
 *   Description    : As we all know that a program generally execute in an sequence unless and 
 *                    until we have some condition to change the flow of execution. C Programming 
 *                    Language supports different flow conditions. This program demonstrates do 
 *                    while loop.
 *----------------------------------------------------------------------------------------------*/
#include 
int main()
{
    int user_input;
    int i = 0;
    printf("Enter an the length of the number series: ");
    scanf("%d", &user_input);
    if (user_input < 1)
    {
        printf("Invalid inputn");
        return 1;
    }
    printf("The series is: ");
    /* The condtion is evaluated after entering the loop */
    do
    {
        printf("%d ", i++);
    } while (i < user_input);
    printf("n");
    return 0;
}

/*----------------------------------------------------------------------------------------------- 
 *   Author         : Emertxe (https://emertxe.com) 
 *   Date           : Wed 09 Mar 2016 16:00:04 IST
 *   File           : c_t029_ch1_while.c
 *   Title          : Flow control statement - do while vs while loop
 *   Description    : As we all know that a program generally execute in an sequence unless and 
 *                    until we have some condition to change the flow of execution. C Programming 
 *                    Language supports different flow conditions. This program demonstrates 
 *                    do while vs while loop
 *----------------------------------------------------------------------------------------------*/

#include 

int main()
{
    /* 
     * A simple and effective example to understand the difference between 
     * do while and while
     */ 
    do
    {
        printf("I should be seenn");
    } while (0);

    while (0)
    {
        printf("Nope, I should not be seenn");
    }

    return 0;
}

/*------------------------------------------------------------------------------------------------ 
 *   Author         : Emertxe (https://emertxe.com) 
 *   Date           : Wed 09 Mar 2016 16:00:04 IST
 *   File           : c_t030_ch1_while.c
 *   Title          : Flow control statement - for loop
 *   Description    : As we all know that a program generally execute in an sequence unless and 
 *                    until we have some condition to change the flow of execution. C Programming 
 *                    Language supports different flow conditions. This program demonstrates 
 *                    for loop.
 *----------------------------------------------------------------------------------------------*/
#include 
int main()
{
    int user_input;
    int i = 0;
    printf("Enter an the length of the number series: ");
    scanf("%d", &user_input);
    if (user_input < 1)
    {
        printf("Invalid inputn");
        return 1;
    }
    printf("The series is: ");
    /* 
     * The initialization section is evaluated first and only once
     * The condtion is evaluated next before entering the loop
     * On true condition the loop body is executed and then
     * The post evaluation expression is evaluated followed by condition check
     */
    for (i = 0; i < user_input; i++)
    {
        printf("%d ", i++);
    }
    printf("n");
    return 0;
}

/*------------------------------------------------------------------------------------------------ 
 *   Author         : Emertxe (https://emertxe.com) 
 *   Date           : Wed 09 Mar 2016 16:00:04 IST
 *   File           : c_t031_ch1_goto.c
 *   Title          : Flow control statement - goto statement
 *   Description    : As we all know that a program generally execute in an sequence unless and 
 *                    until we have some condition to change the flow of execution. C Programming 
 *                    Language supports different flow conditions. This program demonstrates 
 *                    goto statement
 *----------------------------------------------------------------------------------------------*/
#include 
int main()
{
    int user_input;
    int i = 0;
    printf("Enter an the length of the number series: ");
    scanf("%d", &user_input);
    if (user_input < 1)
    {
        printf("Invalid inputn");
        return 1;
    }
    printf("The series is: ");
LOOP1:
    if (i != user_input)
    {
        printf("%d ", i++);
        goto LOOP1;
    }
    printf("n");
    return 0;
}

/*------------------------------------------------------------------------------------------------ 
 *   Author         : Emertxe (https://emertxe.com) 
 *   Date           : Wed 09 Mar 2016 16:00:04 IST
 *   File           : c_t031_ch1_goto.c
 *   Title          : Flow control statement - goto statement
 *   Description    : As we all know that a program generally execute in an sequence unless and 
 *                    until we have some condition to change the flow of execution. C Programming 
 *                    Language supports different flow conditions. This program demonstrates 
 *                    goto statement
 *----------------------------------------------------------------------------------------------*/
#include 
int main()
{
    int user_input;
    int i = 0;
    printf("Enter an the length of the number series: ");
    scanf("%d", &user_input);
    if (user_input < 1)
    {
        printf("Invalid inputn");
        return 1;
    }
    printf("The series is: ");
LOOP1:
    if (i != user_input)
    {
        printf("%d ", i++);
        goto LOOP1;
    }
    printf("n");
    return 0;
}

/*----------------------------------------------------------------------------------------------- 
 *   Author         : Emertxe (https://emertxe.com) 
 *   Date           : Wed 09 Mar 2016 16:00:04 IST
 *   File           : c_t033_ch1_break.c
 *   Title          : Flow control statement - break statement
 *   Description    : As we all know that a program generally execute in an sequence unless and 
 *                    until we have some condition to change the flow of execution. C Programming 
 *                    Language supports different flow conditions. This program demonstrates 
 *                    break statement
 *----------------------------------------------------------------------------------------------*/
#include 
int main()
{
    int i, number;
    printf("Enter a number: ");
    scanf("%d", &number);
    for (i = 0; i < 10; i++)
    {
        if (i == number)
        {
            printf("Number matchedn");
            /* 
             * Breaks the multi itretive loops (for, while and do while) 
             * under which it is stated 
             * One exception is the swtich statement
             */
            break;
        }
    }
    if (i == 10)
    {
        printf("Number not matchedn");
    }
    return 0;
}

/*------------------------------------------------------------------------------------------------ 
 *   Author         : Emertxe (https://emertxe.com) 
 *   Date           : Wed 09 Mar 2016 16:00:04 IST
 *   File           : c_t034_ch1_continue.c
 *   Title          : Flow control statement - continue statement
 *   Description    : As we all know that a program generally execute in an sequence unless and 
 *                    until we have some condition to change the flow of execution. C Programming 
 *                    Language supports different flow conditions.This program demonstrates 
 *                    continue statement
 *----------------------------------------------------------------------------------------------*/

#include 

int main()
{
    int i, number;
    int flag = 0;

    printf("Enter a number: ");
    scanf("%d", &number);

    for (i = 0; i < 10; i++)
    {
        if (i != number)
        {

            /* 
             * Continues the multi itretive loops (for, while and do while) 
             * under which it is stated 
             */
            continue;
        }
        printf("Number matchedn");
    }

    return 0;
}

/*----------------------------------------------------------------------------------------------- 
 *   Author         : Emertxe (https://emertxe.com) 
 *   Date           : Wed 09 Mar 2016 16:00:04 IST
 *   File           : c_t035_ch1_invalid_break_continue.c
 *   Title          : Flow control statement - Invalid use of break & continue statement
 *   Description    : As we all know that a program generally execute in an sequence unless and 
 *                    until we have some condition to change the flow of execution. C Programming 
 *                    Language supports different flow conditions. This program demonstrates how 
 *                    NOT to use break and continue statements.
 *---------------------------------------------------------------------------------------------*/
#include 
int main()
{
    char option;
    int num1 = 10, num2 = 20, sum;
    printf("Enter two numbers to be addedn");
    printf("Number1: ");
    scanf("%d", &num1);
    printf("Number2: ");
    scanf("%d", &num2);
    sum = num1 + num2;
    printf("The result of the expression is %dn", sum);
    printf("Do you want to Exit? [Y - Yes]: ");
    scanf("%c", &option);
    if (option != 'Y')
    {
        /* 
         * Invalid use of break
         * Can appear only inside swtich, while, do while and for loops
         */
        break;
    }
    else
    {
        /* 
         * Invalid use of continue
         * Can appear only inside while, do while and for loops
         */
        continue;
    }
    return 0;
}

/*----------------------------------------------------------------------------------------------- 
 *   Author         : Emertxe (https://emertxe-group.com) 
 *   Date           : Wed 09 Mar 2016 16:00:04 IST
 *   File           : c_t036_ch1_nested_loops.c
 *   Title          : Flow control statement - Nested Loops
 *   Description    : As we all know that a program generally execute in an sequence unless and 
 *                    until we have some condition to change the flow of execution. C Programming 
 *                    Language supports different flow conditions. This program demonstrates 
 *                    nested loops
 *----------------------------------------------------------------------------------------------*/
#include 
int main()
{
    int i, j;
    int inner_loop_length = 1;
    for (i = 0; i < 5; i++)
    {
        for (j = 0; j < inner_loop_length; j++)
        {
            printf("*");
        }
        printf("n");
        inner_loop_length++;
    }
    return 0;
}

/*---------------------------------------------------------------------------------------------- 
 *   Author         : Emertxe (https://emertxe.com) 
 *   Date           : Wed 9 Mar 2016 16:00:04 IST
 *   File           : c_t037_ch1_arith_oper_pre_post.c
 *   Title          : Operators - Arithmetic - Pre and Post
 *   Description    : Symbols that instructs the compiler to perform specific arithmetic or 
 *                    logical operation on operands. All C operators do 2 things
 *                     - Operates on its operands
 *                     - Returns a value
 *                    Operators play a very crucial role in controlling the system behaviour in 
 *                    general. There are different types of Operators available in C Programming 
 *                    Language. This example demonstrates the behaviour of post and pre increment 
 *                    operators.
 *----------------------------------------------------------------------------------------------*/
#include 
int main()
{
    int x = 0;
    int y;
    /* Snippet A */
    y = ++x;
    printf("x = %d, y = %dn", x, y);
    /* Snippet B */
    x = 0;
    y = x++;
    printf("x = %d, y = %dn", x, y);
    return 0;
}

/*----------------------------------------------------------------------------------------------- 
 *   Author         : Emertxe (https://emertxe.com) 
 *   Date           : Wed 9 Mar 2016 16:00:04 IST
 *   File           : c_t038_ch1_arith_oper_pre_post.c
 *   Title          : Operators - Arithmetic - Pre and Post
 *   Description    : Symbols that instructs the compiler to perform specific arithmetic or 
 *                    logical operation on operands. All C operators do 2 things
 *                     - Operates on its operands
 *                     - Returns a value
 *                    Operators play a very crucial role in controlling the system behaviour in 
 *                    general. There are different types of Operators available in C Programming 
 *                    Language. This example demonstrates the behaviour of post and pre 
 *                    increment operators.
 *---------------------------------------------------------------------------------------------*/
#include 
int main()
{
    int x = 0;
    /* The value gets incremented but not reflected to x */
    if (x++)
        puts("Yes :)");
    else
        puts("Huh :(");
    printf("x = %dn", x);
    /* The value gets decremented and reflected to x on the same expression */
    if (--x)
        puts("Yes :)");
    else
        puts("Huh :(");
    printf("x = %dn", x);
    return 0;
}

/*----------------------------------------------------------------------------------------------- 
 *   Author         : Emertxe (https://emertxe.com) 
 *   Date           : Wed 9 Mar 2016 16:00:04 IST
 *   File           : c_t039_ch1_type_conversions.c
 *   Title          : Type conversion - Implicit - Promotion
 *   Description    : Symbols that instructs the compiler to perform specific arithmetic or 
 *                    logical operation on operands. All C operators do 2 things
 *                     - Operates on its operands
 *                     - Returns a value
 *                    Operators play a very crucial role in controlling the system behaviour in 
 *                    general. There are different types of Operators available in C Programming 
 *                    Language. This example demonstrates the behaviour of post and pre 
 *                    increment operators.
 *---------------------------------------------------------------------------------------------*/
#include 
int main()
{
    unsigned int count1 = 10;
    signed int count2 = -1;
    /* The smaller type get promoted to bigger, when opertion happens between them */
    if (count1 > count2)
    {
        printf("Yesn");
    }
    else
    {
        printf("Non");
    }
    return 0;
}

/*----------------------------------------------------------------------------------------------- 
 *   Author         : Emertxe (https://emertxe.com) 
 *   Date           : Wed 9 Mar 2016 16:00:04 IST
 *   File           : c_t041_ch1_type_conversions.c
 *   Title          : Type conversion - Explicit - Demotion
 *   Description    : Symbols that instructs the compiler to perform specific arithmetic or 
 *                    logical operation on operands. All C operators do 2 things
 *                     - Operates on its operands
 *                     - Returns a value
 *                    Operators play a very crucial role in controlling the system behaviour in 
 *                    general. There are different types of Operators available in C Programming 
 *                    Language. This example demonstrates the behaviour of post and pre 
 *                    increment operators.
 *---------------------------------------------------------------------------------------------*/ 
#include 
int main()
{
    int i;
    int array[5] = {1, 2, 3, 4, 5};
    /* We explicitly demote the unsigned to signed, hence it enters the loop */
    for (i = -1; i < (signed) (sizeof(array) / sizeof(int) - 1); i++)
    {
        printf("%dn", array[i + 1]);
    }
    return 0;
}

/*----------------------------------------------------------------------------------------------- 
 *   Author         : Emertxe (https://emertxe.com) 
 *   Date           : Wed 9 Mar 2016 16:00:04 IST
 *   File           : c_t042_ch1_type_conversions.c
 *   Title          : Type conversion - Explicit - Promotion
 *   Description    : Symbols that instructs the compiler to perform specific arithmetic or 
 *                    logical operation on operands. All C operators do 2 things
 *                     - Operates on its operands
 *                     - Returns a value
 *                    Operators play a very crucial role in controlling the system behaviour in 
 *                    general. There are different types of Operators available in C Programming 
 *                    Language. This example demonstrates the behaviour of post and pre 
 *                    increment operators.
 *---------------------------------------------------------------------------------------------*/  

#include 

int main()
{
    float celcius, farenheit;

    printf("Enter the farenheit value: ");
    scanf("%f", &farenheit);

    /* Explicit promotion of int to float */
    celcius = ((float) 5 / 9) * (farenheit - 32);

    printf("Farenheit %f is %f Celciusn", farenheit, celcius);

    return 0;
}

/*----------------------------------------------------------------------------------------------- 
 *   Author         : Emertxe (https://emertxe.com) 
 *   Date           : Wed 9 Mar 2016 16:00:04 IST
 *   File           : c_t042_ch1_type_conversions.c
 *   Title          : Type conversion - Explicit - Promotion
 *   Description    : Symbols that instructs the compiler to perform specific arithmetic or 
 *                    logical operation on operands. All C operators do 2 things
 *                     - Operates on its operands
 *                     - Returns a value
 *                    Operators play a very crucial role in controlling the system behaviour in 
 *                    general. There are different types of Operators available in C Programming 
 *                    Language. This example demonstrates the behaviour of post and pre 
 *                    increment operators.
 *---------------------------------------------------------------------------------------------*/  

#include 

int main()
{
    float celcius, farenheit;

    printf("Enter the farenheit value: ");
    scanf("%f", &farenheit);

    /* Explicit promotion of int to float */
    celcius = ((float) 5 / 9) * (farenheit - 32);

    printf("Farenheit %f is %f Celciusn", farenheit, celcius);

    return 0;
}

/*----------------------------------------------------------------------------------------------- 
 *   Author         : Emertxe (https://emertxe.com) 
 *   Date           : Wed 9 Mar 2016 16:00:04 IST
 *   File           : c_t043_ch1_type_conversions.c
 *   Title          : Type conversion - Sign bit extension
 *   Description    : Symbols that instructs the compiler to perform specific arithmetic or 
 *                    logical operation on operands. All C operators do 2 things
 *                     - Operates on its operands
 *                     - Returns a value
 *                    Operators play a very crucial role in controlling the system behaviour in 
 *                    general. There are different types of Operators available in C Programming 
 *                    Language. This example demonstrates the behaviour of post and pre 
 *                    increment operators.
 *---------------------------------------------------------------------------------------------*/   
#include 
int main()
{
    signed char ch1 = -1;
    unsigned char ch2 = 255;
    printf("ch1(signed) = %dn", ch1); // Sign extension happens here
    printf("ch2 = %dn", ch2); // For unsigned numbers 0's are added
    printf("ch1(signed) = %Xn", ch1); // Sign extension happens here
    printf("ch2 = %Xn", ch2); // For unsigned numbers 0's are added
    return 0;
}

/*--------------------------------------------------------------------------------------------- 
 *   Author         : Emertxe (https://emertxe.com) 
 *   Date           : Wed 9 Mar 2016 16:00:04 IST
 *   File           : c_t044_ch1_true_of_false.c
 *   Title          : Testing of the weight of a variable for TRUE or FALSE
 *   Description    : Symbols that instructs the compiler to perform specific arithmetic or 
 *                    logical operation on operands. All C operators do 2 things
 *                     - Operates on its operands
 *                     - Returns a value
 *                    Operators play a very crucial role in controlling the system behaviour in 
 *                    general. There are different types of Operators available in C Programming 
 *                    Language. This example demonstrates an assignment operator and its use 
 *                    with if statement to evaluate TRUE or FALSE.
 *-------------------------------------------------------------------------------------------*/   

#include 

int main()
{
    int x = 10;

    /*
     * The value 0 is assigned to x here making its weight 0
     * So in C any variable which is non zero is TRUE
     * The below evaluation becomes false leading to else part
     */
    if (x = 0) 
    {
        printf("Hellon");
    }
    else
    {
        printf("Worldn");
    }

    return 0;
}

/*--------------------------------------------------------------------------------------------- 
 *   Author         : Emertxe (https://emertxe.com) 
 *   Date           : Wed 9 Mar 2016 16:00:04 IST
 *   File           : c_t045_ch1_logical_oper_or.c
 *   Title          : Operators - Logical - OR
 *   Description    : Symbols that instructs the compiler to perform specific arithmetic or 
 *                    logical operation on operands. All C operators do 2 things
 *                     - Operates on its operands
 *                     - Returns a value
 *                    Operators play a very crucial role in controlling the system behaviour in 
 *                    general. There are different types of Operators available in C Programming 
 *                    Language. This example demonstrates logical OR operator.
 *-------------------------------------------------------------------------------------------*/   
#include 
int main()
{
    int x = 0;
    /* 
     * Any one of the expression has to evaluate to true to enter the loop
     * If the first expression results in true the second won't be evaluted
     */
    if (x++ || x--)
    {
        printf("Yesn");
    }
    else
    {
        printf("Non");
    }
    printf("The value of x is %dn", x);
    return 0;
}

/*--------------------------------------------------------------------------------------------- 
 *   Author         : Emertxe (https://emertxe.com) 
 *   Date           : Wed 9 Mar 2016 16:00:04 IST
 *   File           : c_t046_ch1_logical_oper_and.c
 *   Title          : Operators - Logical - AND
 *   Description    : Symbols that instructs the compiler to perform specific arithmetic or 
 *                    logical operation on operands. All C operators do 2 things
 *                     - Operates on its operands
 *                     - Returns a value
 *                    Operators play a very crucial role in controlling the system behaviour in 
 *                    general. There are different types of Operators available in C Programming 
 *                    Language. This example demonstrates logical AND operator.
 *-------------------------------------------------------------------------------------------*/   
#include 
int main()
{
    int x = 0;
    /* 
     * All the expressions has to evaluate to true to enter the loop
     * If the first expression results is false the second would not processed
     */
    if (x++ && x++)
    {
        printf("Yesn");
    }
    else
    {
        printf("Non");
    }
    printf("The value of x is %dn", x);
    return 0;
}

/*--------------------------------------------------------------------------------------------- 
 *   Author         : Emertxe (https://emertxe.com) 
 *   Date           : Wed 9 Mar 2016 16:00:04 IST
 *   File           : c_t047_ch1_logical_oper_not.c
 *   Title          : Operators - Logical - NOT
 *   Description    : Symbols that instructs the compiler to perform specific arithmetic or 
 *                    logical operation on operands. All C operators do 2 things
 *                     - Operates on its operands
 *                     - Returns a value
 *                    Operators play a very crucial role in controlling the system behaviour in 
 *                    general. There are different types of Operators available in C Programming 
 *                    Language. This example demonstrates logical NOT operator.
 *-------------------------------------------------------------------------------------------*/   
#include 
int main()
{
    int x = 5;
    /*
     * In C any variable which is non zero is TRUE
     * The below evaluation becomes false leading to else part 
     * since NOT of any non zero value will be always FALSE
     */
    if (!x)
    {
        printf("Hellon");
    }
    else
    {
        printf("Worldn");
    }
    return 0;
}

/*--------------------------------------------------------------------------------------------- 
 *   Author         : Emertxe (https://emertxe.com) 
 *   Date           : Wed 9 Mar 2016 16:00:04 IST
 *   File           : c_t049_ch1_oper_precedence.c
 *   Title          : Operators - Precedence
 *   Description    : Symbols that instructs the compiler to perform specific arithmetic or 
 *                    logical operation on operands. All C operators do 2 things
 *                     - Operates on its operands
 *                     - Returns a value
 *                    Operators play a very crucial role in controlling the system behaviour in 
 *                    general. There are different types of Operators available in C Programming 
 *                    Language. This example demonstrates an operator precedence.
 *-------------------------------------------------------------------------------------------*/   
#include 
int main()
{
    int p = 10, q = 20, r;
    /*
     * An intresting expresion which assigns the result of the logical operation
     * result in p and r even though they are assigned with 5!!. why??
     * Again the precedence of < is greater than ||, is greater than =. Hence the grouping
     * would be like (p = q = (5 || (q < 20))
     */ 
    if (p = r = 5 || q < 20)
    {
        printf("p = %d, q = %d, r = %dn", p, q, r);
    }
    return 0;
}

/*--------------------------------------------------------------------------------------------- 
 *   Author         : Emertxe (https://emertxe.com) 
 *   Date           : Wed 9 Mar 2016 16:00:04 IST
 *   File           : c_t050_ch1_assignemnt_oper.c
 *   Title          : Operators - Assignment
 *   Description    : Symbols that instructs the compiler to perform specific arithmetic or 
 *                    logical operation on operands. All C operators do 2 things
 *                     - Operates on its operands
 *                     - Returns a value
 *                    Operators play a very crucial role in controlling the system behaviour in 
 *                    general. There are different types of Operators available in C Programming 
 *                    Language. This example demonstrates an assignment operator.
 *-------------------------------------------------------------------------------------------*/   
#include 
int main()
{
    int a = 1, c = 1, e = 1;
    float b = 1.5, d = 1.5, f = 1.5;
    /* 
     * The below expression starts from right to left
     * The type conversion fundametals to be kept in mind
     */ 
    a += b += c += d += e += f;
    printf("a = %d, b = %f, c = %d, d = %f, e = %d, f = %fn", a, b, c, d, e, f);
    return 0;
}

/*--------------------------------------------------------------------------------------------- 
 *   Author         : Emertxe (https://emertxe.com) 
 *   Date           : Wed 9 Mar 2016 16:00:04 IST
 *   File           : c_t051_ch1_relational_oper.c
 *   Title          : Operators - Relational - Less and Greater than
 *   Description    : Symbols that instructs the compiler to perform specific arithmetic or 
 *                    logical operation on operands. All C operators do 2 things
 *                     - Operates on its operands
 *                     - Returns a value
 *                    Operators play a very crucial role in controlling the system behaviour in 
 *                    general. There are different types of Operators available in C Programming 
 *                    Language. This example demonstrates greater and less than operator.
 *-------------------------------------------------------------------------------------------*/   
#include 
int main()
{
    int a = 10, b = 5, c = 20;
    if ((a > b) && (b < c))
    {
        puts("Yes");
    }
    else
    {
        puts("No");
    }
    return 0;
}

/*--------------------------------------------------------------------------------------------- 
 *   Author         : Emertxe (https://emertxe.com) 
 *   Date           : Wed 9 Mar 2016 16:00:04 IST
 *   File           : c_t052_ch1_relational_oper.c
 *   Title          : Operators - Relational - Equal to
 *   Description    : Symbols that instructs the compiler to perform specific arithmetic or 
 *                    logical operation on operands. All C operators do 2 things
 *                     - Operates on its operands
 *                     - Returns a value
 *                    Operators play a very crucial role in controlling the system behaviour in 
 *                    general. There are different types of Operators available in C Programming 
 *                    Language. This example demonstrates equal to operator.
 *-------------------------------------------------------------------------------------------*/   
#include 
int main()
{
    float val = 0.7;
    /* 
     * The result ends up if false, since the real constants are stored as double precision
     * but the variable val is float
     */
    if (val == 0.7)
    {
        puts("Equal");
    }
    else
    {
        puts("Not Equal");
    }
    return 0;
}

/*--------------------------------------------------------------------------------------------- 
 *   Author         : Emertxe (https://emertxe.com) 
 *   Date           : Wed 9 Mar 2016 16:00:04 IST
 *   File           : c_t054_ch1_bitwise_oper.c
 *   Title          : Operators - Bitwise
 *   Description    : Symbols that instructs the compiler to perform specific arithmetic or 
 *                    logical operation on operands. All C operators do 2 things
 *                     - Operates on its operands
 *                     - Returns a value
 *                    Operators play a very crucial role in controlling the system behaviour in 
 *                    general. There are different types of Operators available in C Programming 
 *                    Language. Bitwise operators most commonly used in embedded application
 *                    development. This example demonstrates bitwise all bitwise operators.
 *-------------------------------------------------------------------------------------------*/   
#include 
int main()
{
    /* An expression to clear a single bit at postion 0 */
    printf("%hhxn", 0xFF & 0xFE);
    /* An expression to set a single bit at postion 0 */
    printf("%hhxn", 0x00 | 0x01);
    /* An expression to toggle a single bit at postion 0 */
    printf("%hhxn", 0x01 ^ 0x01);
    /* An expression to left shift the value by one bit poistion */
    printf("%hhxn", 0xFF << 0x01); /* * An expression to right shift the value by one bit poistion * Note: The result would depend on the signed bit in case signed objects */ printf("%hhxn", 0xFF >> 0x01);
    /* An expression to 1's compliments the value */
    printf("%hhxn", ~0x00);
    printf("Please so see the next examples for simple appilcations of bitwise operatorn");
    return 0;
}

/*--------------------------------------------------------------------------------------------- 
 *   Author         : Emertxe (https://emertxe.com) 
 *   Date           : Wed 9 Mar 2016 16:00:04 IST
 *   File           : c_t055_ch1_bitwise_oper_bit_ops.c
 *   Title          : Operators - Bitwise
 *   Description    : Symbols that instructs the compiler to perform specific arithmetic or 
 *                    logical operation on operands. All C operators do 2 things
 *                     - Operates on its operands
 *                     - Returns a value
 *                    Operators play a very crucial role in controlling the system behaviour in 
 *                    general. There are different types of Operators available in C Programming 
 *                    Language. Bitwise operators most commonly used in embedded application
 *                    development. This example demonstrates usage of bitwise operators for 
 *                    clearing, setting, toggling and getting the bits from a object.
 *-------------------------------------------------------------------------------------------*/   

#include 

int main()
{
    int data;
    int bit_mask;
    int bit_position;

    /*
     * Clear a bit a given position
     */ 
    printf("Enter a bit postion to be operted on 0XFF [Poition ranges from 0 to 7]: ");
    scanf("%d", &bit_position);

    if ((bit_position < 1) && (bit_position > 7))
    {
        printf("Bit position not yet supportedn");

        return 1;
    }

    /* Creation of a mask to clear at bit_position */
    data = 0xFF;
    bit_mask = ~(1 << bit_position);
    /* Clear the required bit */
    data = data & bit_mask;

    printf("Data [0XFF] after clearing the bit %d is %#hhXn", bit_position, data);

    /*
     * Set a bit a given position
     */ 
    printf("Enter a bit postion to be set in 0X00 [Poition ranges from 0 to 7]: ");
    scanf("%d", &bit_position);

    /* Creation of a mask to clear at bit_position */
    data = 0x00;
    bit_mask =  1 << bit_position;
    /* Clear the required bit */
    data = data | bit_mask;

    printf("Data [0X00] after setting the bit %d is %#hhXn", bit_position, data);

    /*
     * Toggle a bit a given position
     */ 
    printf("Enter a bit postion to be toggled in 0XAA [Poition ranges from 0 to 7]: ");
    scanf("%d", &bit_position);

    /* Creation of a mask to clear at bit_position */
    data = 0xAA;
    bit_mask =  1 << bit_position;
    /* Clear the required bit */
    data = data ^ bit_mask;

    printf("Data [0XAA] after toggling the bit %d is %#hhXn", bit_position, data);

    /*
     * Get a bit a given position
     */ 
    printf("Enter a bit postion to get from 0XAA [Poition ranges from 0 to 7]: ");
    scanf("%d", &bit_position);

    /* Creation of a mask to get a at bit_position */
    data = 0xAA;
    bit_mask =  1 << bit_position;

    /* Get the required bit */
    printf("The bit at position %d from Data [0XAA] is %dn", bit_position, !!(data & bit_mask));

    return 0;
}

/*--------------------------------------------------------------------------------------------- 
 *   Author         : Emertxe (https://emertxe.com) 
 *   Date           : Wed 9 Mar 2016 16:00:04 IST
 *   File           : c_t056_ch1_bitwise_oper_bit_ops.c
 *   Title          : Operators - Bitwise
 *   Description    : Symbols that instructs the compiler to perform specific arithmetic or 
 *                    logical operation on operands. All C operators do 2 things
 *                     - Operates on its operands
 *                     - Returns a value
 *                    Operators play a very crucial role in controlling the system behaviour in 
 *                    general. There are different types of Operators available in C Programming 
 *                    Language. Bitwise operators most commonly used in embedded application
 *                    development. This example demonstrates usage of the shift operators to swap
 *                    nibbles of byte.
 *-------------------------------------------------------------------------------------------*/   

#include 

int main()
{
    signed char num = 0xAB;

    /* Swap higher nibble with lower nibble */
    num = ((num >> 4) & 0x0F) | ((num << 4) & 0xF0);

    /* Mask 8 bits */
    printf("num = %Xn", num & 0xFF);

    return 0;
}

/*--------------------------------------------------------------------------------------------- 
 *   Author         : Emertxe (https://emertxe.com) 
 *   Date           : Wed 9 Mar 2016 16:00:04 IST
 *   File           : c_t057_ch1_bitwise_oper_bit_ops.c
 *   Title          : Operators - Bitwise
 *   Description    : Symbols that instructs the compiler to perform specific arithmetic or 
 *                    logical operation on operands. All C operators do 2 things
 *                     - Operates on its operands
 *                     - Returns a value
 *                    Operators play a very crucial role in controlling the system behaviour in 
 *                    general. There are different types of Operators available in C Programming 
 *                    Language. Bitwise operators most commonly used in embedded application
 *                    development. This example demonstrates usage of the shift operators and its
 *                    behaviour while shifting signed and unsigned numbers.
 *-------------------------------------------------------------------------------------------*/   

#include 

int main()
{
    signed int x = -1;
    unsigned int y = -1;

    /* The sign bit is 1 and would propagate while shifting */
    x = x >> 4;
    printf("Right shift of signed x by 4 = %Xn", x);

    x = x << 4; printf("Left shift of signed x by 4 = %Xn", x); /* The no sign bit, so 0 would propagate while shifting */ y = y >> 4;
    printf("Right shift of unsigned y by 4 = %Xn", y);

    y = y << 4;
    printf("Left shift of unsigned y by 4 = %Xn", y);

    return 0;
}

/*--------------------------------------------------------------------------------------------- 
 *   Author         : Emertxe (https://emertxe.com) 
 *   Date           : Wed 9 Mar 2016 16:00:04 IST
 *   File           : c_t058_ch1_sizeof_oper.c
 *   Title          : Operators - sizeof
 *   Description    : Symbols that instructs the compiler to perform specific arithmetic or 
 *                    logical operation on operands. All C operators do 2 things
 *                     - Operates on its operands
 *                     - Returns a value
 *                    Operators play a very crucial role in controlling the system behaviour in 
 *                    general. There are different types of Operators available in C Programming 
 *                    Language. sizeof is a compile time operator. Very useful if you need to know
 *                    the size of memory allocated for a defined object. This example shows the 
 *                    size of the different data types. Note this is implementation specific and 
 *                    would vary from architecture to architecture.
 *-------------------------------------------------------------------------------------------*/   
#include 
int main()
{
    /* 
     * sizeof is a compile time operator.
     * The return value depends on the compiler implementation and could vary
     * in different target architectures.
     * The below code was run on 32 bit gcc fo x86 architectures
     */
    printf("sizeof(char)tt: %u Bytesn", sizeof(char));
    printf("sizeof(short)tt: %u Bytesn", sizeof(short));
    printf("sizeof(int)tt: %u Bytesn", sizeof(int));
    printf("sizeof(long)tt: %u Bytesn", sizeof(long));
    printf("sizeof(long long)t: %u Bytesn", sizeof(long long));
    printf("sizeof(float)tt: %u Bytesn", sizeof(float));
    printf("sizeof(double)tt: %d Bytesn", sizeof(double));
    printf("sizeof(long double)t: %u Bytesn", sizeof(long double));
    printf("sizeof(pointer)tt: %u Bytesn", sizeof(short *));
    printf("sizeof(void)tt: %u Bytesn", sizeof(void));
    return 0;
}

/*--------------------------------------------------------------------------------------------- 
 *   Author         : Emertxe (https://emertxe.com) 
 *   Date           : Wed 9 Mar 2016 16:00:04 IST
 *   File           : c_t059_ch1_sizeof_oper.c
 *   Title          : Operators - sizeof
 *   Description    : Symbols that instructs the compiler to perform specific arithmetic or 
 *                    logical operation on operands. All C operators do 2 things
 *                     - Operates on its operands
 *                     - Returns a value
 *                    Operators play a very crucial role in controlling the system behaviour in 
 *                    general. There are different types of Operators available in C Programming 
 *                    Language. sizeof is a compile time operator. Very useful if you need to know
 *                    the size of memory allocated for a defined object. This example shows the 
 *                    size of the different data types. Note this is implementation specific and 
 *                    would vary from architecture to architecture.
 *-------------------------------------------------------------------------------------------*/   

#include 

int main()
{
    int num = 1;

    /* 
     * sizeof is a compile time operator.
     * The return value depends on the compiler implementation and could vary
     * in different target architectures.
     * The below code was run on 32 bit gcc fo x86 architectures
     * The parentheses are must if you have to find the size of datatype
     * size of returns a unsigned value
     */
    printf("%zu %zu %zun", sizeof(int), sizeof num, sizeof 1);

    return 0;
}

/*--------------------------------------------------------------------------------------------- 
 *   Author         : Emertxe (https://emertxe.com) 
 *   Date           : Wed 9 Mar 2016 16:00:04 IST
 *   File           : c_t060_ch1_sizeof_oper.c
 *   Title          : Operators - sizeof
 *   Description    : Symbols that instructs the compiler to perform specific arithmetic or 
 *                    logical operation on operands. All C operators do 2 things
 *                     - Operates on its operands
 *                     - Returns a value
 *                    Operators play a very crucial role in controlling the system behaviour in 
 *                    general. There are different types of Operators available in C Programming 
 *                    Language. sizeof is a compile time operator. Very useful if you need to know
 *                    the size of memory allocated for a defined object. This example shows the 
 *                    size of the different data types. Note this is implementation specific and 
 *                    would vary from architecture to architecture.
 *-------------------------------------------------------------------------------------------*/   
#include 
int main()
{
    int i = 0;
    /* 
     * sizeof is a compile time operator.
     * So the any expression which is an argument of will only be evaluated only at
     * compilation time. The code for such expression would not generated by compiler.
     */
    int j = sizeof(++i);
    printf("%d: %dn", i, j);
    return 0;
}

/*--------------------------------------------------------------------------------------------- 
 *   Author         : Emertxe (https://emertxe.com) 
 *   Date           : Wed 9 Mar 2016 16:00:04 IST
 *   File           : c_t061_ch1_comma_oper.c
 *   Title          : Operators - Comma
 *   Description    : Symbols that instructs the compiler to perform specific arithmetic or 
 *                    logical operation on operands. All C operators do 2 things
 *                     - Operates on its operands
 *                     - Returns a value
 *                    Operators play a very crucial role in controlling the system behaviour in 
 *                    general. There are different types of Operators available in C Programming 
 *                    Language. Comma depending on the context acts a operator and separator. In 
 *                    case of list of declarator, list of initializers and list of arguments its 
 *                    acts seperator. In rest of the cases it acts an operator.
 *-------------------------------------------------------------------------------------------*/   
#include 
int main()
{
    int x;
    int y, z;
    /* The comma operator has the least precedence hence 5 would be assigned to x */
    x = 5, 10, 15;
    printf("%dn", x);
    /* 
     * The values are grouped with a parentheses, hence the parentheses would be evaluated first.
     * Now based on the associavity 15 would be assigned to x
     */ 
    x = (5, 10, 15);
    printf("%dn", x);
    /* 
     * The values are grouped with a parentheses, hence the parentheses would be evaluated first.
     * Now based on the associavity, y would be 100 and then z becomes 110 leading x to 110
     */ 
    x = (y = 100, z = y + 10);
    printf("x = %d, y = %d, z = %dn", x, y, z);
    return 0;
}

/*--------------------------------------------------------------------------------------------- 
 *   Author         : Emertxe (https://emertxe.com) 
 *   Date           : Wed 9 Mar 2016 16:00:04 IST
 *   File           : c_t062_ch1_comma_oper.c
 *   Title          : Operators - Comma
 *   Description    : Symbols that instructs the compiler to perform specific arithmetic or 
 *                    logical operation on operands. All C operators do 2 things
 *                     - Operates on its operands
 *                     - Returns a value
 *                    Operators play a very crucial role in controlling the system behaviour in 
 *                    general. There are different types of Operators available in C Programming 
 *                    Language. Comma depending on the context acts a operator and separator. In 
 *                    case of list of declarator, list of initializers and list of arguments its 
 *                    acts seperator. In rest of the cases it acts an operator.
 *-------------------------------------------------------------------------------------------*/   
#include 
int main()
{
    int i = 0, j = 0;
    j = i++ ? i++ : ++i;
    printf("i = %d, j = %dn", i, j);
    j = i++ ? i++, ++j : ++j, i++;
    printf("i = %d, j = %dn", i, j);
    return 0;
}

/*--------------------------------------------------------------------------------------------- 
 *   Author         : Emertxe (https://emertxe.com) 
 *   Date           : Wed 9 Mar 2016 16:00:04 IST
 *   File           : c_t063_ch1_ternary_oper_max.c
 *   Title          : Operators - Ternary
 *   Description    : Symbols that instructs the compiler to perform specific arithmetic or 
 *                    logical operation on operands. All C operators do 2 things
 *                     - Operates on its operands
 *                     - Returns a value
 *                    Operators play a very crucial role in controlling the system behaviour in 
 *                    general. There are different types of Operators available in C Programming 
 *                    Language. Ternary operator to test a condition (hence called as conditional
 *                    operator) and return expressions as true or false
 *-------------------------------------------------------------------------------------------*/   
#include 
int main()
{
    int a, b;
    int max;
    a = 100, b = 10;
    /* Test for a > b, on true it would return a else b */
    max = (a > b) ? a : b;
    printf("Max = %dn", max);
    a = 10, b = 100;
    (a > b) ? (max = a) : (max = b);
    printf("Max = %dn", max);
    a = 10, b = 10;
    (a > b) ? printf("Max = %dn", a): printf("Max = %dn", b);
    a = 1, b = 200;
    printf("Largest = %dn", (a > b) ? a : b);
    return 0;
}

/*--------------------------------------------------------------------------------------------- 
 *   Author         : Emertxe (https://emertxe.com) 
 *   Date           : Wed 9 Mar 2016 16:00:04 IST
 *   File           : c_t064_ch1_ternary_oper_abs_val.c
 *   Title          : Operators - Ternary
 *   Description    : Symbols that instructs the compiler to perform specific arithmetic or 
 *                    logical operation on operands. All C operators do 2 things
 *                     - Operates on its operands
 *                     - Returns a value
 *                    Operators play a very crucial role in controlling the system behaviour in 
 *                    general. There are different types of Operators available in C Programming 
 *                    Language. Ternary operator to test a condition (hence called as conditional
 *                    operator) and return expressions as true or false
 *-------------------------------------------------------------------------------------------*/   
#include 
int main()
{
    int x = -10;
    unsigned int abs_val;
    abs_val = (x > 0) ? x : -x;
    printf("Absolute val = %un", abs_val);
    return 0;
}

/*--------------------------------------------------------------------------------------------- 
 *   Author         : Emertxe (https://emertxe.com) 
 *   Date           : Wed 9 Mar 2016 16:00:04 IST
 *   File           : c_t065_ch_qualifier_const.c
 *   Title          : C basic datatypes - Const Qualifier
 *   Description    : A simple program exploring the basic C data types. C supports two basic 
 *                    datatypes hold integral and real objects as int and float (single 
 *                    precision). The char falls under the integral category. Any variable 
 *                    can be qualified for non mutability, hence cannot be changed.
 *-------------------------------------------------------------------------------------------*/   
#include 
int main()
{
    const int num1;
    /* Not allowed to change */
    num1 = 10;
    if (num1 == 10)
    {
        printf("Yesn");
    }
    /* Only way to assign a value to const variable */
    const int num2 = 10;
    /* Not allowed to change */
    if (num2++ == 10)
    {
        printf("Yesn");
    }
    return 0;
}

/*---------------------------------------------------------------------------------------------- 
 *   Author         : Emertxe (https://emertxe.com) 
 *   Date           : Wed 9 Mar 2016 16:00:04 IST
 *   File           : c_t067_ch1_array.c
 *   Title          : C User Defiened Datatype - Arrays - Reading from user
 *   Description    : An array is a collection of similar data type. Elements occupy consecutive 
 *                    memory locations (addresses). First element with lowest address and the 
 *                    last element with highest address. Elements are indexed from 0 to 
 *                    SIZE – 1. for example say we have an array of 5 elements(say array[5]) 
 *                    will be indexed from 0 to 4. Accessing out of range array elements would 
 *                    be “illegal access”, i.e for example do not access elements array[-1] and 
 *                    array[SIZE]. Array size can't be altered at run time.This example show how 
 *                    to get the input from the user and store in a defined array.
 *--------------------------------------------------------------------------------------------*/   
#include 
int main()
{
    int a[5];
    int i;
    printf("Enter 5 numbers: ");
    for (i = 0; i < 5; i++)
    {
        /* Read and store values entered by the user in array at index i */
        scanf("%d", &a[i]);
    }
    /* Print scaned array elements */
    for (i = 0; i < 5; i++)
    {
        printf("The element at index %d is %dn", i, a[i]);
    }
}

/*---------------------------------------------------------------------------------------------- 
 *   Author         : Emertxe (https://emertxe.com) 
 *   Date           : Wed 9 Mar 2016 16:00:04 IST
 *   File           : c_t068_ch1_array_boundary.c
 *   Title          : C User Defiened Datatype - Arrays - Out of bound
 *   Description    : An array is a collection of similar data type. Elements occupy consecutive 
 *                    memory locations (addresses). First element with lowest address and the 
 *                    last element with highest address. Elements are indexed from 0 to 
 *                    SIZE – 1. for example say we have an array of 5 elements(say array[5]) 
 *                    will be indexed from 0 to 4. Accessing out of range array elements would 
 *                    be “illegal access”, i.e for example do not access elements array[-1] and 
 *                    array[SIZE]. Array size can't be altered at run time.This example show 
 *                    illeagle access of the array elements (out of bound).
 *--------------------------------------------------------------------------------------------*/   
#include 
int main()
{
    /* 
     * Lets define 3 array variables x, y, z where each can store 2 elements
     * Assuming the memory allocated for each array is contigous
     */ 
    int x[2] = {1, 2};
    int y[2];
    int z[2] = {3, 4};
    int i;
    printf("Enter the elements for y[]n");
    for (i = 0; i < 3; i++)
    {
        scanf("%d", &y[i]);
        /* 
         * Note that the array y is defined to store only 2 elements, but the loop run
         * from 0 to 2 which is 3 elements!
         * So the adjacent of y is array z, so expecting z[0] gets changed to the last
         * user input
         */ 
    }
    /* Based on the above assumption we are now modifing the 1st element of the x i.e. x[1] */
    y[-1] = 10;
    printf("Values of x[] are:n");
    for (i = 0; i < 2; i++)
    {
        printf("%d ", x[i]);
    }
    printf("n");
    printf("Values of z[] are:n");
    for (i = 0; i < 2; i++)
    {
        printf("%d ", z[i]);
    }
    printf("n");
    printf("Please make sure to check the next examplen");
    return 0;
}

/*---------------------------------------------------------------------------------------------- 
 *   Author         : Emertxe (https://emertxe.com) 
 *   Date           : Wed 9 Mar 2016 16:00:04 IST
 *   File           : c_t069_ch1_array_boundary.c
 *   Title          : C User Defiened Datatype - Arrays - Out of bound
 *   Description    : An array is a collection of similar data type. Elements occupy consecutive 
 *                    memory locations (addresses). First element with lowest address and the 
 *                    last element with highest address. Elements are indexed from 0 to 
 *                    SIZE – 1. for example say we have an array of 5 elements(say array[5]) 
 *                    will be indexed from 0 to 4. Accessing out of range array elements would 
 *                    be “illegal access”, i.e for example do not access elements array[-1] and 
 *                    array[SIZE]. Array size can't be altered at run time.This example show 
 *                    illeagle access of the array elements (out of bound) which could lead to 
 *                    segmentation fault.
 *--------------------------------------------------------------------------------------------*/   
#include 
int main()
{
    int a[5], i;
    /* 
     * The array is defined for just 5 elements.
     * Moreover we are trying to access 50 elements from 5000 to 5050
     * which could certinly lead to a segmentation fault
     */ 
    for (i = 5000; i <= 5050; i++)
    {
        printf("%dn", a[i]);
    }
    return 0;
}

/*---------------------------------------------------------------------------------------------- 
 *   Author         : Emertxe (https://emertxe.com) 
 *   Date           : Wed 9 Mar 2016 16:00:04 IST
 *   File           : c_t070_ch1_array_element_address.c
 *   Title          : C User Defiened Datatype - Arrays - Element addresses
 *   Description    : An array is a collection of similar data type. Elements occupy consecutive 
 *                    memory locations (addresses). First element with lowest address and the 
 *                    last element with highest address. Elements are indexed from 0 to 
 *                    SIZE – 1. for example say we have an array of 5 elements(say array[5]) 
 *                    will be indexed from 0 to 4. Accessing out of range array elements would 
 *                    be “illegal access”, i.e for example do not access elements array[-1] and 
 *                    array[SIZE]. Array size can't be altered at run time.This example shows 
 *                    array initialization while definition and how address is allocated for 
 *                    each element of an array.
 *--------------------------------------------------------------------------------------------*/   
#include 
int main()
{
    /* On a 32 bit system size of int would be 4 bytes width */
    int arr1[3] = {1, 2, 3};
    /* On a 32 bit system size of short would be 2 bytes width */
    short arr2[3] = {1, 2, 3};
    /* On a 32 bit system size of char would be 1 bytes width */
    char arr3[3] = {'A', 'B', 'C'};
    int i;
    for (i = 0; i < 3; i++)
    {
        printf("Element %d at arr1[%d] is at %pn", i, i, &arr1[i]);
    }
    for (i = 0; i < 3; i++)
    {
        printf("Element %d at arr2[%d] is at %pn", i, i, &arr2[i]);
    }
    for (i = 0; i < 3; i++)
    {
        printf("Element %d at arr3[%d] is at %pn", i, i, &arr3[i]);
    }
    return 0;
}

/*---------------------------------------------------------------------------------------------- 
 *   Author         : Emertxe (https://emertxe.com) 
 *   Date           : Wed 9 Mar 2016 16:00:04 IST
 *   File           : c_t071_ch1_array_copy.c
 *   Title          : C User Defiened Datatype - Arrays - Copy
 *   Description    : An array is a collection of similar data type. Elements occupy consecutive 
 *                    memory locations (addresses). First element with lowest address and the 
 *                    last element with highest address. Elements are indexed from 0 to 
 *                    SIZE – 1. for example say we have an array of 5 elements(say array[5]) 
 *                    will be indexed from 0 to 4. Accessing out of range array elements would 
 *                    be “illegal access”, i.e for example do not access elements array[-1] and 
 *                    array[SIZE]. Array size can't be altered at run time.This example shows 
 *                    that the array cannot be copied by direct assignment.
 *--------------------------------------------------------------------------------------------*/   
#include 
int main()
{
    int a[5] = {1, 2, 3, 4, 5};
    int b[5];
    int i;
    /* 
     * Will a get copied to b!!?
     */
    b = a;
    /* 
     * No, not possible. The array name represents a base address of an array which is
     * a constant, so since we cannot modify a constant object the copiler will issue an
     * error.
     */ 
    /* Print array b */
    for (i = 0; i < 5; i++)
    {
        printf("%d ", b[i]);
    }
}

/*---------------------------------------------------------------------------------------------- 
 *   Author         : Emertxe (https://emertxe.com) 
 *   Date           : Wed 9 Mar 2016 16:00:04 IST
 *   File           : c_t072_ch1_array_copy.c
 *   Title          : C User Defiened Datatype - Arrays - Copy
 *   Description    : An array is a collection of similar data type. Elements occupy consecutive 
 *                    memory locations (addresses). First element with lowest address and the 
 *                    last element with highest address. Elements are indexed from 0 to 
 *                    SIZE – 1. for example say we have an array of 5 elements(say array[5]) 
 *                    will be indexed from 0 to 4. Accessing out of range array elements would 
 *                    be “illegal access”, i.e for example do not access elements array[-1] and 
 *                    array[SIZE]. Array size can't be altered at run time.This example shows how 
 *                    to copy an array.
 *--------------------------------------------------------------------------------------------*/   
#include 
int main()
{
    int a[5] = {1, 2, 3, 4, 5};
    int b[5];
    int i;
    /* Copy a to b, element by element */
    for (i = 0; i < 5; i++)
    {
        b[i] = a[i];
    }
    /* Print array b */
    for (i = 0; i < 5; i++)
    {
        printf("%d ", b[i]);
    }
    printf("n");
    return 0;
}

/*---------------------------------------------------------------------------------------------- 
 *   Author         : Emertxe (https://emertxe.com) 
 *   Date           : Wed 9 Mar 2016 16:00:04 IST
 *   File           : c_t073_ch1_array_copy.c
 *   Title          : C User Defiened Datatype - Arrays - Initialization
 *   Description    : An array is a collection of similar data type. Elements occupy consecutive 
 *                    memory locations (addresses). First element with lowest address and the 
 *                    last element with highest address. Elements are indexed from 0 to 
 *                    SIZE – 1. for example say we have an array of 5 elements(say array[5]) 
 *                    will be indexed from 0 to 4. Accessing out of range array elements would 
 *                    be “illegal access”, i.e for example do not access elements array[-1] and 
 *                    array[SIZE]. Array size can't be altered at run time.This example shows 
 *                    how to copy an array.
 *--------------------------------------------------------------------------------------------*/   
#include 
int main()
{
    /* Perfectly fine */
    int a[5] = {1, 2, 3, 4, 5};
    /* Perfectly fine, elements 2, 3 and 4 will be uninitilized */
    int b[5] = {6, 7};
    /* Perfectly fine, all elements will be uninitilized */
    int c[5];
    /* No, atleast gcc doesn't allow this, will lead to compiler error*/
    int d[];
    int size = 5;
    /* No not allowed, a variable size array cannot be initialized */
    int e[size] = {1, 2, 3, 4, 5};
    return 0;
}