SELF-PACED LEARNING

MODULE
College
 INFORMATION SHEET FN-3.1.1
“C Unions, Bit Fields and Typedef”
C Unions
A union is a special data type available in C that enables you to store different data types in the
same memory location. You can define a union with many members, but only one member can contain
a value at any given time. Unions provide an efficient way of using the same memory location for multi-
purpose.

Defining a Union
To define a union, you must use the union statement in very similar was as you did while
defining structure. The union statement defines a new data type, with more than one member for your
program. The format of the union statement is as follows:

The union tag is optional and each member definition is a normal variable definition, such as int
i; or float f; or any other valid variable definition. At the end of the union's definition, before the final
semicolon, you can specify one or more union variables but it is optional. Here is the way you would
define a union type named Data which has the three members i, f, and str:

Now, a variable of Data type can store an integer, a floating-point number, or a string of
characters. This means that a single variable i.e. same memory location can be used to store multiple
types of data. You can use any built-in or user defined data types inside a union based on your
requirement.
The memory occupied by a union will be large enough to hold the largest member of the union.
For example, in above example Data type will occupy 20 bytes of memory space because this is the
maximum space which can be occupied by character string. Following is the example which will display
total memory size occupied by the above union:
#include <stdio.h>
#include <string.h>
union Data
{
int i;
float f;
char str[20];
};
int main( )
 {
union Data data;
printf( "Memory size occupied by data : %d\n", sizeof(data));
return 0;
}

When the above code is compiled and executed, it produces the following result:
Memory size occupied by data : 20

Accessing Union Members

To access any member of a union, we use the member access operator (.). The member access
operator is coded as a period between the union variable name and the union member that we wish to
access. You would use union keyword to define variables of union type. Following is the example to
explain usage of union:
#include <stdio.h>
#include <string.h>
union Data
{
int i;
float f;
char str[20];
};
int main( )
{
union Data data;
data.i = 10;
data.f = 220.5;
strcpy( data.str, "C Programming");
printf( "data.i : %d\n", data.i);
printf( "data.f : %f\n", data.f);
printf( "data.str : %s\n", data.str);
return 0;
}
When the above code is compiled and executed, it produces the following result:
data.i : 1917853763
data.f : 4122360580327794860452759994368.000000
data.str : C Programming

Here, we can see that values of i and f members of union got corrupted because final value assigned to
the variable has occupied the memory location and this is the reason that the value if str member is
getting printed very well. Now let's look into the same example once again where we will use one
variable at a time which is the main purpose of having union:
#include <stdio.h>
#include <string.h>
union Data
{
 int i;
float f;
char str[20];
};
int main( )
{
union Data data;
data.i = 10;
printf( "data.i : %d\n", data.i);

data.f = 220.5;
printf( "data.f : %f\n", data.f);

strcpy( data.str, "C Programming");

printf( "data.str : %s\n", data.str);
return 0;
}

When the above code is compiled and executed, it produces the following result:
data.i : 10
data.f : 220.500000
data.str : C Programming
Here, all the members are getting printed very well because one member is being used at a time.

“Bit Fields”
Suppose your C program contains a number of TRUE/FALSE variables grouped in a structure called
status, as follows:

This structure requires 8 bytes of memory space but in actual we are going to store either 0 or 1
in each of the variables. The C programming language offers a better way to utilize the memory space in
such situation. If you are using such variables inside a structure then you can define the width of a
variable which tells the C compiler that you are going to use only those number of bytes. For example,
above structure can be re-written as follows:

Now, the above structure will require 4 bytes of memory space for status variable but only 2 bits
will be used to store the values. If you will use up to 32 variables each one with a width of 1 bit , then
also status structure will use 4 bytes, but as soon as you will have 33 variables, then it will allocate next
slot of the memory and it will start using 64 bytes. Let us check the following example to understand the
concept:
#include <stdio.h>
#include <string.h>
/* define simple structure */
struct
{
unsigned int widthValidated;
unsigned int heightValidated;
} status1;
/* define a structure with bit fields */
struct
{
unsigned int widthValidated : 1;
unsigned int heightValidated : 1;
} status2;
int main( )
{
printf( "Memory size occupied by status1 : %d\n", sizeof(status1));
printf( "Memory size occupied by status2 : %d\n", sizeof(status2));
return 0;
}

When the above code is compiled and executed, it produces the following result:
Memory size occupied by status1 : 8
Memory size occupied by status2 : 4

Bit Field Declaration

The declaration of a bit-field has the form inside a structure:
Below the description of variable elements of a bit field:

