Develop Embedded Software Module-Session 3

Training Of Trainers (TOT) program on
Embedded Software Engineer Job role
www.emtech.in 24x7 Helpline +91 92120 88881 info@emtech.in 1
Session 3
Developing Software
Module

Agenda
Session 1
History of C
Fundamentals of C
Data Types
Variables, Constants and Arrays
Keywords
Decision Control (if-else)
Session 2
Loops
Functions (Overview)
Arrays
Session 3
Pointers & String

Strings

Definition
 
Character Arrays and Strings
Strings:
Are enclosed in double quotes "string"
Are terminated by a null character '0'
Must be manipulated as arrays of characters (treated
element by element)
May be initialized with a string literal
Strings are arrays of char whose last element is a null
character '0' with an ASCII value of 0. C has no native
string data type, so strings must always be treated as
character arrays.

Syntax
Example
 
Creating a String Character Array
char str1[10]; //Holds 9 characters plus '0'
char str2[6]; //Holds 5 characters plus '0'
char arrayName[length];
Strings are created like any other array of char:
length must be one larger than the length of the string to
accommodate the terminating null character '0'
A char array with n elements holds strings with n-1 char

Example
Syntax
 
How to Initialize a String at Declaration
char str1[] = "Microchip"; //10 chars "Microchip0"
char str2[6] = "Hello"; //6 chars "Hello0"
//Alternative string declaration – size required
char str3[4] = {'P', 'I', 'C', '0'};
char arrayName[] = "Microchip";
Character arrays may be initialized with string literals:
Array size is not required
Size automatically determined by length of string
NULL character '0' is automatically appended

Syntax
Example
How to Initialize a String in Code
str[0] = 'H';
str[1] = 'e';
str[2] = 'l';
str[3] = 'l';
str[4] = 'o';
str[5] = '0';
arrayName[0] = char1;
arrayName[1] = char2;
arrayName[n] = '0';
In code, strings must be initialized element by element:
Null character '0' must be appended manually

Example
 
Comparing Strings
Strings cannot be compared using relational operators
(==, !=, etc.)
Must use standard C library string manipulation
functions
strcmp() returns 0 if strings equal
char str[] = "Hello";
if (!strcmp( str, "Hello"))
printf("The string is "%s".n", str);

Data Pointers

 
A Variable's Address versus A Variable's Value
In some situations, we will want to work with a variable's
address in memory, rather than the value it contains…
005A
Address
16-bit Data Memory
(RAM)
0x0802
0x0804
0x0806
0x0808
0x0800
x
Variable stored
at Address
0123
DEAD
BEEF
F00D
0456 0x080A
Variable name
from C code
int x;
Value of
variable x
= 0x0123
Address of
variable x
= 0x0802

What are pointers?
A pointer is a variable or constant that holds the
address of another variable or function
FFFF
Address
16-bit Data Memory
(RAM)
0x0802
0x0804
0x0806
0x0808
0x0800
x
p
Variable at
Address
0123
FFFF
0802
FFFF
FFFF 0x080A
Integer Variable:
Pointer Variable:

 
What do they do?
A pointer allows us to indirectly access a variable
(just like indirect addressing in assembly language)
005A
Address
16-bit Data Memory
(RAM)
0x0802
0x0804
0x0806
0x0808
0x0800
x 0123
DEAD
0802
F00D
0456 0x080A
p
x = 0x0123;
*p = 0x0123;
Direct Access
via x
Indirect Access
via *p
p points to x

Example
Syntax
 
How to Create a Pointer Variable
int *iPtr; // Create a pointer to int
float *fPtr; // Create a pointer to float
type *ptrName;
In the context of a declaration, the * merely indicates that the
variable is a pointer
type is the type of data the pointer may point to
Pointer usually described as “a pointer to type”

To set a pointer to point to another variable, we use the
& operator (address of), and the pointer variable is
used without the dereference operator *:
This assigns the address of the variable x to the
pointer p (p now points to x)
Note: p must be declared to point to the type of x (e.g.
int x; int *p;)
 
Initialization
p = &x;

 
Usage
When accessing the variable pointed to by a pointer,
we use the pointer with the dereference operator *:
This assigns to the variable y, the value of what p is
pointing to (x from the last slide)
Using *p, is the same as using the variable it points to
(e.g. x)
y = *p;

Example
 
Another Way To Look At The Syntax
&x is a constant pointer
It represents the address of x
The address of x will never change
p is a variable pointer to int
It can be assigned the address of any int
It may be assigned a new address any time
int x, *p; //int and a pointer to int
p = &x; //Assign p the address of x
*p = 5; //Same as x = 5;

Example
 
Another Way To Look At The Syntax
*p represents the data pointed to by p
*p may be used anywhere you would use x
* is the dereference operator, also called the
indirection operator
In the pointer declaration, the only significance of * is
to indicate that the variable is a pointer rather than an
ordinary variable
int x, *p; //1 int, 1 pointer to int
p = &x; //Assign p the address of x
*p = 5; //Same as x = 5;

