Summary of C Programming

Module 1
C Programming Summary
Dr. Hau Yuan Wen (Jasmine)

School of Biomedical Engineering and Health Sciences
www.utm.my innovative ● entrepreneurial ● global 1

Software Development Process for
Embedded System

Embedded Programming
Small, Efficient, Reliable, Reusable Code

Brief Review of
Embedded C Programming

main()
 Every C language program MUST have AT LEAST ONE
function, namely main().
 Starting point when the program code is executed.
 Considered as the lowest-level task.
void main() void main()
{ { //< statements>
// < statements> while (1)
} {
// < statements>
Every embedded microcontroller application has
}
an infinite loop built into it somewhere, such as
}
the while(1), to prevent the program from
running out of things to do and doing random
things that may be undesirable.

C Basic syntax
; To indicate the end of an expression.
{}  To delineate the beginning and the end of the function’s
contents.
 To indicate when a series of statements is to be treated as a
single block
“text” To mark the beginning and the end of a text string.
// Single-line comments
/* */ Multi-line comments
# Preprocessor instruction
#include<..>: To include the content of other system header files
#include “..“: To include the content of other user header files
#define: To define constant and macro

C Identifier
 Identifier: A variable or function name made up of a letter
or underscore (_), followed by a sequence of letters
and/or digits and/or underscores.
 Case sensitive
 Can be any length, but some compilers may recognize
only a limited number of characters.
 Must not be the reserved words.
 “White space (e.g. black space, tab, new line)” is ignored
unless delineated by quotes.

C Reserved Word
 Must be lowercase
 Should never be used as identifiers.
auto defined float long static while
break do for register struct
bit double funcused return switch
case eeprom goto short typedef
char else if signed union
const enum inline sizeof unsigned
continue extern int sfrb void
default flash interrupt sfrw volatile

Variables and Constants

Variables and Constants
 Variables: Values that can be changed (RAM) Used to
Constant: Fixed Values (ROM) store data
 Stored in the limited memory of the C, and the compiler
needs to know how much memory to set aside for each
variable without wasting memory space unnecessarily.
 Variable declaration:
Reserve word indicating its type and size, followed by an
identifier
unsigned char ascii;
int clock_cycle;
double execution_time;

10
Variables and Constant Types
Type Size (Bits) Size (Bytes) Range
bit 1 - 0, 1
char 8 1 -128 to 127
unsigned char 8 1 0 to 255
signed char 8 1 -128 to 127
int 16 2 -32768 to 32767
short int 16 2 -32768 to 32767
unsigned int 16 2 0 to 65535
signed int 16 2 -32768 to 32767
long int 32 4 -2147483648 to 2147483647
unsigned long int 32 4 0 to 4294967295
signed long int 32 4 -2147483648 to 2147483647
float 32 4 1.175e-38 to 3.402e38
double 64
www.utm.my
8 9.46e -308 to 1.79e308
innovative ● entrepreneurial ● global 11
11
Variables Scope
 Accessibility of a variable within a program.
LOCAL Variable Global / External Variable
Memory spaces allocated by the Memory space that is allocated
function by the compiler
Not accessible from other Accessible by all the functions in
functions a program
Scope is limited to the functions in Unlimited scope
which they are declared
Local variable with same identifier Can be modified by any function
name can be used in multiple and will retain its value to be
functions without conflict used by other functions.
If a local variable has the same name as a global variable and is used within a
function, the local variable will be used by the function. The value of global
variable will remain untouched.
12
Constants
 Constant: Fixed Values and never be changed
 Stored in the program code space (ROM) rather than in the
limited variable data storage space (RAM) to save limited
data memory space.
 Can be in the form of number, character or a string of text.
e.g. Z = 2032 * y;
x = ‘A’;
code = “SMBE2032”;
const char c = 20;

13
Numeric Representation
Representation Prefix Example
Decimal - 1234
Binary 0b 0b10101111
Hexadecimal 0x 0xFF
Octal 0 0765
Representation Suffix Example

