C Programming Part 8: Bit Fields and Pointers

C_Programming
Part 8
ENG. KEROLES SHENOUDA
1

Access Wrong Bit on the Register
one of the most famous issue for
the embedded programmer
2
Functionality
issue

Bit-Fields
THINK FIRST THEN ANSWER
HOW TO USE STRUCTURE ON ACCESS
SPECIFIC BIT ON THE REGISTERS ?
3

Bit-Fields
 Unlike some other computer languages, C has a built-in
feature, called a bit-field, that allows you to
access a single bit. Bit-fields can be useful for a number of
reasons, such as:
 If storage is limited, you can store several Boolean (true/false)
variables in one byte.
 Certain devices transmit status information encoded into one or more
bits within a byte
 Certain encryption routines need to access the bits within a byte.
4

Bit-Fields
 A bit-field must be a member of a structure or union. It defines how
long, in bits, the field is to be.
The general form of a bit-field definition is
type name: length;
 type is the type of the bit-field, and length is the number of bits in
the field. The type of a bitfield must be int, signed, or unsigned.
(C99 also allows a bit-field to be of type _Bool.)
 Bit-fields are frequently used when analyzing input from a hardware
device.
5

Bit-Fields
For example, the status port of a serial communications adapter might
return a status byte organized like this:
Bit Meaning When Set
0 Change in clear-to-send line
1 Change in data-set-ready
2 Trailing edge detected
3 Change in receive line
4 Clear-to-send
5 Data-set-ready
6 Telephone ringing
7 Received signal
6
struct status_type {
unsigned char delta_cts:1;
unsigned char delta_dsr:1;
unsigned char tr_edge:1;
unsigned char delta_rec:1;
unsigned char cts:1;
unsigned char dsr:1;
unsigned char ring:1;
unsigned char rec_line:1;
} status;

Bit-Fields
 You might use statements like the ones
shown here to enable a program to
determine when it can
send or receive data:
7
status = get_port_status();
if(status.cts) printf("clear to send");
if(status.dsr) printf("data ready");
Bit Meaning When Set
0 Change in clear-to-send line
1 Change in data-set-ready
2 Trailing edge detected
3 Change in receive line
4 Clear-to-send
5 Data-set-ready
6 Telephone ringing
7 Received signal
} status;

Bit-Fields 10
} status;
status
7 6 5 4 3 2 1 0
delta_cts
delta_dsr
tr_edge
delta_rec
cts
dsr
rec_line

Bit-Fields
 You do not have to name
each bit-field.
This makes it easy to reach the
bit you want, bypassing unused
ones.
 For example, if you only care
about the cts and dsr bits, you
could declare the
status_type structure like this:
 Also, notice that the bits after
dsr do not need to be specified if
they are not used.
11
status
7 6 5 4 3 2 1 0
cts
dsr

Bit-Fields
 It is valid to mix normal structure members with bit-fields. For
example
12
What is the Output ?

Bit-Fields
 It is valid to mix normal structure members with bit-fields. For
example
13
What is the Output ?

Bit-Fields
Bit-fields have certain restrictions
 you cannot take the address of a bit-field.
Bit-fields cannot be arrayed.
 You cannot know, from machine to machine, whether
the fields will run from right to left or from left to right;
have some machine dependencies
14

What Are Pointers?
 A pointer is a variable that holds a memory
address.
 This address is the location of another object
(typically another variable) in memory.
For example, if one variable contains the address of another
variable, the first variable is said to point to
the second.
16

Why do we need Pointer?
 Simply because it’s there!
 It is used in some circumstances in C
Remember this?
scanf(“%d”, &i);

Pointers
Pointer Variables
 If a variable is going to be a
pointer, it must be declared
as such. A pointer
declaration consists of a
base type, an *, and the
variable name. The general
form for declaring a pointer
variable is
type *name;
18

Pointer Arithmetic
 There are only two arithmetic operations
that you can use on pointers:
addition and subtraction.
25

26
rule govern pointer arithmetic.

All pointer arithmetic is relative to its base type
(assume 2-byte integers)
27

LAB Average of Weights
 It is required to calculate the summation weight of 5
boxes. The user should enter the boxes
30

Pointers and Arrays
 There is a close relationship between pointers and arrays.
 Consider this program fragment:
char str[80], *p1;
p1 = str;
Here, p1 has been set to the address of the first array element in str.
 To access the fifth element in str, you could write
str[4]
or
*(p1+4)
33

Pointers AND Functions
 Pointers are used efficiently with functions. Using pointers