Example
 
How Pointers Work
Address
16-bit Data Memory
(RAM)
0x08BC
0x08BE
0x08C0
0x08C2
0x08C4
0x08C6
0x08BA
{
int x, y;
int *p;
x = 0xDEAD;
y = 0xBEEF;
p = &x;
*p = 0x0100;
p = &y;
*p = 0x0200;
}
x
y
p
Variable at
Address
0x08C8
0000
0000
0000
0000
0000
0000
0000
0000

Example
 
How Pointers Work
Address
16-bit Data Memory
(RAM)
0x08BC
0x08BE
0x08C0
0x08C2
0x08C4
0x08C6
0x08BA
x
y
p
Variable at
Address
0x08C8
0000
DEAD
0000
0000
0000
0000
0000
0000
{
int x, y;
int *p;
x = 0xDEAD;
y = 0xBEEF;
p = &x;
*p = 0x0100;
p = &y;
*p = 0x0200;
}

Example
 
How Pointers Work
Address
16-bit Data Memory
(RAM)
0x08BC
0x08BE
0x08C0
0x08C2
0x08C4
0x08C6
0x08BA
x
y
p
Variable at
Address
0x08C8
0000
DEAD
BEEF
0000
0000
0000
0000
0000
{
int x, y;
int *p;
x = 0xDEAD;
y = 0xBEEF;
p = &x;
*p = 0x0100;
p = &y;
*p = 0x0200;
}

Example
 
How Pointers Work
Address
16-bit Data Memory
(RAM)
0x08BC
0x08BE
0x08C0
0x08C2
0x08C4
0x08C6
0x08BA
x
y
p
Variable at
Address
0x08C8
0000
DEAD
BEEF
08BC
0000
0000
0000
0000
{
int x, y;
int *p;
x = 0xDEAD;
y = 0xBEEF;
p = &x;
*p = 0x0100;
p = &y;
*p = 0x0200;
}

Example
 
How Pointers Work
Address
16-bit Data Memory
(RAM)
0x08BC
0x08BE
0x08C0
0x08C2
0x08C4
0x08C6
0x08BA
x
y
p
Variable at
Address
0x08C8
0000
0100
BEEF
08BC
0000
0000
0000
0000
{
int x, y;
int *p;
x = 0xDEAD;
y = 0xBEEF;
p = &x;
*p = 0x0100;
p = &y;
*p = 0x0200;
}

Example
 
How Pointers Work
Address
16-bit Data Memory
(RAM)
0x08BC
0x08BE
0x08C0
0x08C2
0x08C4
0x08C6
0x08BA
x
y
p
Variable at
Address
0x08C8
0000
0100
BEEF
08BE
0000
0000
0000
0000
{
int x, y;
int *p;
x = 0xDEAD;
y = 0xBEEF;
p = &x;
*p = 0x0100;
p = &y;
*p = 0x0200;
}

Example
 
How Pointers Work
Address
16-bit Data Memory
(RAM)
0x08BC
0x08BE
0x08C0
0x08C2
0x08C4
0x08C6
0x08BA
x
y
p
Variable at
Address
0x08C8
0000
0100
0200
08BE
0000
0000
0000
0000
{
int x, y;
int *p;
x = 0xDEAD;
y = 0xBEEF;
p = &x;
*p = 0x0100;
p = &y;
*p = 0x0200;
}

 
Post-Increment/Decrement Syntax Rule
Care must be taken with respect to operator precedence
when doing pointer arithmetic:
Syntax Operation Description by Example
Post-Increment
data pointed to
by Pointer
(*p)++
Post-Increment
Pointer
*p++
*(p++)
z = (*p)++;
is equivalent to:
z = *p;
*p = *p + 1;
z = *(p++);
is equivalent to:
z = *p;
p = p + 1;

Example
 
Post-Increment / Decrement Syntax
Address
16-bit Data Memory
(RAM)
0x0800
0x0802
0x0804
0x0806
0x0808
0x080A
0x07FE
x[0]
x[1]
x[2]
0x080C
0000
0001
0002
0003
0800
0000
0000
0000
p
y
{
int x[3] = {1,2,3};
int y;
int *p = &x;
y = 5 + *(p++);
y = 5 + (*p)++;
}
Remember:
*(p++) is the same as *p++

Example
 
Address
16-bit Data Memory
(RAM)
0x0800
0x0802
0x0804
0x0806
0x0808
0x080A
0x07FE
x[0]
x[1]
x[2]
0x080C
0000
0001
0002
0003
0800
0006
0000
0000
p
y
{
int x[3] = {1,2,3};
int y;
int *p = &x;
y = 5 + *(p++);
y = 5 + (*p)++;
}
Remember:

Example
 
