Homework

• Starting Chapter 2 K&R. Read ahead.

• Questions?

Call by Value vs Call by Reference

• Simple variables passed as function parameters in C are actually only copies on the stack.

(Note: Stack pointer is a register)

foo(i, j);

void foo(int i, int j)

{

}

Stack PointerBefore call and after return

Unused

Stack PointerAfter call and before return

Unused i jReturnData

StackData

StackData

Copy of Value

• This is known as Call by Value. • Unlike some languages, which have call by

reference• You can't change arguments in original location

within the function -- just change the stack copy • To make changes, you must pass pointers to

original variables. See next slide.• You’re not responsible for pointers yet, but start

getting used to them!

Call by Value vs Call by Reference

Pointers as Arguments• Pointer variables passed as function parameters

in C are still only value on the stack but can be used to access original location indirectly

foo(&i, &j);

void foo(int *i, int *j)

{

}

Stack PointerBefore call and after return

Unused

Stack PointerAfter call and before return

Unused &i &jReturnData

StackData

StackData

Point to values

Pointers as Arguments• The following doesn’t work!!!

void exchgint (int a, int b) { int dummy;

dummy = a; a = b; b = dummy;

}

Pointers as Arguments• Must be done with pointers!!!

void exchgint (int *pa, int *pb){

int dummy; dummy = *pa; *pa = *pb; *pb = dummy;

}

Pointers as Arguments

• An array name is automatically passed as a pointer • You don't need to create a pointer yourself with the

“address of” operator (&)

int array1[10], array2[10];

foo(array1, array2);• Unless you are passing a pointer to a specific array

element (Remember printf in visitype?)

foo(&array1[4*i], &array2[4*j]);

Scope of Variables – Local Automatic• Each local variable of a function (inside { }) comes into

existence only when it is called disappears when a return is performed.

• Local variables are said to be automatic. • Memory is allocated on the stack after the calling sequence

argument values• Undefined (i.e. garbage) value unless explicitly initialized in

the source code• Initialization is done each time the function or block is

entered (K&R P.85).

Stack PointerAfter local variables are allocated

StackDataUnused i j

ReturnData

LocalVariables

Scope of Variables – Local Static• A local alternative to automatic is known as static. • A static variable declared in a function is preserved in memory.

Still local - can only be used inside { }.• It is guaranteed to be initialized to zero if it is not initialized

otherwise.• If the static variable is initialized, it is done once before the

program starts execution (K&R P.85).

e.g., the seed of a random number generator so it will have memory from one invocation to the next and not always give the same random number.

int rand( ){ static int seed = 1; /* initialize to 1 in the beginning and

remember value between calls to rand */}

Scope of Variables – Local Static

• Good for implementing a “Finite State Machine”– They allow a function to preserve its state value(s)

• But, be careful using local static variables!!– A function may behave differently when it is called

with different values preserved in local static variables– Makes testing of a function more complex because you

need to test its behavior with all possible values of any local static variables

– Complex sequence of calls to function may be required to drive local static variables into desired test “state(s)”

Scope of Variables - External• Alternative to local is known as external• Look at maxline program on page 32 of K&R• Variables declared ahead of/outside of all { }’s are available

to all functions within the program load• These are sometimes called “global variables”• Can be used to pass data between functions• Values are preserved like static local variables• It is guaranteed to be initialized to zero • If the external variable is initialized, it is done once before

the program starts execution. • Not a good idea to use them – Why not?

Scope of Variables - External• Global variables are not a good idea because:

– They can be accessed from anywhere. If their value gets corrupted, it is NOT easy to figure out what code in which function caused the corruption.

– They make the functions dependent on their external environment instead of being able to stand alone using arguments to get their input values and a return value to pass back an output value.

• Software architecture/design standards for most projects will prohibit use of “global variables” or severely restrict their use. Don’t use them!!

Scope of Variables – External Static

• Another alternative known as external static• No good examples that I see in K&R• Static variables declared ahead of/outside of all { }’s are

available to all functions within this file only• These are very similar to OOP “class variables”• Can be used to pass data between functions in file only• Values are preserved like static local variables• It is guaranteed to be initialized to zero• If the external static variable is initialized, it is done once

before the program starts execution. • These are more acceptable than global variables