provides two main features:
Fast data transfer, because only pointers are transferred.
Pointers allow the definition of several outputs for the same
function.
36

Fast Data
Transfer
Using
Pointers
37

Fast Data
Transfer
Using
Pointers
38

Passing
Arrays and
Pointers to
Functions
Normal
Array
Passing
39

Passing
Arrays and
Pointers to
Functions
Array
Passing with
Pointers
40

Method 2 is completely equivelent to
Method 1 which means that:
41

Finally we can summarize function
parameters types
 1. Input Parameters (Calling by Value)
The parameter values is completely transmitted to the function. This
gives the
function the ability to read the transmitted data only.
2. Input/Output Parameters (Refrence or Pointer)
The parameter pointer (refernce) is transmitted only. This gives the
function the
ability to read from and write to the original parameters.
3. Output Parameters (Return Value)
The return data of the function is assumed as an output parameter. Normally C
does
not provide other Output parameters except the return value.
42

The sort function contains the two types
of parameters.
43

Pointer with Unknown Type (void*)
 Programmer can define general
pointer without specifying a linked
data type.
 This type of pointers called (void
pointer).
 void pointer can not be used
normally to manipulated data, it
is required to type cast each
data access operation.
44

Example: Universal Compare with void Pointers
45

Example: Universal Compare with void Pointers
46

The function prototype is:
 int Compare(void* value1, void* value2, int type)
which means it takes any two pointers with uncknown
type, the third parameter informs the
type of the submitted values (1 means integer, 2
means double).
47

Pointer Conversions
void * pointers
 In C, it is permissible to assign a void * pointer to any other type of pointer. It
is also permissible to assign any other type of pointer to a void * pointer. A
void * pointer is called a generic pointer.
 The void * pointer is used to specify a pointer whose base type is unknown.
 The void * type allows a function to specify a parameter that is capable of
receiving any type of pointer argument without reporting a type mismatch.
 It is also used to refer to raw memory (such as that returned by the
malloc( ) function described later in this chapter)
48

Multiple Indirection
Pointer to Pointer
 You can have a pointer point to another pointer
that points to the target value.
 This situation is called
multiple indirection, or pointers to pointers
49

NULL and Unassigned Pointers
 If the pointer is unassigned it will contain an invalid address, it is unsafe
to use an unassigned pointer, normally the program will crash. Fllowing
program will crash because
the (pX) pointer is not pointed to a valid address, it contain a memory
gurbage
52

NULL and Unassigned Pointers
 To avoid using unassigned pointers, all pointers must hold a valid address,
if not it must hold
a zero value. Sometimes zero value called (NULL). Above program may be
fixed as shown
bellow:
53

An Illustration
int i = 5, j = 10;
int *ptr;
int **pptr;
ptr = &i;
pptr = &ptr;
*ptr = 3;
**pptr = 7;
ptr = &j;
**pptr = 9;
*pptr = &i;
*ptr = -2;
Data Table
Name Type Description Value
i int integer variable 5
j int integer variable 10

An Illustration
int i = 5, j = 10;
int *ptr; /* declare a pointer-to-integer variable */
int **pptr;
ptr = &i;
pptr = &ptr;
*ptr = 3;
**pptr = 7;
ptr = &j;
**pptr = 9;
*pptr = &i;
*ptr = -2;
Data Table
ptr int * integer pointer variable

An Illustration
int i = 5, j = 10;
int *ptr;
int **pptr; /* declare a pointer-to-pointer-to-integer variable */
ptr = &i;
pptr = &ptr;
*ptr = 3;
**pptr = 7;
ptr = &j;
**pptr = 9;
*pptr = &i;
*ptr = -2;
Data Table
ptr int * integer pointer variable
pptr int ** integer pointer pointer variable
Double
Indirection

An Illustration
int i = 5, j = 10;
int *ptr;
int **pptr;
ptr = &i; /* store address-of i to ptr */
pptr = &ptr;
*ptr = 3;
**pptr = 7;
ptr = &j;
**pptr = 9;
*pptr = &i;
*ptr = -2;
Data Table
ptr int * integer pointer variable address of i
pptr int ** integer pointer pointer variable
*ptr int de-reference of ptr 5

An Illustration
int i = 5, j = 10;
int *ptr;
int **pptr;
ptr = &i;
pptr = &ptr; /* store address-of ptr to pptr */
*ptr = 3;
**pptr = 7;
ptr = &j;
**pptr = 9;
*pptr = &i;
*ptr = -2;
Data Table
pptr int ** integer pointer pointer variable address of ptr
*pptr int * de-reference of pptr value of ptr
(address of i)