Unsigned integer U 10000U
Long integer L 99L
Unsigned long integer UL 99UL
Floating point F 3.214F
Printable Character ‘‘ ‘a’, ‘A’, ‘\141’, ‘\x61’
14
Numeric Representation
Nonprintable Character Representation Equivalent Hex Value
BEL ‘\a’ ‘\x07’
Backspace ‘\b’ ‘\x08’
Horizontal Tab (TAB) ‘\t’ ‘\x09’
New line Feed, New line (LF) ‘\n’ ‘\x0a’
Vertical Tab (VT) ‘\v’ ‘\x0b’
NP Form Feed, New Page (FF) ‘\f’ ‘\x0c’
Carriage Return (CR) ‘\r’ ‘\x0d’
Backslash ‘\\’ ?
Single quote ‘\’’ ?

15
Ascii Code Table

16
Enumerations & Definitions
 To allow the programmer replace numbers with names or
other more meaningful phrase.
 Enumeration, enum:
• To assign sequential integer constant values to a list of identifier.
• To replace pure numbers.
 Definition, #define:
• To define constants or any macro substitution.
• Allow substitution of one text string for another
• Pre-processor directive: Happens before the actual compilation
begins.
17
Enumerations & Definitions
 Example:
#include<stdio.h>
#define PORTB "DIGITAL PORT"
#define leds 8
void main()
{
enum { red_led_on = 1, green_led_on, both_leds_on };
printf("green_led_on = %d\n", green_led_on);

printf("Number of LEDS = %d\n", leds);
printf("PORT B is %s\n", PORTB);
}

18
Storage Classes: auto, static and register
Automatic (auto) Static (static) Register (register)
Default class Same as auto
Uninitialized when it is Allocated in global Use an actual machine
declared and allocated in memory space. register in the
memory space (RAM) microprocessor as the
variable
Memory space is Initialized to zero for Intent of speeding up
released when the the first time the a particular process
function is exited, function is entered, by reducing the
meaning the values will and it retains its value number of machines
be lost and if the when the function is cycles required to
function is re-entered exited. access the variable.
auto int value_1; static int value_2; register char value_3;
int value_1;
19
Type casting
 Temporary force the type and size of the variable.
 Allow the previously declared type to be overridden for the
duration of the operation being performed.
 Important when the arithmetic operations are performed
with variable of different sizes.
int x=12; // a signed integer, 16-bit integer (-32768 to +32767)
char y; // a signed, 8-bit character (-128 to +127)
y = (char)x + 3; // x is converted to a character and then 3 is added,

// and the value is then placed into y.
x = (int)y; // y is extended up to an integer, and assigned to x.

20
Operators

21
Assignment and Operators
 Assignment operator (=)
 A value assigned to a variable can be a constant, a variable
or an expression.
 Parenthesis (): Improve code readability and determine
priority
Arithmetic Operators C Symbol Relational Operators C Symbol
Multiply * Is Equal to ==
Divide / Is Not Equal to !=
Modulo % Less Than <
Addition + Less Than or Equal to <=
Subtraction or Negation - Greater Than >
www.utm.my
Greater Than or Equal to >=
22
Assignment and Operators
Bitwise Operators C Symbol Logic Operators C Symbol
One’s Complement ~ AND &&
Left Shift << OR ||
Right Shift >> NOT !
AND &
 TRUE – Represented by a
Exclusive OR ^
nonzero value
OR (Inclusive OR) |
 FALSE – by a zero value
 Bitwise AND and OR are
useful in dealing with
parallel ports - masking and
bitwise port control
23
Increment, Decrement and Compound
Compound Equivalent
Assignment Assignment
Increment/Decrement C Symbol Operator Example
Operators (Example) a += 3 a=a+3
Post-Increment X++ a -= 5 a=a–5
Pre-Increment ++X a *= 2 a=a*2
Post-Decrement Y-- a /= 4 a=a/4
Pre-Decrement --Y a%=9 a=a%9
a |= 7 a = a OR 7
 Post-Operation: An operation