The variables defined with a predefined width are called bit fields. A bit field can hold more than a single
bit for example if you need a variable to store a value from 0 to 7 only then you can define a bit field
with a width of 3 bits as follows:
struct
{
unsigned int age : 3;
} Age;
The above structure definition instructs C compiler that age variable is going to use only 3 bits to store
the value, if you will try to use more than 3 bits then it will not allow you to do so. Let us try the
following example:
When the above code is compiled it will compile with warning and when executed, it produces the
following result:

Typedef
The C programming language provides a keyword called typedef, which you can use to give a type a new
name. Following is an example to define a term BYTE for one-byte numbers:
typedef unsigned char BYTE;
After this type definitions, the identifier BYTE can be used as an abbreviation for the type unsigned char,
for example:
BYTE b1, b2;
By convention, uppercase letters are used for these definitions to remind the user that the type name is
really a symbolic abbreviation, but you can use lowercase, as follows:
typedef unsigned char byte;
You can use typedef to give a name to user defined data type as well. For example, you can use typedef
with structure to define a new data type and then use that data type to define structure variables
directly as follows:
#include <stdio.h>
#include <string.h>
typedef struct Books
{
char title[50];
char author[50];
char subject[100];
int book_id;
} Book;
int main( )
{
Book book;
strcpy( book.title, "C Programming");
strcpy( book.author, "Nuha Ali");
strcpy( book.subject, "C Programming Tutorial");
book.book_id = 6495407;
printf( "Book title : %s\n", book.title);
printf( "Book author : %s\n", book.author);
printf( "Book subject : %s\n", book.subject);
printf( "Book book_id : %d\n", book.book_id);
return 0;
}

When the above code is compiled and executed, it produces the following result:
 Book title : C Programming
Book author : Nuha Ali
Book subject : C Programming Tutorial
Book book_id : 6495407

typedef vs #define
The #define is a C-directive which is also used to define the aliases for various data types similar to
typedef but with three differences:
 The typedef is limited to giving symbolic names to types only where as #define can be used to
define alias for values as well, like you can define 1 as ONE etc.
 The typedef interpretation is performed by the compiler where as #define statements are
processed by the pre-processor.

Following is a simplest usage of #define:

#include <stdio.h>
#define TRUE 1
#define FALSE 0
int main( )
{
printf( "Value of TRUE : %d\n", TRUE);
printf( "Value of FALSE : %d\n", FALSE);
return 0;
}
When the above code is compiled and executed, it produces the following result:
Value of TRUE : 1
Value of FALSE : 0

Reference: Workbook in C Programming Computer Programming 1 by Paulino H. Gatpandan, Azenith M. Rollan

https://www.unf.edu/~wkloster/2220/ppts/cprogramming..pdf
 SELF CHECK FN-3.1.1

A. What is the output of the following code?

 SELF CHECK ANSWER KEY FN-3.1.1

A.
STUDENT NAME: __________________________________ SECTION: __________________

PERFORMANCE TASK FN-3.1.1

PERFORMANCE TASK TITLE: C Program (Payroll)

PERFORMANCE OBJECTIVE: The learners independently demonstrate core competencies about C

programs
MATERIALS:
Computer / Android phone
Applications / Software:
Computer: TurboC2
Android phone: Coding C
Procedure:
Create a program of following problem.
(screenshot the output and code)
A. Write a program of simple Payroll System.(Salary=Rate*Hrs, Total Salary = Salary - Deduction )
Example Output:
Enter Name: Juan DelaCruz
Enter EmployeeNo.: 0009-22111
No. of Hours Work: 96
Salary Rate: 50
Salary: 4800
Deduction:
SSS: 100
Pag-ibig: 100
PhilHealth:100
Total Salary: 4500
Mr. Juan DelaCruz, with 96 hours of work and 50 pesos salary rate, your total salary is 4500

PRECAUTIONS:
 Undertake final inspections to ensure the program conform to requirements
ASSESSMENT METHOD: PERFORMANCE TASK CRITERIA CHECKLIST
STUDENT NAME: __________________________________ SECTION: __________________

PERFORMANCE TASK CRITERIA CHECK LIST FN-3.1-1

SCORING
CRITERIA
1 2 3 4 5
1. Quality of Work – the ability to follow procedures with precision and the
art, skill and finality of work
2. Speed – efficiency of work
3. Proper use of statement – the ability to apply proper statement for a
given task
TEACHER’S REMARKS:  QUIZ  RECITATION  PROJECT
GRADE:

5 - Excellently Performed
4 - Very Satisfactorily Performed
3 - Satisfactorily Performed
2 - Fairly Performed
1 - Poorly Performed

_________________________________
TEACHER

Date: ______________________