Address
16-bit Data Memory
(RAM)
0x0800
0x0802
0x0804
0x0806
0x0808
0x080A
0x07FE
x[0]
x[1]
x[2]
0x080C
0000
0001
0002
0003
0802
0006
0000
0000
p
y
{
int x[3] = {1,2,3};
int y;
int *p = &x;
y = 5 + *(p++);
y = 5 + (*p)++;
}
Remember:

Example
 
Address
16-bit Data Memory
(RAM)
0x0800
0x0802
0x0804
0x0806
0x0808
0x080A
0x07FE
x[0]
x[1]
x[2]
0x080C
0000
0001
0002
0003
0802
0007
0000
0000
p
y
{
int x[3] = {1,2,3};
int y;
int *p = &x;
y = 5 + *(p++);
y = 5 + (*p)++;
}
Remember:

Example
 
Address
16-bit Data Memory
(RAM)
0x0800
0x0802
0x0804
0x0806
0x0808
0x080A
0x07FE
x[0]
x[1]
x[2]
0x080C
0000
0001
0003
0003
0802
0007
0000
0000
p
y
{
int x[3] = {1,2,3};
int y;
int *p = &x;
y = 5 + *(p++);
y = 5 + (*p)++;
}
Remember:

 
Pre-Increment/Decrement Syntax Rule
Care must be taken with respect to operator
precedence when doing pointer arithmetic:
Syntax Operation Description by Example
Pre-Increment
data pointed to
by Pointer
++(*p)
Pre-Increment
Pointer
++*p
*(++p)
z = ++(*p);
is equivalent to:
*p = *p + 1;
z = *p;
z = *(++p);
is equivalent to:
p = p + 1;
z = *p;

Example
 
Pre-Increment / Decrement Syntax
Address
16-bit Data Memory
(RAM)
0x0800
0x0802
0x0804
0x0806
0x0808
0x080A
0x07FE
x[0]
x[1]
x[2]
0x080C
0000
0001
0002
0003
0800
0000
0000
0000
p
y
{
int x[3] = {1,2,3};
int y;
int *p = &x;
y = 5 + *(++p);
y = 5 + ++(*p);
}
Remember:
*(++p) is the same as *++p

Example
 
Address
16-bit Data Memory
(RAM)
0x0800
0x0802
0x0804
0x0806
0x0808
0x080A
0x07FE
x[0]
x[1]
x[2]
0x080C
0000
0001
0002
0003
0802
0000
0000
0000
p
y
{
int x[3] = {1,2,3};
int y;
int *p = &x;
y = 5 + *(++p);
y = 5 + ++(*p);
}
Remember:

Example
 
Address
16-bit Data Memory
(RAM)
0x0800
0x0802
0x0804
0x0806
0x0808
0x080A
0x07FE
x[0]
x[1]
x[2]
0x080C
0000
0001
0002
0003
0802
0007
0000
0000
p
y
{
int x[3] = {1,2,3};
int y;
int *p = &x;
y = 5 + *(++p);
y = 5 + ++(*p);
}
Remember:

Example
 
Address
16-bit Data Memory
(RAM)
0x0800
0x0802
0x0804
0x0806
0x0808
0x080A
0x07FE
x[0]
x[1]
x[2]
0x080C
0000
0001
0003
0003
0802
0007
0000
0000
p
y
{
int x[3] = {1,2,3};
int y;
int *p = &x;
y = 5 + *(++p);
y = 5 + ++(*p);
}
Remember:

Example
 
Address
16-bit Data Memory
(RAM)
0x0800
0x0802
0x0804
0x0806
0x0808
0x080A
0x07FE
x[0]
x[1]
x[2]
0x080C
0000
0001
0003
0003
0802
0008
0000
0000
p
y
{
int x[3] = {1,2,3};
int y;
int *p = &x;
y = 5 + *(++p);
y = 5 + ++(*p);
}
Remember:

The parentheses determine what gets incremented/
decremented:
 
Pre- and Post- Increment/Decrement Summary
Modify the pointer itself
*(++p) or *++p and *(p++) or *p++
Modify the value pointed to by the pointer
++(*p) and (*p)++

Example
 
Initialization Tip
If a pointer isn't initialized to a specific address when it
is created, it is a good idea to initialize it as NUL
(pointing to nowhere)
This will prevent it from unintentionally corrupting a
memory location if it is accidentally used before it is
initialized
int *p = NUL;
NULL is the character '0' but NUL is the value of a
pointer that points to nowhere

Conclusion
Pointers are variables that hold the address of other
variables.
Pointers make it possible for the program to change
which variable is acted on by a particular line of code .
Incrementing and decrementing pointers will modify
the value in multiples of the size of the type they point
to.

Thank you!

Develop Embedded Software Module-Session 3

More Related Content

What's hot (20)

Viewers also liked (6)

Similar to Develop Embedded Software Module-Session 3 (20)

Recently uploaded (20)

Develop Embedded Software Module-Session 3