is executed after the a &= 6 a = a AND 6
expression has been resolved.
a ^= 8 a = a XOR 8
 Pre-Operation: An operation is
executed before the a <<= 2 a = a << 2
expression was resolved. a >>= 3 a = a >> 3
24
Memory Accessing Operators
Operator Meaning Example Result
& Address of &x Memory address of variable x
* Pointer variable 2 meanings:
declaration or int *p; • Pointer variable declaration
Indirection *p = 3; • The content of an object (or function)
pointed by p.
[] Array element x[i] *(x+i), the element with index i in the array
x.
. Member of a s.x The member named x in the structure or
structure or union union s
-> Member of a p->x The member named x in the structure or
structure or union union pointed to by pointer variable p.

25
Conditional Operator (? :)
expression_A ? expression_B : expression_C;
 If expression_A returns TRUE, execute expression_B,

else execute expression_C
 Example: Assume x = 5 and y = 2. What is the output of:

( x && y ) ? printf(“True”); printf(“False”);
(x & y ) ? printf(“True”); printf(“False”);
( x || y ) ? printf(“True”); printf(“False”);
(x|y) ? printf(“True”); printf(“False”);

26
Operator Precedence
Name Level Operators Grouping
Primary 1 (High) () . [] -> Left to right
Unary 2 ! ~ (type) * & ++ -- sizeof Right to left
Binary 3 * / % Left to Right
Arithmetic 4 + - Left to right
Shift 5 << >> Left to right
Relational 6 < <= > >= Left to right
Equality 7 == != Left to right
Bitwise 8 & Left to right
Bitwise 9 ^ Left to right
Bitwise 10 | Left to right
Logical 11 && Left to right
Logical 12 || Left to right
Conditional 13 ? : Right to left
Assignment 14 (low) = += -= /= *= %= <<= >>= &= ^= |= Right to left
 Instead of memorize this table, use parenthesis () to guarantee the order process.
27
Control Statement

28
Control Statement
 To control the flow of execution of a program
• if/else: To steer or branch the operation in one of two directions.
• while, do/while, for: To control the repetition of a block of
instructions
• switch/case: To allow a single decision to direct the flow of the
program to one of many possible blocks of instruction in a clean
and concise fashion.

29
If branch
if (condition)
{
statement1;
statement2;
…..
}
OR
 Try to create a good programming habit

if (condition) to always include the { } though the if
statement; block only consists of single statement.
30
If…else branch
if (condition)
{
statement1;
statement2;
…..
}
else
{
statement1; if (condition)
statement2; statementT;  Try to create a good programming
….. habit to always include the { }
else
} though the if block only consists
statementF;
of single statement.
31
If…else if … else branch
if (condition1)
statement1;
else if (condition2)
statement2;
else if (condition3)
statement3;
…..
else if (condition_n-1)
statementn-1;
else
statementn;

32
Switch…case statements
switch (condition)
{
case condition1:
statements1;
break;
case condition2:
statements2;
break;
…
case conditionn-1:
statementsn-1;
break;
default:
statementsn;
break;  The condition could only accept
}
either integer or char value.
33
While loop
while (condition)
{
statement1;
statement2;
…..
}
OR
 Try to create a good programming
while (condition) habit to always include the { } though
statement; the while loop only consists of single
statement.
34
Do…While loop
do
{
statement1;
statement2;
…..
} while (condition);
OR
do  Try to create a good programming

statement; habit to always include the { } though
while (condition); the while loop only consists of single
statement.
35
For loop
for (init; condition; update)
{
statement1;
statement2;
…..
}  Initialization: only execute once at the
start of the loop
OR  Conditional: Tested and if result
returns TRUE, then statements are
for (init; condition; update) executed.
statement;
 Update: Execute at the end of each
