Bit Fields in C

Bit fields can be used in a structure or union. They are used where memory is very scarce. They can be used when the highest value that will be represented by a variable is very small.For instance, leat a variable int a is used to store 4 states say, (0, 1, 2, 3). The number of bits required to represent the highest value '3' is 2. If an integer is used to save these states, 32 bits are allocates in which 30 bits are unused. If 'n' such variables are used, the number of bits wasted will be 30*n. By using bit fields represented as int a:2; Though complete 32 bits are allocated for the int type, a represents only the first two LSBs. Any further bitfields declared as in below example will be packed within this remaining 30 bits until the total size reaches above 32 bits (4 bytes).

#include <stdio.h>
{
int a:5;
int b:10;
int c: 12;
int d;
} n1;

int main()
{
n1.d = 0x12345678;
printf("a 0x%x b 0x%x c 0x%x d 0x%x\n", n1.a, n1.b, n1.c, n1.d);
}

Output:

a 0xffff fff8 b 0xffff fe78 c 0x678 d 0x12345678

Double pointer usage and dynamic memory allocation using box diagram

Consider the below example,

#include <stdio.h>
#include <stdlib.h>

int main(void)
{
    int **p;     /* A pointer to a pointer to an integer */
    int a;

    p = malloc(sizeof(int *));

    *p = malloc(sizeof(int)); /* OR *p = &a; */

    **p = 10;

    printf("a = %d  **p = %d\n", a, **p);
} 

Output:

a = 10 **p = 10

In the above example, 'p' is a double pointer which means, 'p' will point to another pointer which in-turn is pointing to an integer variable.

Now, we have 'p' which is a pointer to a pointer. 'p' has its memory allocated at some address location say, '1000'. Lets say 'p' is ponting to another pointer 'x' which is at the address '1004'. Then 'x' in-turn will be pointing to variable 'a' located at say, 1008.

Box Diagram representation of pointers

'p' points to 'x'.

'x' points to 'a'

p->x->a or (p->*p->**p)

if say, pointer 'x' is not declared, then the second link in the above representation will break.

p->( )->a or (p->( )->**p)

It means, there is no memory representing link-2 which will have the address of 'a'. Hence, by using dynamic memory allocation, we can first allocate a memory by declaring a pointer variable 'x' and make the link.

Or, dynamically allocate a memory of type (int *) and make 'p' to directly point to that memory and put the address of 'a' in that allocated memory. The above program represents the second case.

In other words,

if you have a double pointer say,

int **p;

It means, at the declaration, memory is allocated for the variable 'p' which can point to another integer pointer which in turn will point to an integer variable. i.e., if it is a double pointer, then there needs three memory locations, one for 'p' of type 'int **' (pointer to a integer pointer) which is allocated during declaration, another for '*p' of type 'int *' (pointer to an integer) and the third memory for integer to which it points to (say, an integer value '10'). So, two memory allocations are needed.

p = malloc(sizeof(int *));

*p = malloc(sizeof(int));

The first statement will allocate the second memory for *p (type: int *) and its address is stored in p (type: int **).

The second statement will allocate the third memory required to store an integer '10' (type: int) and its address is stored in *p (type: int *).

The third memory can also be  a integer variable (say, count) in which case, the second statement above can be modified as

*p = &count;

Similarly,

For triple pointer, ***p, there shall be 4 memory locations, 3 for pointers and one for the variable it is pointing to and so on..

But, why do we need a double or a tripple pointer?

Pointer usage in C

C provides pointers which are used to store the address location of another variable of a particular data type.

Declaring a pointer to an integer variable,

int *p;

where, 'p' is a integer pointer that can point to (store the address of) a variable of type 'int'.

i.e., an integer pointer should be used to store the address of an integer variable only.

Similarly, a character pointer shall point to a character variable only. Failing to follow this, may result in an undefined behaviour.

Now, lets consider an example:

#include <stdio.h>

int main(void)
{
    int a = 10; /* An integer variable */
    int *p; /* A pointer to an integer */

    p = &a;

    printf("a = %d  *p = %d\n", a, *p);
} 

Output:

a = 10 *p = 10

In the above program, integer 'a' will be allocated a memory in stack say '0x1000' and the value '10' is stored in that memory location. Integer pointer 'p' will be allocated a memory in stack say '1004'.

Now, '&a' represents the address allocated to store the value in 'a' i.e., &a = 1000.

Now, this value 1000 is copied to 'p'. Now, the variable 'p' contains 1000.

Then, in the print statement, '*p' means de-referencing 'p'.

i.e., contentof(p) or contentof(1000) = 10. Hence, the output 10.

With this understanding, lets look at how to use double pointers and dynamically allocate a memory in the next example.

C Code | Tic Tac Toe game

Given below the code for tic tac toe game with variable grid size. Know about the game at Wikipedia or play online at http://playtictactoe.org/ or get the android app at google play.

C Code | Hangman game

In Hangman game, you need to find random words before the hangman image is completed. For every wrong answer, image will grow by one step. Code for hangman is given below. To know more details about the game, read at Wikipedia and play at hangman.no

C Code | Master mind or Bulls and Cows game

Giving the code below, for details about the game, read at Wikipedia or play at archimedes-lab.

In the below code, a 4 digit number with unique digits is generated by swapping an array having 10 elements (0 to 9) for N_SWAP number of times. The player is given 8 chances to identify the 4 digit number. For every input, the game will show number of bulls and cows.Digits at the right place are counted as bulls and the digits at the wrong place are counted as cows.

Hint: If bulls + cows = 4, it means the number you entered have the right digits but positionally misplaced.

Example: Let the secret number be 1234. Guessed number be 1203. Now bulls = 2, cows = 1.

C Code | Arithmetic quiz game

Below this is the code for arithmetic quiz game. For understanding the game, play at thatquiz.org

C Code | Guess a number game

Below is the C code to build "Guess the number" game. For details on how does guess the number game works, visit GuessMyNumberGame or Wiki page.