Transcript C in a Nutshell - California University of Pennsylvania

‘C’ in a Nutshell
A “crash course” in C...
...with designs for embedded systems
by J. S. Sumey
Part I: intro, variables, constants, operators
REFERENCE:
The C Programming Language (2nd ed.)
Brian W. Kernighan
Dennis M. Ritchie
Prentice Hall Software Series
'C' in a Nutshell by J. Sumey
2 of 27
Low-Level (Assembly) Programming
pros:

object code is smaller and runs faster
 important in embedded systems!

programmer has total control over system
hardware
cons:



need to know processor and hardware intimately
more tedious & time consuming
not portable!
'C' in a Nutshell by J. Sumey
3 of 27
High-Level Programming
pros:


source code is highly portable
more streamlined development, quicker
 increased programmer productivity



support of structured design techniques
more readable code, easier maintenance
better math handling support
cons:

increased overhead
'C' in a Nutshell by J. Sumey
4 of 27
“Mixed” Approach
can use HLL like ‘C’ for bulk of project and
use assembly for select parts



time-sensitive functions
interrupt handling
special instructions, ex: fuzzy logic
creates linkage issues


calling assembly routines from C
parameter passing & return results
'C' in a Nutshell by J. Sumey
5 of 27
C Background
created in ‘70s by Dennis Ritchie at Bell Labs
a general-purpose “systems” programming
language, multi-domain



applications
compilers
operating systems
platform & architecture independent
standardized in late ‘80s by ANSI  “ANSI C”
is actually known as a mid-level language
most commonly used language in industry
'C' in a Nutshell by J. Sumey
6 of 27
Overview 1
a ‘typed’ language


fundamental: characters, integers, floating-point
derived: pointers, arrays, structures, unions
“basic” arithmetic & logical operations only
typical control-flow constructs




statement grouping
decision
selection
looping
'C' in a Nutshell by J. Sumey
7 of 27
Overview 2
functions:




may return anything (or nothing)
no nesting
may be recursive
may exist in separate source files compiled
individually or combined into a single file
variable scope (declarations, actually):



local to a function
local to a source file, global to all functions within
global to entire program
'C' in a Nutshell by J. Sumey
8 of 27
Overview 3
uses a “preprocessor” during compilation



macro substitution
include files
conditional compilation
depends on libraries for everything else!



input / output
file access
composite object manipulation
 i.e., arrays, lists, strings

dynamic memory allocation
'C' in a Nutshell by J. Sumey
9 of 27
I. Data Types & Operations
- representation of information
& how to manipulate it
Constants - 1
integers

use suffix to override default int
 ex: 999999999L – forces interpretation as long
 ex: 32767U – forces unsigned interpretation

prefixes to override default base (10)
 ex: 037 = 0x1f = 31
 ex: 0XFUL = ???
 some compilers also support binary constants:
#define MASK 0b11110000
floats

contain ‘.’ or ‘e’, default is double
 ex: 1e-1L – forces long interpretation
'C' in a Nutshell by J. Sumey
11 of 27
Constants - 2
characters

a single character within single quotes
 ex: ‘A’ = 0x41 = 65

can represent certain control characters via
“escape sequences”
 ex: ‘\n’, ‘\b’, ‘\f’, ‘\g’, ‘\r’, ‘\t’, ‘\\’

can also represent characters in octal & hex
 ex: #define LF ‘\012’
 ex: #define CR ‘\0x0d’
'C' in a Nutshell by J. Sumey
12 of 27
Constants - 3
sting literals


zero or more characters within double quotes
terminating null byte (‘\0’) is assumed
 ex: “a 21 character string”
gotcha:

‘t’  “t”
'C' in a Nutshell by J. Sumey
13 of 27
Variables
represent named storage locations in memory
must be declared before use

associates a data type to the variable
letters, numbers, & underscore