loop iteration
36
For loop
for (init; condition; update)
{
statement1;
statement2;
…..
}
Equal with:
init;
while (condition)
{
statement1;
statement2;
…..
update;
}

37
break, continue, and goto
 break, continue, and goto: To modify the execution of the for, while,
do/while, and switch statements.
 break:
• To exit from a for, while, do/while, or switch statement entirely.
• If the statements are nested one inside the other, the break statement will exit
only from the immediate block of statements.
 continue:
• Allow the program to start the next iteration of a while, do/while, or for loop.
• Quit the following statements after continue but restart the loop again as next
iteration.
 goto: Literally “jump” execution of the program to a label marking
the next statement to be executed.

38
break

39
continue

40
break vs continue
break continue
A break can appear in both switch and A continue can appear only in loop (for, while, do)
loop (for, while, do) statements. statements.
A break causes the switch or loop A continue doesn't terminate the loop, it causes the
statements to terminate the moment it loop to go to the next iteration. All iterations of the
is executed. Loop or switch ends loop are executed even if continue is encountered.
abruptly when break is encountered. The continue statement is used to skip statements in
the loop that appear after the continue.
The break statement can be used in The continue statement can appear only in loops.
both switch and loop statements. You will get an error if this appears in switch
statement.
When a break statement is When a continue statement is encountered, it gets
encountered, it terminates the block the control to the next iteration of the loop.
and gets the control out of
the switch or loop.
A break causes the innermost enclosing A continue inside a loop nested within a
loop or switch to be exited immediately. switch causes the next loop iteration.

41
Functions

42
Functions
 Function / subroutine / procedures: an encapsulation of a block
of statements that can be used more than once in a program.
 Development of a “library”
• Modularity
• Reusability
• Save time and maintains stability
 A function may not receive any argument or parameter or
return a value: void.
 A function may accept multiple parameters, but it can only
return one, default type is int.

43
Function Prototype Declaration
 Normally declared in a “header.h” file then include by a
“program.c” file.
e.g.
/* program.c */
#include “header1.h” //user header file
#include <header2.h> // system header file
 Function declaration:
return_type function_name (type arg1, type arg2, …type argn);
float arg1 float

int Output / int
char arg2 function_name char
Return value
double : (only allow one) double
etc argn etc

44
Function Prototype Declaration
 e.g. /* header1.h */
int func_1 (int a, double b, char c); // argument type is compulsory
// OR
int func_1 (int, double, char); // argument name is optional
void func_2 (void);
(integer) a
(double) b func_1 int func_2

(char) c
 C DOES NOT allow multiple function prototype declaration

with same function name
e.g. /* header1.h */
int func_1 (int, double, char);
int func_1www.utm.my
(double, double, char);innovative
// illegal
● entrepreneurial ● global 45
45
Function Body Definition
 Normally declared in a “header.c” file while include the function prototype
declaration of “header.h” file.
e.g.
/* header1.c */
#include “header1.h”
 Function definition:
return_type function_name (type arg1, type arg2, …type argn)
{
statement1;
statement2;
…….
statementn;
return (value);
}

46
Function Body Definition
 The number, type and the sequence of the argument during
function definition or function call MUST BE MATCHED with
function declaration.
 e.g: /* header1.h */
int func1 (int a, double b, char c);
/* header1.c */
#include “header1.h”
int func1 (int a, double b, char c) // match!
{ … }
char func1 (double a, double b, char c) // type of agrument mismatch!
{ … }
int func1 (double b, int a, char c) // type and sequence of arguments mismatch!
{ … }
int func1 (char c) // # of argument mismatch!
{ … }
47
Complete Example
/* ALU.h */ /* main.c */
int addition (int a, int b); #include “ALU.h”
double multiplication (double a, double b);
int main()
/* ALU.c */ {
#include “ALU.h” int a = 3, b = 5, c = 0;
int x = 3.45, y = 4.12, z = 0.0;
int addition (int a, int b)
{ int c; c = addition (a, b);
c = a + b; z = multiplication (x, y);
return c; }
}
double multiplication (double a, double b)