Examples of Scopes of Variables

• These examples are from p.342:

“C Programming for Scientists and Engineers with Applications” by Rama Reddy and Carol Ziegler, Jones and Bartlett 2010.

Scope of Variables – Example #1

#include <stdio.h>int main(){ int a=10; printf(“a=%d\n”, a); { int b=5; printf(“b=%d\n”, b); { int c=40; printf(“c=%d\n”,c); } } return 0;}

Scope of c

Scope of b

Scope of a

10

5

40

Scope of Variables – Example #2#include <stdio.h>int main(){ int x=10; printf(“x=%d\n”, x); { int x=5; printf(“x=%d\n”, x); { int x=40; printf(“x=%d\n”,x); } x=x+4; printf(“x=%d\n”,x); } x=x+15; printf(“x=%d\n”,x); return 0;}

x=40 x=5+4 x=10+15

If the same variable is defined inside and outside the block,the name inside the block will be referenced if the block is being executed.

10

5

40

9

25

Scope of Variables – Example #3#include <stdio.h>void func1(void); void func2(void); void func3(void);int main(){ int x=20; printf(“x=%d\n”, x); func1(); x=x+10; printf(“x=%d\n”, x); func2(); x=x+40; printf(“x=%d\n”,x); func3(); return 0;}

int x;void func1(void){ x=5; printf(“In func1 x=%d\n”,x); return;}

void func2(void){ int x=0; printf(“In func2 x=%d\n”, x); return;}

void func3(void){ printf(“In func3 x=%d\n”, x); return ;}

Scope of 1st x

Scope of 2nd xScope of

3rd x

20

30

70

5

0

5

Scope of Variables – Example #4#include <stdio.h>void func1(void); void func2(void); int main(){ int x=5; printf(“x=%d\n”, x); func1(); x=x+5; printf(“x=%d\n”, x); func2(); x=x+5; printf(“x=%d\n”,x); return 0;}int x;void func1(void){ x=6; printf(“In func1 x=%d\n”,x);}void func2(void){ x=x+10; printf(“In func2 x=%d\n”, x);}

Scope of x

Scope of x

External storage class definition

5

10

15

6

16

Scope of Variables – Example #5#include <stdio.h>void func1(void); void func2(void); int main(){ extern int x; x=1; printf(“x=%d\n”, x); func1(); x=x+6; printf(“x=%d\n”, x); func2(); x=x+7; printf(“x=%d\n”,x); return 0;}

int x;void func1(void){ printf(“In func1 x=%d\n”,x); x=5;}void func2(void){ x=x+10; printf(“In func2 x=%d\n”, x);}

Scope of x

File 2

File 1

1

1

11

21

28

Scope of Variables – Example #6#include <stdio.h>void func1(void); void func2(void); int main(){ extern int x; x=1; printf(“x=%d\n”, x); func1(); x=x+6; printf(“x=%d\n”, x); func2(); x=x+7; printf(“x=%d\n”,x); return 0;}

int x;void func1(void){ x=5; printf(“In func1 x=%d\n”,x);}void func2(void){ int x=10; printf(“In func2 x=%d\n”, x);}

Scope of x

Scope of x

File 1

File 2

1

11

18

5

10

Data Types

• Finished K&R Chapter 1 / Now starting Chapter 2• Variable Names• Data Types:

– char– int– short int– long int– float– double

Variable / Symbolic Constant Names

• Rules for generating names:– All letters and digits are allowed– Uppercase and lower case letters are different– First character must be a letter– Underscore _ counts as a letter

(useful for improving readability)– But, don’t begin variable names with _

(reserved for library routines)

Variable / Symbolic Constant Names (cont’d)

• Rules for generating names:– Internal - at least 31 characters are significant– External – e.g. function names: only count on 6

characters and a single case– Avoid using C keywords (if, else, int, float, etc.)– Choose variable names that are related to the purpose

or use of the variable

Data Types• char (character)

char has 8 bits (stored in one byte in memory)unsigned:

0 ≤ char ≤ 28 -100000000 ≤ char ≤ 11111111Overflow at 255 (255 + 1 = 0)Underflow at 0 (0 – 1 = 255)