must start with letter or ‘_’
library routines typically start variables with ‘_’
convention: all UPPERCASE for symbolic constants;
lower or mixed upper/lower for variables
minimum 31 characters significant
don’t use reserved words (if, else, int, etc.)
'C' in a Nutshell by J. Sumey
14 of 27
Data Types
Basic data types:

char – holds a single character (ASCII)
 typically consumes 1 byte per char
 has same characteristics as ints

int – integer only number
 typically 16 or 32 bits, depends on architecture

float – ‘single precision’ floating point
 typically 32 bits, depends on architecture

double – ‘double precision’ floating point
 typically 64 bits, depends on architecture
'C' in a Nutshell by J. Sumey
15 of 27
Data Type ‘Qualifiers’
modify the basic properties of the data type

long & short – apply to integers to force them to
more or less dynamic range
 ex: short int loopctr;
 ‘int’ may be omitted

signed & unsigned – applies to chars & ints
 ex: unsigned char uc; range of ‘uc’ is 0..255
 ex: signed char sc; range of ‘sc’ is -128..+127

long double – extended-precision floating point
standard headers define sizes for given system

<limits.h> & <float.h>
'C' in a Nutshell by J. Sumey
16 of 27
Sample program: sizes.c
#include <stdio.h>
#include <limits.h>
#include <float.h>
main()
{
printf( "\n--- SIZES OF BASIC DATA TYPES ON A COLDFIRE v1 ---\n\n" );
printf( "number of bits in a char: %i\n", CHAR_BIT );
printf( "range of a unsigned char: %u..%u\n", 0, UCHAR_MAX );
printf( "range of a
signed char: %i..%i\n", SCHAR_MIN, SCHAR_MAX );
printf( "range of a plane ol char: %i..%i\n", CHAR_MIN, CHAR_MAX );
puts( "" );
printf( "number of bits in a short: %i\n", sizeof(short)*8);
printf( " range of a short integer: %i..%i\n", SHRT_MIN, SHRT_MAX );
printf( "
an unsigned short: %u..%u\n", 0, USHRT_MAX );
puts( "" );
printf( " number of bits in a int: %i\n", sizeof(int)*8 );
printf( " range of a plane integer: %i..%i\n", INT_MIN, INT_MAX );
printf( "
an unsigned int: %u..%u\n", 0, UINT_MAX );
puts( "" );
printf( " number of bits in a long: %i\n", sizeof(long)*8 );
printf( " range of a long integer: %li..%li\n", LONG_MIN, LONG_MAX );
printf( "
an unsigned long: %lu..%lu\n", 0L, ULONG_MAX );
puts( "" );
printf( " number of bits in a long long: %i\n", sizeof(long long)*8 );
printf( " range of a long long int: %lli..%lli\n", LLONG_MIN, LLONG_MAX );
printf( "
an unsigned long long: %llu..%llu\n", 0LL, ULLONG_MAX );
puts( "" );
printf( " number of digits in a float: %i\n", FLT_DIG );
printf( "
range of a plane ol float: %E..%E\n", FLT_MIN, FLT_MAX );
puts( "" );
printf( "number of digits in a double: %i\n", DBL_DIG );
printf( " range of a plane ol double: %.15E..%.15E\n", DBL_MIN, DBL_MAX );
}
'C' in a Nutshell by J. Sumey
17 of 27
Sample run on a ColdFire v1 MCU
--- SIZES OF BASIC DATA TYPES ON A COLDFIRE v1 --number of bits in a
range of a unsigned
range of a
signed
range of a plane ol
char:
char:
char:
char:
8
0..255
-128..127
0..255
number of bits in a short: 16
range of a short integer: -32768..32767
an unsigned short: 0..65535
number of bits in a int: 32
range of a plane integer: -2147483648..2147483647
an unsigned int: 0..4294967295
number of bits in a long: 32
range of a long integer: -2147483648..2147483647
an unsigned long: 0..4294967295
number of bits in a long long: 64
range of a long long int: -9223372036854775808..9223372036854775807
an unsigned long long: 0..18446744073709551615
number of digits in a float: 6
range of a plane ol float: 1.175494E-38..3.402823E+38
number of digits in a double: 15
range of a plane ol double: 2.225073858507201E-308..1.797693134862316E+308
'C' in a Nutshell by J. Sumey
18 of 27
Data Types for Embedded Systems
very useful in embedded systems:

byte-sized (8-bit) data
 Byte, uchar, uint8, byte: 0..255
 sByte, schar, sint8: -128..+127

16-bit data
 Word, uint, uint16, word: 0..65535
 sWord, sint, sint16: -32768..+32767

32-bit data
 LWord, ulong, uint32, dword: 0..4294967295
 sLWord, slong, sint32: -2147483648..2147483647

Boolean
 bool: TRUE/FALSE

these are defined in stdtypes.h, derivative.h, etc.
'C' in a Nutshell by J. Sumey
19 of 27
“Extended” Data Types
additional data types derived from or
extending the basic types:





array
pointer
structure
union
function
will save for part III
'C' in a Nutshell by J. Sumey
20 of 27
Variable ‘Storage’ Attributes
define where variables are stored and how
they may be used / accessed



auto (default) – in a “stack frame”
register – kept in a processor register if possible
const – a variable that doesn’t change after
initialization
 should be stored in ROM

volatile – a variable that can change “on its own”
 I/O registers, semaphores

extern – a variable defined outside the module it
is referenced from
'C' in a Nutshell by J. Sumey
21 of 27
Declarations
variables must be declared before use
specifies a data type to each variable


ex: int first, last, inc;
ex: short Circuit;
may also include an initializer

ex: char esc = ‘\0x1b’;
the “const” qualifier declares a read-only
variable (cannot be subsequently changed)

ex: const float pi = 3.14159;
'C' in a Nutshell by J. Sumey
22 of 27
Operators - 1
arithmetic

+, -, *, /, % (modulus, ints only)
equality

== (equal), != (not equal)
relational

<, <=, =>, >
logical – normally used in if statements

&& (and), || (or), ! (not)
'C' in a Nutshell by J. Sumey
23 of 27
Operators - 2
increment / decrement


++, -be careful of prefix vs. postfix use!
bitwise




perform bit manipulation on char/integers only
& (AND), | (OR), ^ (EOR)
<< (shift left), >> (shift right)
~ (1’s complement)
these operators can be very useful for
embedded programming!

ex…
'C' in a Nutshell by J. Sumey
24 of 27
Assignment Operators
many binary operators have a corresponding
“assignment operator”



e1 op= e2 is equivalent to e1 = e1 op e2
ex: step += 2
this works for +, -, *, /, %, <<, >>, &, ^, |
increases efficiency in embedded
programming! (how?)


ex: porta |= 4;
ex: portb &= ~4;
'C' in a Nutshell by J. Sumey
25 of 27
Conditional Expressions
uses the ternary operator “?:” and three
expressions


expr1 ? expr2 : expr3
means: expr2 if expr1 is true (non-0), else expr3
ex: z = ( a < b ) ? a : b;
is equivalent to:
if (a < b) z = a; else z = b;
i.e., z = min( a, b) !
'C' in a Nutshell by J. Sumey
26 of 27
Precedence
PREC.
hi
determines order of
expression evaluation;
hence result!
association determines
binding of operators
may always be
overridden with parens

ex:
if (porta & 0x80 == 0)
bomb = 17 / 0;
OOPS!
what’s really wrong here?
lo
'C' in a Nutshell by J. Sumey
OPERATOR
ASSOC.
() [] -> .
l-to-r
! ~ ++ -- + - (unary)
* & (type) sizeof
r-to-l
*/%
l-to-r
+ - (binary)
l-to-r
<< >>
l-to-r
< <= >= >
l-to-r
== !=
l-to-r
&
l-to-r
^
l-to-r
|
l-to-r
&&
l-to-r
||
l-to-r
?:
r-to-l
= op=
r-to-l
,
l-to-r
27 of 27