{ int c;
c = a * b;
return c;
}
48
Recursive Function
 A function that calls itself.
 Example: Calculating factorials: n! = n * (n-1)!
int fact (int n)
{
if (n==0)
return 1;
else
return ( n * fact (n-1));
}
 Possible applications: factorials, quick sorts, and linked-lists

searches.

49
Pointers and Arrays

50
Pointers
 Pointers: Variables that contain the address or location of a
variable, constant, function or data object.
 Allocates an area in memory large enough to hold the
machines address of the variable (not according to the data
width)
 Dealing with the address of the variable it is pointing to, not
the value of the variable itself.
 * : Indirection or dereferencing operator, to gain access to
the data located at the address contained in the pointer.
 &: Address operator
51
Pointers
 e.g.
char *p; // p is a pointer to a character
char a, b; // a and b are normal character variables
p = &a; // p stores the address of variable a and

// pointing to a
b = *p; //b equals the contents pointed to by p, b = a
*p = 5; //the contents pointed to by p stores 5, a = 5

52
Pointers Memory Address Memory (RAM) Variables
0x1000 0x35 a
0x1001 0x36
p = &a
char *p; 0x1002 0x78 b
0x1003 0x8A
char a, b;
0x1004 0x10 *p
0x1005 0x00
p = &a;
BEFORE
b = *p;
*p = 5; Memory Address Memory (RAM) Variables
0x1000 0x05 (*p = 5) a
0x1001 0x36
p = &a
0x1002 0x35 (b = *p) b
0x1003 0x8A
0x1004 0x10 *p
0x1005 0x00
www.utm.my AFTER
53
Pointers
 Pointers are effectively addresses, they offer the ability to
move, copy, and change memory in all sorts of ways.
int *iptr; // a pointer point to a integer variable
long *lptr; // a pointer point to a long variable
iptr = iptr + 1; // moves the pointer to the next integer

// (2 bytes away)
lptr = lptr + 1; // moves the pointer to the next long
// integer (4 bytes away)
iptr++; // moves the pointer to the next integer
// (2 bytes away)
--lptr++; // moves the pointer back to the preceding
// long integer location (-4 bytes)

54
Pointers
 Other eg: Same priority, evaluate from left to right
char c;
char *p;
c = *p++; //assign c the value pointed to by p, and then

// increment the address p
c = *++p; // increment the address p, then assign c the
// value pointed to by p
c = ++*p; // increment the value pointed to by p, then
// assign it to c, leaving the value of p untouched
c = (*p)++; // assign c the value pointed to by p, and then
// increment the value pointed to by p, leaving the
// value of p untouched

55
Pointers and Function
/* ALU.h */  Pointers can be used to extend the
void swap1 (int a, int b); amount of information returned
void swap2 (int *a, int *b); from a function.
/* main.c */
/* ALU.c */
#include “ALU.h”
#include “ALU.h”
void swap1 (int a, int b) int main()

{ int temp; {
temp = b; int a = 23, b = 35;
b = a; int *ptr_a = &a, *ptr_b = &b;
a = temp;
} swap1 (a, b); // pass by value
swap2 (ptr_a, ptr_b); // pass by pointer
void swap2 (int *a, int *b) swap2 (&a, &b); // pass by reference
{ int temp; }
temp = *b;
*b = *a; Are all these three function calls
*a = temp;
}
returns the same result?
56
Arrays
 Array: A data set of same declared type, arranged in order.
int digits[10]; // this declares an array of 10 integers
char str[20]; // this declares an array of 20 characters
 Referencing of an array elements: by an index or subscript, range
from 0 to n-1.
str[0], str[1], str[2], …….. str[19]
 Array declarations can contain initializer.

