CSE 109

Computer Programming
Bitwise operators and Structure
Dr. Tanveer Awal
Department of CSE, BUET
 Bitwise Operators
• Performs operation on a bit-by-bit level.
Operator Type Name

& Binary Bitwise AND

| Binary Bitwise OR
^ Binary Bitwise XOR
~ Unary 1’s Complement
<< Binary Left Shift Operator
>> Binary Right Shift Operator

• Works with character type and integer types only.

 Bitwise Operators
• Bitwise AND
unsigned int i, j;
i=11
j=1
• Determine i & j
00000000 00000000 00000000 00001011
00000000 00000000 00000000 00000001
------------------------------------------------------------------------
00000000 00000000 00000000 00000001

• So, i & j results in 1

bitwise_intro.c
 Bitwise Operators
• Bitwise OR
unsigned int i, j;
i=11
j=1
• Determine i | j
00000000 00000000 00000000 00001011
00000000 00000000 00000000 00000001
------------------------------------------------------------------------
00000000 00000000 00000000 00001011

• So, i | j results in 11
bitwise_intro.c
 Bitwise Operators
• Bitwise XOR
unsigned int i, j;
i=11
j=1
• Determine i ^ j
00000000 00000000 00000000 00001011
00000000 00000000 00000000 00000001
------------------------------------------------------------------------
00000000 00000000 00000000 00001010

• So, i ^ j results in 10
bitwise_intro.c
 Bitwise Operators
• Bitwise NOT
unsigned int i, j;
i=11
• Determine ~i
00000000 00000000 00000000 00001011
------------------------------------------------------------------------
11111111 11111111 11111111 11110100

bitwise_intro.c
Shift Operators

bitwise_shift_operator1 &2.c
 Bitwise Operators
• The left shift and right shift operators should not be used for negative numbers.
• The bitwise operators should not be used in place of logical operators.
• The left-shift and right-shift operators are equivalent to multiplication and
division by 2 respectively.
• The & operator can be used to quickly check if a number is odd or even.
• The ~ operator should be used carefully.

bitwise_intro.c
 Structure
• Aggregate data type
• Composed of two or more related variables
– Called member
– Each member can be of different types
 Structure (General Form)
struct tag-name {
type member1;
type member2;
type member3;
.
.
.
type memberN;
} variable-list;

– The keyword struct means that a structure type is defined

– tag-name is the name of the type
– Either tag-name or variable-list is optional
 Structure Example
struct point {
int x;
int y;
} p1, p2;

struct {
int x;
int y;
} p1, p2;
 Structure Example
struct point {
int x;
int y;
};
struct point p1, p2;
• Keyword struct before variable declaration is necessary
• Each instance of a structure contains its own copy of the members
• Structure declaration without any variable name does not reserve any storage
– Describes template or shape of a structure
 Structure Declaration
• Structure can be declared
– Locally (inside a function)
– Globally (outside of any function)

• Structure declaration and structure variable declaration are different.

– Variables can be declared during structure declaration or later

• It is possible to declare structure globally and declare the variables of the

structure locally

• See structure_declaration.c for detailed declaration.

 Structure Initialization
p1.x=10;
p1.y=5;

struct point p3={5, 2};

 Structure Size
• The size of a structure element is greater than or equal to the summation of
sizes of its fields (members).
• Why may it be greater?
– For the ease of memory access! Memory is not accessed bytewise rather accessed
4 bytes per operation or 8 bytes per operation. So, it is common to find the size
of the structure as the multiple of 4 or 8.
– Memory access is higher topic, not for now. Just remember the reason behind
larger structure size.
 Structure Assignment
• Possible when type of the both objects are same
p2=p3;
 Accessing Structure Member
• Use dot operator to access the member of a structure
StructureVariable.member
For example, if p3 is a structure variable,
printf("%d, %d\n", p3.x, p3.y);
• For scanf or other cases where address of a member is required, use &
operator before structure variable name not before member name.
&StructureVariable.member
For example, if p3 is a structure variable,
scanf("%d %d\n", &p3.x, &p3.y);
• See “structure_class_example.c” and “structure_class_example1.c”
 Structure Array
• A structure array can be declared like the process of a normal variable
declaration.
• Index must be used to access an element of the array
• To access the member of that element, use dot operator after the index

Also see “structure_class_example2.c”

 Structure Array
• The member of a structure and a normal variable in a function can have the
same name.

Member x and int x are different

 Nested Structure
• A structure can be used inside another structure and so on.
• If structure A is used inside structure B, then structure A must be declared
before structure B.
• If structure A is used inside structure B, then B is the outer structure and A
is inner structure.
• During accessing the elements of nested structure object, use the outermost
structure variable first, then a dot, then the inner one, and so on.
Nested Structure
 Structure in Function
• A structure object can be passed into a function and a structure object can be
returned from a function.
Structure in Function

See structure_in_function.c
 Pointer to Structure
• Pointer of a structure can be declared in the same way pointers to other
variables are declared.
• When accessing a member using a structure, use the dot operator. When
accessing a member using a pointer, use the arrow operator.
• See “structure_pointer.c” and “structure_pointer1.c” for the use of pointer
to structure
• See structure_pointer2.c to see the use of pointer for the case of nested
structure
 typedef (user defined data types)
• typedef type new-type
• type: an existing data type
• Example:
– typedef int age
• age is a user defined data type, equivalent to int
– typedef double height;
height maleHeight, femaleHeight;
 typedef with Structure
typedef struct
{
member1;
member2;
} new-type;

• typedef struct {
int month;
int day;
int year;
} date;
typedef with Structure

See structure_typedef.c
 Bit-field
• A variation on structure member.
• Composed of 1 or more bits.
• type name: size;
• type can be int or unsigned int
• struct b_type
{ unsigned dept:3;
unsigned instock:1;
unsigned backOrdered:1;
unsigned lead_time:3;
}inv[MAX_ITEM];

}
 Bit-field
• Address of a bit-field variable cannot be obtained. Smallest addressable unit
of memory is a byte.
• Use:
– Pack information into smallest possible space. Hence they allow efficient use of
memory.
• Whether bitfields are stored high order to low order or the other way
around is implementation dependent.
 Union
• A single piece of memory shared by 2 or more different variables.
• Only 1 variable may be in use at any time.
• Defined much like structure.
union tag-name {
type member1;
type member2;
type member3;
.
.
.
type memberN;
} variable-list;
 Union
union u_type {
int i; Size of union is fixed at compile time and is
char c[4]; large enough to accommodate the largest
member of the union.
double d;
} sample;

i d

c[0] c[1] c[2] c[3]

How an instance of u_type appears in memory
(assuming 4 byte int and 8 byte double
Thank You 