An Illustration
int i = 5, j = 10;
int *ptr;
int **pptr;
ptr = &i;
pptr = &ptr;
*ptr = 3;
**pptr = 7;
ptr = &j;
**pptr = 9;
*pptr = &i;
*ptr = -2;
Data Table

An Illustration
int i = 5, j = 10;
int *ptr;
int **pptr;
ptr = &i;
pptr = &ptr;
*ptr = 3;
**pptr = 7;
ptr = &j;
**pptr = 9;
*pptr = &i;
*ptr = -2;
Data Table
**pptr int de-reference of de-reference of
pptr
7

An Illustration
int i = 5, j = 10;
int *ptr;
int **pptr;
ptr = &i;
pptr = &ptr;
*ptr = 3;
**pptr = 7;
ptr = &j;
**pptr = 9;
*pptr = &i;
*ptr = -2;
Data Table
ptr int * integer pointer variable address of j

An Illustration
int i = 5, j = 10;
int *ptr;
int **pptr;
ptr = &i;
pptr = &ptr;
*ptr = 3;
**pptr = 7;
ptr = &j;
**pptr = 9;
*pptr = &i;
*ptr = -2;
Data Table
ptr int * integer pointer variable address of j
**pptr int de-reference of de-reference of
pptr
9

An Illustration
int i = 5, j = 10;
int *ptr;
int **pptr;
ptr = &i;
pptr = &ptr;
*ptr = 3;
**pptr = 7;
ptr = &j;
**pptr = 9;
*pptr = &i;
*ptr = -2;
Data Table
*pptr int * de-reference of pptr value of ptr
(address of i)

An Illustration
int i = 5, j = 10;
int *ptr;
int **pptr;
ptr = &i;
pptr = &ptr;
*ptr = 3;
**pptr = 7;
ptr = &j;
**pptr = 9;
*pptr = &i;
*ptr = -2;
Data Table
i int integer variable -2
*ptr int de-reference of ptr -2

Pointer Arithmetic
 What’s ptr + 1?
 The next memory location!
 What’s ptr - 1?
 The previous memory location!
 What’s ptr * 2 and ptr / 2?
 Invalid operations!!!

Pointer Arithmetic and Array
float a[4];
float *ptr;
ptr = &(a[2]);
*ptr = 3.14;
ptr++;
*ptr = 9.0;
ptr = ptr - 3;
*ptr = 6.0;
ptr += 2;
*ptr = 7.0;
Data Table
a[0] float float array element (variable) ?
ptr float * float pointer variable
*ptr float de-reference of float pointer
variable
?

float a[4];
float *ptr;
ptr = &(a[2]);
*ptr = 3.14;
ptr++;
*ptr = 9.0;
ptr = ptr - 3;
*ptr = 6.0;
ptr += 2;
*ptr = 7.0;
Data Table
ptr float * float pointer variable address of a[2]
variable
?

float a[4];
float *ptr;
ptr = &(a[2]);
*ptr = 3.14;
ptr++;
*ptr = 9.0;
ptr = ptr - 3;
*ptr = 6.0;
ptr += 2;
*ptr = 7.0;
Data Table
a[2] float float array element (variable) 3.14
variable
3.14

float a[4];
float *ptr;
ptr = &(a[2]);
*ptr = 3.14;
ptr++;
*ptr = 9.0;
ptr = ptr - 3;
*ptr = 6.0;
ptr += 2;
*ptr = 7.0;
Data Table
variable
?

float a[4];
float *ptr;
ptr = &(a[2]);
*ptr = 3.14;
ptr++;
*ptr = 9.0;
ptr = ptr - 3;
*ptr = 6.0;
ptr += 2;
*ptr = 7.0;
Data Table
variable
9.0

float a[4];
float *ptr;
ptr = &(a[2]);
*ptr = 3.14;
ptr++;
*ptr = 9.0;
ptr = ptr - 3;
*ptr = 6.0;
ptr += 2;
*ptr = 7.0;
Data Table
variable
?

float a[4];
float *ptr;
ptr = &(a[2]);
*ptr = 3.14;
ptr++;
*ptr = 9.0;
ptr = ptr - 3;
*ptr = 6.0;
ptr += 2;
*ptr = 7.0;
Data Table
variable
6.0

float a[4];
float *ptr;
ptr = &(a[2]);
*ptr = 3.14;
ptr++;
*ptr = 9.0;
ptr = ptr - 3;
*ptr = 6.0;
ptr += 2;
*ptr = 7.0;
Data Table
variable
3.14