int array[5] = {5, 10, 15, 20, 25};
//what will happen if:

c = array[8]; //? – will lead to unexpected result
// outside of array boudary
57
Character Array
 Most common array type.
 Also refer as a string or character string.
char str[6];
const cstr[8] = “Hello C”;
Memory Address Memory (ROM) Variables

0x1000 ‘H’ cstr[0]
0x1001 ‘e’ cstr[1]
0x1002 ‘I’ cstr[2]
0x1003 ‘l’ cstr[3]
0x1004 ‘o’ cstr[4]
0x1005 ‘<space>’ cstr[5]
0x1006 ‘C’ cstr[6]
0x1007 \0 (null termination) cstr[7]
58
Multidimensional Arrays
 Multidimensional Array: Arrays of arrays
 Could be two, three, four, or more dimensions.
 Useful in operations such as matrix arithmetic, filters, and look-
up tables (LUTs) block_A [0] [1]
int block_A[2];
block_B [0] [0] [1]
int block_B[2][2];
int block_C[3][2][2]; [1] [0] [1]
[0] [1] [2]
block_C [0] [0] [1] [0] [0] [1] [0] [0] [1]
[1] [0] [1] [1] [0] [1] [1] [0] [1]

59
Array and Pointers
 The array name itself is treated as the address of the first
element in the array.
char stng[10];
char *p;
p = stng; // p is pointing to stng[0]

p = &stng[0]; // same as statement above
p = &stng[5]; //p is pointing to stng[5]

*p = 5; // stng[5] = 5

60
Structure and Union

61
Structures and Unions
 Used to group variables (could consist of different variable
data type) under one heading or name.
 A structure or union can be thought of as an object.
 The members of the structure or union are the properties
(variables) of that object.
 Consider as the fundamental elements in object-oriented
programming (OOP).

62
Structures
 Structure template declaration:
struct structure_name struct structure_name
{ {
type member1; type member1;
… …
type memberX; type memberX;
}; } structure_var_name;
 Structure variable declaration:

struct structure_name var1, var2[3];
 Member operator (.) : to access a member within a structure
structure_var_name.member1;
63
Structures Examples
// Structure template declaration struct LOCATION
struct DATE {
{ int x;
int y;
int day; };
int month;
int year; struct PART
}; {
char name[20];
long int sku;
// Structure variable declaration struct LOCATION bin;
struct DATE birth_date = { 3, 9, 1980}; } widget;
// Access & modify structure member location_x = widget.bin.x;

birth_date.day = 31; location_y = widget.bin.y;
birth_date.month = 8; widget.bin.x = 30;
birth_date.year = 1978; widget.bin.y = 256;

64
Structures
 A structure can be passed to a function as a parameter as
well as returned from a function.
struct PART new_location (int x, int y)
{
struct PART temp;
temp.name = “ “;
temp.sku = 0;
temp.bin.x = x;
temp.bin.y = y;
}
widget = new_location (10,10);

65
Array of Structures
struct PART
{
char name[20];
long int sku;
struct LOCATION bin;
} widget[100];
location_x = widget[23].bin.x;
location_y = widget[23].bin.y;
widget[23].name; // the name of widget 24

widget[23].name[0]; // the 1st character in the name of
//widget 24
66
Pointer to Structure
 To use a pointer to reference the structure, eg. Passing a
pointer to a structure to a function instead of passing the
entire structure.
 Structure pointer variable declaration:
struct structure_name *structure_var_name;
 Structure pointer operator (->): To access the members of the
structure through indirection.
structure_var_name -> member;
OR
(*structure_var_name).member;
67
Pointer to Structure Example
struct LOCATION
{ // This is the location coordinates x and y
int x;
int y;
};
struct PART
{
char name[20]; // a string for the part name
long int sku; // a SKU number for the part
struct LOCATION bin; // its location in the warehouse
};
struct PART widget, *this_widget; // declare a structure and a pointer to a structure
this_widget = &widget; // assign the pointer the address of a structure
…
this_widget->sku = 1234; // Access a member of the structure through indirection
(*this_widget).sku = 1234; // Using the indirection operator to first locate the
// structure and then using the member operator to
// access the sku member