signed (if supported in the implementation):-27 ≤ char ≤ 27-110000000 ≤ char ≤ 01111111Overflow at 127 (127 + 1 = -128)Underflow at –128 (-128 – 1 = 127)

Data Types• int (integer on our machines)

int has 32 bits (stored in four sequential bytes in memory)unsigned:

0 ≤ char ≤ 232 - 10x00000000 ≤ char ≤ 0xffffffffOverflow at 4294967295 (4294967295 + 1 = 0)Underflow at 0 (0 – 1 = 4294967295)

signed:-231 ≤ char ≤ 231-10x80000000 ≤ char ≤ 0x7fffffffOverflow at 2147483647 (2147483647 + 1 = –2147483648)Underflow at –2147483648 (-2147483648 – 1 = 2147483647)

Data Types• short int (short integer on our machines)

short int has 16 bits (stored in two sequential bytes in memory)unsigned:

0 ≤ char ≤ 216 - 10x0000 ≤ char ≤ 0xffffOverflow at 65535 (65535 + 1 = 0)Underflow at 0 (0 – 1 = 65535)

signed:-215 ≤ char ≤ 215-10x8000 ≤ char ≤ 0x7fffOverflow at 32767 (32767 + 1 = –32768)Underflow at –32768 (-32768 – 1 = 32767)

Data Types• long int (long integer on our machines – same as int)

long int has 32 bits (stored in four sequential bytes in memory)unsigned:

0 ≤ char ≤ 232 - 10x0000 0000 ≤ char ≤ 0xffff ffffOverflow at 4294967295 (4294967295 + 1 = 0)Underflow at 0 (0 – 1 = 4294967295)

signed:-231 ≤ char ≤ 231-10x8000 0000 ≤ char ≤ 0x7fff ffffOverflow at 2147483647 (2147483647 + 1 = –2147483648)Underflow at –2147483648 (-2147483648 – 1 = 2147483647)

Data Types• float

– 32-bits (stored in four sequential bytes in memory) – based on the IEEE 754 floating point standard

+ 1.f x 2e

1 8 bits 23 bits

sign exponent e fraction f

Data Types• float, double

– Both represent numbers with fractional parts– “double” is a “float” with more precision– Don't do much with float or double in this course– Implementation is machine dependent: for our machine: float is 4 bytes double is 8 bytes

• Without a co-processor to do floating point computations, it takes a lot of computation time to do them in software. – Not often used in real time, embedded systems. – A cost versus performance tradeoff!

Numbering Systems• Binary (no symbol to represent binary numbers)

– Learn binary numbers using this gamehttp://forums.cisco.com/CertCom/game/binary_game_page.htm

• Octal (Octal Constant is written 0dd…)OCTAL BINARY OCTAL BINARY

0 000 4 1001 001 5 1012 010 6 1103 011 7 111

Note: Can’t write a decimal value with a leading 0 digit – will be interpreted as octal

zero

Numbering Systems• Hex (Hex Constant is written 0xdd…)

HEX BIN. HEX BIN. HEX BIN. HEX BIN. 0 0000 4 0100 8 1000 C 1100

1 0001 5 0101 9 1001 D 1101 2 0010 6 0110 A 1010 E 1110 3 0011 7 0111 B 1011 F 1111

NOTE: Memorize these translations

• DO NOT convert between binary and Hex or Octal by converting to decimal and back! Much harder!!

• Learn to group binary digits by 3 (for octal) or 4 (for hex) to convert

Examples of the Number System

Decimal Octal Hex

31 --------> 037 -----------> 0x1f

128 -------->0200 ----------> 0x80

Numbering Systems• char Data Type Constants

‘a’ integer value in ASCII code for letter a‘0’ integer value in ASCII code for number 0

‘\b’ integer value in ASCII code for backspace

‘\ooo’ octal value 000 – 377 (0 – 255 decimal)

‘\xhh’ hex value 0x00 – 0xff (0 – 255 decimal)

• examples‘a’ = 0x61 ‘0’ = 0x30

‘\127’ = 0x57 ‘\x2b’ = 0x2b

Numbering Systems

• Other Data Type Constants1234 int

1234L long int

1234UL unsigned long int

1234. double (because of decimal point)

1234.4F float (because of the suffix)

1234e-2 double (because of exponent)