float a[4];
float *ptr;
ptr = &(a[2]);
*ptr = 3.14;
ptr++;
*ptr = 9.0;
ptr = ptr - 3;
*ptr = 6.0;
ptr += 2;
*ptr = 7.0;
Data Table
variable
7.0

Pointer to Function
 powerful feature of C is the function pointer.
 A function has a physical location in memory that can be assigned to a pointer.
 This address is the entry point of the function
and it is the address used when the function is called.
 Once a pointer points to a function, the
function can be called through that pointer.
 Function pointers also allow functions to be passed as arguments to other
functions
76

Pointers Tricks
80
How to Read C complex pointer
double to integer
Modularity
Pointer with Constant

expression
Operator Precedence Associative
(),[] 1 Left to Right
*,Identifier 2 Right to Left
Data Type 3 –
81
Before We Learn How to Read Complex Array we should
first know precedence and associative .
•Priority : Operator precedence describes the order in
which C reads expressions
•order : Order operators of equal precedence in an
expression are applied
Before Reading Article You Should know Precedence
and Associative Table

expression
82

expression
 char (* ptr)[5]
Step 1 :
•Observe Above Precedence Table
•[] and () have Same Priority
•Using Associativity , Highest Priority Element is decided
•Associativity is from Left to Right First Priority is Given to “()”
83

expression
84
Step 2 :
•Between Pair of Brackets again we have to decide which one has highest priority ? ‘*’ or ‘ptr’ ?
•* and Identifier ptr have Same Priority
•Associativity is from Right to Left First Priority is Given to “ptr”

expression
85
Read it as –
ptr is pointer to a one dimensional array having
size five which can store data of type char

How to Read C complex pointer expression
examples
86

examples
87

examples
88

examples
89

examples
 Test Your self
90

Pointers Tricks
91
Pointers on Embedded C
Modularity

Pointers Tricks
95
Modularity

For example “UART” (send data)
 Send_data(u16 data)
 {
 USART_Init ();
 USART_Trans_Int_Enable();
 USART_Trans_Enable();
 USART_Transmit(u16 data);
 }
97
USART_Init (){…}
USART_Trans_Int_Enable (){…}USART_Trans_Enable (){…}
USART_Transmit(u16 data);
{…}
UART

 {
 USART_Init ();
 }
98
USART_Init (){…}
{…}
UARTSend dataByte Byte
Once the UART
sent the Data,
The TX interrupt
will insert and
the CPU will call
ISR(USART_TXC_vect)
{ …….. }

 {
 USART_Init ();
 }
99
USART_Init (){…}
{…}
Once the UART
sent the Data,
The TX interrupt
will insert and
the CPU will call
ISR(USART_TXC_vect)
{ …….. }

100
void (*Ptr_To_Trans_Int) (void);
extern void USART_callback_Trans_Int(void (*Ptr_to_Func)(void))
{
Ptr_To_Trans_Int = Ptr_to_Func;
}
USART_Init (){…}
ISR(USART_TXC_vect)
{ …….. }
ISR(USART_TXC_vect)
{
(*Ptr_To_Trans_Int)();
}

Pointers Tricks
101
Modularity

Variable Quantifiers - const
 const is used with a datatype declaration or definition to specify an
unchanging value
 const objects may not be changed
102

Variable Quantifiers - const
 const is used with a datatype declaration or definition to specify an
unchanging value
 const objects may not be changed
103

Complete the table yes/no … 106

107
int* ptr = &a;
int* const ptr = &a;
int const *ptr = &a;
const int *ptr = &a;

Try Now

References 111
 C The Complete Reference 4th Ed Herbert Schildt
 A Tutorial on Data Representation
 std::printf, std::fprintf, std::sprintf, std::snprintf…..
 C Programming for Engineers, Dr. Mohamed Sobh
 C programming expert.
 fresh2refresh.com/c-programming
 C programming Interview questions and answers
 C – Preprocessor directives
 Constant Pointers and Pointers to Constant A Subtle Difference in C
Programming

C Programming Part 8: Bit Fields and Pointers

Empfohlen

Empfohlen

Weitere ähnliche Inhalte

Was ist angesagt?

Was ist angesagt? (20)

Andere mochten auch

Andere mochten auch (14)

Ähnlich wie C Programming Part 8: Bit Fields and Pointers

Ähnlich wie C Programming Part 8: Bit Fields and Pointers (20)

Mehr von Keroles karam khalil

Mehr von Keroles karam khalil (16)

Kürzlich hochgeladen

Kürzlich hochgeladen (20)

C Programming Part 8: Bit Fields and Pointers