68
Unions
 Much like a structure, but difference in the way the memory
is allocated.
 The members of a union actually share a common memory
allocated to the largest member of that union.
union union_name union union_name

{ {
… …
type memberX; type memberX;
}; } union_var_name;

69
Unions
 E.g union SOME_TYPES Allocated memory:
{
char character; 4 bytes (long int datatype)
int integer;
long int long_one;
} my_space;
my_space.long_one = 0x12345678L;
Then the character and integer will also be modified
my_space.character = 0x12;
my_space.integer = 0x1234;
70
Unions
 Used as a method of preserving valuable memory space.
 Define a “scratch pad” area of memory: If there are
variables that are used on a temporary basis, and there is
never a chance that they will be used at the same time
 Used a s method of extracting smaller parts of data from a
larger data object
 The data could be byte order swapped, word order
swapped, or both.
 Could be used as a test for a compiler in order to find out
data organization in memory (big-endian or little endian)

71
Array vs. Structures
Array Structure
Collection of data elements of same Collection of data elements of
type (homogeneous). different types (heterogeneous)
Derived data type Programmer-defined data type
Any array behaves like a built-in data But in the case of structure, first we have
types. All we have to do is to declare an to design and declare a data structure
array variable and use it. before the variable of that type are
declared and used.
Allocates static memory Allocate dynamic memory
Array data are access using index. Structure elements are access using (.)
operator.
Array is a pointer to the first element of Structure is not a pointer
it
Element access takes relatively less Property access takes relatively large
time. time.

Structures vs. Union
Structure Union
Keyword: struct Keyword: union
When a variable is associated with a When a variable is associated with a union,
structure, the compiler allocates the memory the compiler allocates the memory by
for each member. considering the size of the largest memory.
Size is greater than or equal to the sum of Size of union is equal to the size of largest
sizes of its members. The smaller members member.
may end with unused slack bytes.
Each member within a structure is assigned Memory allocated is shared by individual
unique storage area of location. members of union.
The address of each member will be in The address is same for all the members of a
ascending order. This indicates that memory union. This indicates that every member
for each member will start at different offset begins at the same offset value.
values.
Altering the value of a member will not affect Altering the value of any of the member will
other members of the structure. alter other member values.
Individual member can be accessed at a time. Only one member can be accessed at a time.
Several members of a structure can initialize Only the first member of a union can be
at once. initialized.
73
typedef and sizeof operators

74
typedef
 typedef: For creating new type name with an existing type.
typedef struct
typedef unsigned char byte; { char name[20];
typedef unsigned int word; char age;
int hp_no;
} student;
byte var1;
student Jasmine;
word var2; student Wendy;
 typedef is evaluated by the compiler directly and can work

with declarations, castings, and usages that would exceed
the capabilities of the pre-processor #define.

75
sizeof
 sizeof: A compile-time feature that creates a constant value
related to the size of data object or its type (in bytes)
located in the parentheses ( ).
sizeof (typename);
sizeof(object);
 Example:
int value, x; x = sizeof(int); // this would set x=2, since an int is 2 bytes
long int array[2][3];
x = sizeof(value); // this would set x=2, since value is an int
x = sizeof(long); // this would set x=4, since a long is 4 bytes
struct record x = sizeof(array); // x = sizeof(long)*array_width*array_length
{ //= 4*2*3 = 24
char name[24];
int id_number; x = sizeof(record); // x = 24+2 for the char string + the integer
} students[100]; x = sizeof(students); // x = 100 Elements * (24 characters +
sizeof(int)), x = 100*(24+2) = 2600 !!
76
Software Development

77
Software Development Cycle

78
Programming styles, standards &
guidelines
 Readability and maintainability of the software
 A documented development process
 Project management
 Quality control and meeting outside requirements such as
ISO9001 and ISO9003
 Configuration management and revision control
 Design-rule and code-style requirements of your company or
organization
 Verification and validation processes to meet medical and
industrial requirements
 Hazard analysis
79

Summary of C Programming

Uploaded by

Document Information

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

Summary of C Programming

Uploaded by

Copyright:

Available Formats

Module 1

Dr. Hau Yuan Wen (Jasmine)

www.utm.my innovative ● entrepreneurial ● global 1

www.utm.my innovative ● entrepreneurial ● global 22

www.utm.my innovative ● entrepreneurial ● global 33

www.utm.my innovative ● entrepreneurial ● global 44

www.utm.my innovative ● entrepreneurial ● global 55

www.utm.my innovative ● entrepreneurial ● global 66

www.utm.my innovative ● entrepreneurial ● global 77

www.utm.my innovative ● entrepreneurial ● global 88

www.utm.my innovative ● entrepreneurial ● global 99

www.utm.my innovative ● entrepreneurial ● global 10

www.utm.my innovative ● entrepreneurial ● global 13

Representation Suffix Example

www.utm.my innovative ● entrepreneurial ● global 15

www.utm.my innovative ● entrepreneurial ● global 16

printf("green_led_on = %d\n", green_led_on);

www.utm.my innovative ● entrepreneurial ● global 18

y = (char)x + 3; // x is converted to a character and then 3 is added,

www.utm.my innovative ● entrepreneurial ● global 20

www.utm.my innovative ● entrepreneurial ● global 21

www.utm.my innovative ● entrepreneurial ● global 25

expression_A ? expression_B : expression_C;

 If expression_A returns TRUE, execute expression_B,

 Example: Assume x = 5 and y = 2. What is the output of:

www.utm.my innovative ● entrepreneurial ● global 26

www.utm.my innovative ● entrepreneurial ● global 28

www.utm.my innovative ● entrepreneurial ● global 29

 Try to create a good programming habit

www.utm.my innovative ● entrepreneurial ● global 32

do  Try to create a good programming

www.utm.my innovative ● entrepreneurial ● global 37

www.utm.my innovative ● entrepreneurial ● global 38

www.utm.my innovative ● entrepreneurial ● global 39

www.utm.my innovative ● entrepreneurial ● global 40

www.utm.my innovative ● entrepreneurial ● global 41

www.utm.my innovative ● entrepreneurial ● global 42

www.utm.my innovative ● entrepreneurial ● global 43

float arg1 float

www.utm.my innovative ● entrepreneurial ● global 44

(double) b func_1 int func_2

 C DOES NOT allow multiple function prototype declaration

www.utm.my innovative ● entrepreneurial ● global 46

double multiplication (double a, double b)

 Possible applications: factorials, quick sorts, and linked-lists

www.utm.my innovative ● entrepreneurial ● global 49

www.utm.my innovative ● entrepreneurial ● global 50

char a, b; // a and b are normal character variables

p = &a; // p stores the address of variable a and

b = *p; //b equals the contents pointed to by p, b = a

*p = 5; //the contents pointed to by p stores 5, a = 5

www.utm.my innovative ● entrepreneurial ● global 52

iptr = iptr + 1; // moves the pointer to the next integer

www.utm.my innovative ● entrepreneurial ● global 54

c = *p++; //assign c the value pointed to by p, and then

www.utm.my innovative ● entrepreneurial ● global 55

void swap1 (int a, int b) int main()

 Array declarations can contain initializer.

//what will happen if:

Memory Address Memory (ROM) Variables

[0] [1] [2]

[1] [0] [1] [1] [0] [1] [1] [0] [1]

www.utm.my innovative ● entrepreneurial ● global 59

p = stng; // p is pointing to stng[0]