starting chapter 2 k&r. read ahead.. call by value vs call by reference simple variables passed...
TRANSCRIPT
![Page 1: Starting Chapter 2 K&R. Read ahead.. Call by Value vs Call by Reference Simple variables passed as function parameters in C are actually only copies on](https://reader035.vdocuments.mx/reader035/viewer/2022062805/5697bfd81a28abf838caeb89/html5/thumbnails/1.jpg)
• Starting Chapter 2 K&R. Read ahead.
![Page 2: Starting Chapter 2 K&R. Read ahead.. Call by Value vs Call by Reference Simple variables passed as function parameters in C are actually only copies on](https://reader035.vdocuments.mx/reader035/viewer/2022062805/5697bfd81a28abf838caeb89/html5/thumbnails/2.jpg)
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
![Page 3: Starting Chapter 2 K&R. Read ahead.. Call by Value vs Call by Reference Simple variables passed as function parameters in C are actually only copies on](https://reader035.vdocuments.mx/reader035/viewer/2022062805/5697bfd81a28abf838caeb89/html5/thumbnails/3.jpg)
• 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
![Page 4: Starting Chapter 2 K&R. Read ahead.. Call by Value vs Call by Reference Simple variables passed as function parameters in C are actually only copies on](https://reader035.vdocuments.mx/reader035/viewer/2022062805/5697bfd81a28abf838caeb89/html5/thumbnails/4.jpg)
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
![Page 5: Starting Chapter 2 K&R. Read ahead.. Call by Value vs Call by Reference Simple variables passed as function parameters in C are actually only copies on](https://reader035.vdocuments.mx/reader035/viewer/2022062805/5697bfd81a28abf838caeb89/html5/thumbnails/5.jpg)
Pointers as Arguments• The following doesn’t work!!!
void exchgint (int a, int b) { int dummy;
dummy = a; a = b; b = dummy;
}
![Page 6: Starting Chapter 2 K&R. Read ahead.. Call by Value vs Call by Reference Simple variables passed as function parameters in C are actually only copies on](https://reader035.vdocuments.mx/reader035/viewer/2022062805/5697bfd81a28abf838caeb89/html5/thumbnails/6.jpg)
Pointers as Arguments• Must be done with pointers!!!
void exchgint (int *pa, int *pb){
int dummy; dummy = *pa; *pa = *pb; *pb = dummy;
}
![Page 7: Starting Chapter 2 K&R. Read ahead.. Call by Value vs Call by Reference Simple variables passed as function parameters in C are actually only copies on](https://reader035.vdocuments.mx/reader035/viewer/2022062805/5697bfd81a28abf838caeb89/html5/thumbnails/7.jpg)
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]);
![Page 8: Starting Chapter 2 K&R. Read ahead.. Call by Value vs Call by Reference Simple variables passed as function parameters in C are actually only copies on](https://reader035.vdocuments.mx/reader035/viewer/2022062805/5697bfd81a28abf838caeb89/html5/thumbnails/8.jpg)
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
![Page 9: Starting Chapter 2 K&R. Read ahead.. Call by Value vs Call by Reference Simple variables passed as function parameters in C are actually only copies on](https://reader035.vdocuments.mx/reader035/viewer/2022062805/5697bfd81a28abf838caeb89/html5/thumbnails/9.jpg)
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 */}
![Page 10: Starting Chapter 2 K&R. Read ahead.. Call by Value vs Call by Reference Simple variables passed as function parameters in C are actually only copies on](https://reader035.vdocuments.mx/reader035/viewer/2022062805/5697bfd81a28abf838caeb89/html5/thumbnails/10.jpg)
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)”
![Page 11: Starting Chapter 2 K&R. Read ahead.. Call by Value vs Call by Reference Simple variables passed as function parameters in C are actually only copies on](https://reader035.vdocuments.mx/reader035/viewer/2022062805/5697bfd81a28abf838caeb89/html5/thumbnails/11.jpg)
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?
![Page 12: Starting Chapter 2 K&R. Read ahead.. Call by Value vs Call by Reference Simple variables passed as function parameters in C are actually only copies on](https://reader035.vdocuments.mx/reader035/viewer/2022062805/5697bfd81a28abf838caeb89/html5/thumbnails/12.jpg)
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!!
![Page 13: Starting Chapter 2 K&R. Read ahead.. Call by Value vs Call by Reference Simple variables passed as function parameters in C are actually only copies on](https://reader035.vdocuments.mx/reader035/viewer/2022062805/5697bfd81a28abf838caeb89/html5/thumbnails/13.jpg)
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
![Page 14: Starting Chapter 2 K&R. Read ahead.. Call by Value vs Call by Reference Simple variables passed as function parameters in C are actually only copies on](https://reader035.vdocuments.mx/reader035/viewer/2022062805/5697bfd81a28abf838caeb89/html5/thumbnails/14.jpg)
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.
![Page 15: Starting Chapter 2 K&R. Read ahead.. Call by Value vs Call by Reference Simple variables passed as function parameters in C are actually only copies on](https://reader035.vdocuments.mx/reader035/viewer/2022062805/5697bfd81a28abf838caeb89/html5/thumbnails/15.jpg)
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
![Page 16: Starting Chapter 2 K&R. Read ahead.. Call by Value vs Call by Reference Simple variables passed as function parameters in C are actually only copies on](https://reader035.vdocuments.mx/reader035/viewer/2022062805/5697bfd81a28abf838caeb89/html5/thumbnails/16.jpg)
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
![Page 17: Starting Chapter 2 K&R. Read ahead.. Call by Value vs Call by Reference Simple variables passed as function parameters in C are actually only copies on](https://reader035.vdocuments.mx/reader035/viewer/2022062805/5697bfd81a28abf838caeb89/html5/thumbnails/17.jpg)
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
![Page 18: Starting Chapter 2 K&R. Read ahead.. Call by Value vs Call by Reference Simple variables passed as function parameters in C are actually only copies on](https://reader035.vdocuments.mx/reader035/viewer/2022062805/5697bfd81a28abf838caeb89/html5/thumbnails/18.jpg)
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
![Page 19: Starting Chapter 2 K&R. Read ahead.. Call by Value vs Call by Reference Simple variables passed as function parameters in C are actually only copies on](https://reader035.vdocuments.mx/reader035/viewer/2022062805/5697bfd81a28abf838caeb89/html5/thumbnails/19.jpg)
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
![Page 20: Starting Chapter 2 K&R. Read ahead.. Call by Value vs Call by Reference Simple variables passed as function parameters in C are actually only copies on](https://reader035.vdocuments.mx/reader035/viewer/2022062805/5697bfd81a28abf838caeb89/html5/thumbnails/20.jpg)
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
![Page 21: Starting Chapter 2 K&R. Read ahead.. Call by Value vs Call by Reference Simple variables passed as function parameters in C are actually only copies on](https://reader035.vdocuments.mx/reader035/viewer/2022062805/5697bfd81a28abf838caeb89/html5/thumbnails/21.jpg)
Data Types
• Finished K&R Chapter 1 / Now starting Chapter 2• Variable Names• Data Types:
– char– int– short int– long int– float– double
![Page 22: Starting Chapter 2 K&R. Read ahead.. Call by Value vs Call by Reference Simple variables passed as function parameters in C are actually only copies on](https://reader035.vdocuments.mx/reader035/viewer/2022062805/5697bfd81a28abf838caeb89/html5/thumbnails/22.jpg)
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)
![Page 23: Starting Chapter 2 K&R. Read ahead.. Call by Value vs Call by Reference Simple variables passed as function parameters in C are actually only copies on](https://reader035.vdocuments.mx/reader035/viewer/2022062805/5697bfd81a28abf838caeb89/html5/thumbnails/23.jpg)
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
![Page 24: Starting Chapter 2 K&R. Read ahead.. Call by Value vs Call by Reference Simple variables passed as function parameters in C are actually only copies on](https://reader035.vdocuments.mx/reader035/viewer/2022062805/5697bfd81a28abf838caeb89/html5/thumbnails/24.jpg)
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)
![Page 25: Starting Chapter 2 K&R. Read ahead.. Call by Value vs Call by Reference Simple variables passed as function parameters in C are actually only copies on](https://reader035.vdocuments.mx/reader035/viewer/2022062805/5697bfd81a28abf838caeb89/html5/thumbnails/25.jpg)
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)
![Page 26: Starting Chapter 2 K&R. Read ahead.. Call by Value vs Call by Reference Simple variables passed as function parameters in C are actually only copies on](https://reader035.vdocuments.mx/reader035/viewer/2022062805/5697bfd81a28abf838caeb89/html5/thumbnails/26.jpg)
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)
![Page 27: Starting Chapter 2 K&R. Read ahead.. Call by Value vs Call by Reference Simple variables passed as function parameters in C are actually only copies on](https://reader035.vdocuments.mx/reader035/viewer/2022062805/5697bfd81a28abf838caeb89/html5/thumbnails/27.jpg)
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)
![Page 28: Starting Chapter 2 K&R. Read ahead.. Call by Value vs Call by Reference Simple variables passed as function parameters in C are actually only copies on](https://reader035.vdocuments.mx/reader035/viewer/2022062805/5697bfd81a28abf838caeb89/html5/thumbnails/28.jpg)
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
![Page 29: Starting Chapter 2 K&R. Read ahead.. Call by Value vs Call by Reference Simple variables passed as function parameters in C are actually only copies on](https://reader035.vdocuments.mx/reader035/viewer/2022062805/5697bfd81a28abf838caeb89/html5/thumbnails/29.jpg)
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!
![Page 30: Starting Chapter 2 K&R. Read ahead.. Call by Value vs Call by Reference Simple variables passed as function parameters in C are actually only copies on](https://reader035.vdocuments.mx/reader035/viewer/2022062805/5697bfd81a28abf838caeb89/html5/thumbnails/30.jpg)
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
![Page 31: Starting Chapter 2 K&R. Read ahead.. Call by Value vs Call by Reference Simple variables passed as function parameters in C are actually only copies on](https://reader035.vdocuments.mx/reader035/viewer/2022062805/5697bfd81a28abf838caeb89/html5/thumbnails/31.jpg)
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
![Page 32: Starting Chapter 2 K&R. Read ahead.. Call by Value vs Call by Reference Simple variables passed as function parameters in C are actually only copies on](https://reader035.vdocuments.mx/reader035/viewer/2022062805/5697bfd81a28abf838caeb89/html5/thumbnails/32.jpg)
Examples of the Number System
Decimal Octal Hex
31 --------> 037 -----------> 0x1f
128 -------->0200 ----------> 0x80
![Page 33: Starting Chapter 2 K&R. Read ahead.. Call by Value vs Call by Reference Simple variables passed as function parameters in C are actually only copies on](https://reader035.vdocuments.mx/reader035/viewer/2022062805/5697bfd81a28abf838caeb89/html5/thumbnails/33.jpg)
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
![Page 34: Starting Chapter 2 K&R. Read ahead.. Call by Value vs Call by Reference Simple variables passed as function parameters in C are actually only copies on](https://reader035.vdocuments.mx/reader035/viewer/2022062805/5697bfd81a28abf838caeb89/html5/thumbnails/34.jpg)
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)
![Page 35: Starting Chapter 2 K&R. Read ahead.. Call by Value vs Call by Reference Simple variables passed as function parameters in C are actually only copies on](https://reader035.vdocuments.mx/reader035/viewer/2022062805/5697bfd81a28abf838caeb89/html5/thumbnails/35.jpg)
Converting Decimal to Binary• Divide the decimal number successively by 2 and
write down the remainder in binary form:
e.g. 11710
117 1 LSB (after divide by 2, remainder =1)
58 0 (after divide by 2, remainder =0)
29 1 (after divide by 2, remainder =1)
14 0 (after divide by 2, remainder =0)
7 1 (after divide by 2, remainder =1)
3 1 (after divide by 2, remainder =1)
1 1 (after divide by 2, remainder =1)
0 0 MSB
• Read UP and add any leading 0’s: 01110101
odd
even
![Page 36: Starting Chapter 2 K&R. Read ahead.. Call by Value vs Call by Reference Simple variables passed as function parameters in C are actually only copies on](https://reader035.vdocuments.mx/reader035/viewer/2022062805/5697bfd81a28abf838caeb89/html5/thumbnails/36.jpg)
Converting Decimal to Hex• Method 1:
– Convert the decimal number to binary and group the binary digits in groups of 4
e.g. 11710 0111 01012 7516
• Method 2 (shown in HW3):– Divide the decimal number successively by 16 and write down the remainder in hex form: 117 5 LSB (after divide by 16, remainder =5)
7 7 MSB (after divide by 16, remainder =7)
– Read UP and add any leading 0’s: 0x75
![Page 37: Starting Chapter 2 K&R. Read ahead.. Call by Value vs Call by Reference Simple variables passed as function parameters in C are actually only copies on](https://reader035.vdocuments.mx/reader035/viewer/2022062805/5697bfd81a28abf838caeb89/html5/thumbnails/37.jpg)
Converting Binary to Decimal• Treat each bit position n that contains a one as
adding 2n to the value. Ignore zeros because they can’t add anything to the value.
Bit 0 LSB 1 1 (= 20)
Bit 1 0 0
Bit 2 1 4 (= 22)
Bit 3 1 8 (= 23)
Bit 4 0 0
Bit 5 1 32 (= 25)
Bit 6 0 0
Bit 7 MSB 0 0
Total 45
![Page 38: Starting Chapter 2 K&R. Read ahead.. Call by Value vs Call by Reference Simple variables passed as function parameters in C are actually only copies on](https://reader035.vdocuments.mx/reader035/viewer/2022062805/5697bfd81a28abf838caeb89/html5/thumbnails/38.jpg)
Converting Hex to Decimal
• Treat each digit n as adding 16n to the value. Ignore zeros because they can’t add anything to the value.
Digit 0 LSB 0 0
Digit 1 2 32 (= 2 * 161)
Digit 2 b 2816 (= 11 * 162)
Digit 3 0 0
Digit 4 0 0
Digit 5 1 1048576 (= 1 * 165)
Digit 6 0 0
Digit 7 MSB 0 0
Total 1051424
![Page 39: Starting Chapter 2 K&R. Read ahead.. Call by Value vs Call by Reference Simple variables passed as function parameters in C are actually only copies on](https://reader035.vdocuments.mx/reader035/viewer/2022062805/5697bfd81a28abf838caeb89/html5/thumbnails/39.jpg)
Base for Integer Constants
• Designating the base for an integer constant
• If constant begins with either:0x It is Hex with a-f as Hex digits
0X It is Hex with A-F as Hex digits
• Otherwise, if constant begins with0 It is Octal
• Otherwise, it is decimal
![Page 40: Starting Chapter 2 K&R. Read ahead.. Call by Value vs Call by Reference Simple variables passed as function parameters in C are actually only copies on](https://reader035.vdocuments.mx/reader035/viewer/2022062805/5697bfd81a28abf838caeb89/html5/thumbnails/40.jpg)
Base for Character Constants
• Designating the base for a character constant• If constant begins with either:
‘\x It is Hex with 0-9 and a-f as Hex digits
‘\X It is Hex with 0-9 and A-F as Hex digits
• Otherwise, if constant begins with‘\0 It is Octal
• Otherwise, it is the ASCII code for a character
‘a’
![Page 41: Starting Chapter 2 K&R. Read ahead.. Call by Value vs Call by Reference Simple variables passed as function parameters in C are actually only copies on](https://reader035.vdocuments.mx/reader035/viewer/2022062805/5697bfd81a28abf838caeb89/html5/thumbnails/41.jpg)
Constants• Character and Integer Constants are Signed!
– Sign bit (MSB) not set
‘\x55’ equals an 8-bit quantity 01010101
when casted to an int, it equals 0000 … 01010101
0x55 equals a 32-bit quantity 0000 … 01010101
– Sign bit (MSB) set
‘\xaa’ equals an 8-bit quantity 10101010
when casted to an int, it equals 1111 … 10101010
0xaa equals a 32 bit quantity 0000 … 10101010– Note: None of the ASCII codes (x00 - x7f) have sign bit set!
![Page 42: Starting Chapter 2 K&R. Read ahead.. Call by Value vs Call by Reference Simple variables passed as function parameters in C are actually only copies on](https://reader035.vdocuments.mx/reader035/viewer/2022062805/5697bfd81a28abf838caeb89/html5/thumbnails/42.jpg)
Signed (Default) Behavior• Careful mixing modes when initializing variables!
int i; (signed behavior is default)
char c; (signed behavior is default)
i = 0xaa; (== 000000aa) as intended
i = ‘\xaa’; (== ffff ffaa) sign extends!
c = ‘\xaa’; (== aa) as intended
i = c; (==ffff ffaa) sign extends!
char
int
Sign Bit Extension1
11111111 11111111 11111111 1
0101010
0101010
![Page 43: Starting Chapter 2 K&R. Read ahead.. Call by Value vs Call by Reference Simple variables passed as function parameters in C are actually only copies on](https://reader035.vdocuments.mx/reader035/viewer/2022062805/5697bfd81a28abf838caeb89/html5/thumbnails/43.jpg)
Unsigned Behavior• Careful mixing modes when initializing variables!
unsigned int i; (must specify unsigned if wanted)
unsigned char c; (must specify unsigned if wanted)
i = 0xaa; (== 000000aa) as intended
i = ‘\xaa’; (== ffffffaa) char sign extends!
c = ‘\xaa’; (== aa) as intended
i = c; (==0000 00aa) char sign not extended!
char
int
Sign Bit Extension1
11111111 11111111 11111111 1
0101010
0101010
![Page 44: Starting Chapter 2 K&R. Read ahead.. Call by Value vs Call by Reference Simple variables passed as function parameters in C are actually only copies on](https://reader035.vdocuments.mx/reader035/viewer/2022062805/5697bfd81a28abf838caeb89/html5/thumbnails/44.jpg)
Example to illustrate signed/unsigned typesvoid copy_characters(void){
char ch;
while ((ch =getchar()) != EOF)
putchar(ch);
}
If getchar() == EOF, is this true?
What happens if ch is defined as
unsigned char? Is this true?
Changing the declaration of ch into int ch; makes it work.
yes No
![Page 45: Starting Chapter 2 K&R. Read ahead.. Call by Value vs Call by Reference Simple variables passed as function parameters in C are actually only copies on](https://reader035.vdocuments.mx/reader035/viewer/2022062805/5697bfd81a28abf838caeb89/html5/thumbnails/45.jpg)
One’s ComplementTwo’s Complement
• One’s Complement Character Arithmetic~ is the one’s complement operator~ flips the value of each bit in the dataAll zeroes become one, All ones become zero~ ‘\xaa’ == ‘\x55’~10101010 == 01010101
• Number anded with its one’s complement = 010101010
& 0101010100000000
![Page 46: Starting Chapter 2 K&R. Read ahead.. Call by Value vs Call by Reference Simple variables passed as function parameters in C are actually only copies on](https://reader035.vdocuments.mx/reader035/viewer/2022062805/5697bfd81a28abf838caeb89/html5/thumbnails/46.jpg)
One’s ComplementTwo’s Complement
• Two’s Complement Character Arithmetic- is the two’s complement operator- flips the value of each bit in the data and adds 1It creates the negative of the data value- ‘\x55’ == ‘\xab’- 01010101 == 10101011
• Number added to its two’s complement = 001010101
+ 10101011 (1) 00000000 (carry out of MSB is dropped)
![Page 47: Starting Chapter 2 K&R. Read ahead.. Call by Value vs Call by Reference Simple variables passed as function parameters in C are actually only copies on](https://reader035.vdocuments.mx/reader035/viewer/2022062805/5697bfd81a28abf838caeb89/html5/thumbnails/47.jpg)
Two Special Case Values
• char 0 (or zero of any length)-00000000 = 11111111
+ 1= 00000000
• char -27 (or -2n-1 for any length = n)-10000000 = 01111111
+ 1= 10000000
![Page 48: Starting Chapter 2 K&R. Read ahead.. Call by Value vs Call by Reference Simple variables passed as function parameters in C are actually only copies on](https://reader035.vdocuments.mx/reader035/viewer/2022062805/5697bfd81a28abf838caeb89/html5/thumbnails/48.jpg)
Bit Manipulation
• Bitwise Operators: ~ one’s complement (unary not)& and| or ^ xor (exclusive or)<< left shift>> right shift
• Lots of possible Exam questions here!
![Page 49: Starting Chapter 2 K&R. Read ahead.. Call by Value vs Call by Reference Simple variables passed as function parameters in C are actually only copies on](https://reader035.vdocuments.mx/reader035/viewer/2022062805/5697bfd81a28abf838caeb89/html5/thumbnails/49.jpg)
Binary Logic Tables
AND 0 1
0
1 1
0
0
0NOT
0
0
1
1
OR 0 1
0
1 1
0
1
1
ADD 0 1
0
1 0 Carry 1
0
1
1
XOR 0 1
0
1
10
01Operands
Results
![Page 50: Starting Chapter 2 K&R. Read ahead.. Call by Value vs Call by Reference Simple variables passed as function parameters in C are actually only copies on](https://reader035.vdocuments.mx/reader035/viewer/2022062805/5697bfd81a28abf838caeb89/html5/thumbnails/50.jpg)
Bit Manipulationunsigned char n = ‘\xa6’;
n 10100110
~n 01011001 (1s complement: flip bits)
n | ‘\x65’ 10100110 turn on bit in result if | 01100101 on in either operand
11100111
![Page 51: Starting Chapter 2 K&R. Read ahead.. Call by Value vs Call by Reference Simple variables passed as function parameters in C are actually only copies on](https://reader035.vdocuments.mx/reader035/viewer/2022062805/5697bfd81a28abf838caeb89/html5/thumbnails/51.jpg)
Bit Manipulations
n & ‘\x65’ 10100110 turn on bit in result if
| 01100101 on in both operands
00100100
n ^ ‘\x65’ 10100110 turn on bit in result if
| 01100101 on in exactly 1 operand
11000011
![Page 52: Starting Chapter 2 K&R. Read ahead.. Call by Value vs Call by Reference Simple variables passed as function parameters in C are actually only copies on](https://reader035.vdocuments.mx/reader035/viewer/2022062805/5697bfd81a28abf838caeb89/html5/thumbnails/52.jpg)
Bit Manipulations n = ‘\x18’; 00011000 (Remember n is unsigned)
n << 1 00110000 shift 1 to left (like times 2)
n << 2 01100000 shift 2 to left (like times 4)
n << 4 10000000 shift 4 to left
(bits disappear off left end)
n >> 2 00000110 shift 2 to right (like / 4)
n >> 4 00000001 shift 4 to right
(bits disappear off right end)
Unsigned Right Shift 0
![Page 53: Starting Chapter 2 K&R. Read ahead.. Call by Value vs Call by Reference Simple variables passed as function parameters in C are actually only copies on](https://reader035.vdocuments.mx/reader035/viewer/2022062805/5697bfd81a28abf838caeb89/html5/thumbnails/53.jpg)
Bit Manipulations
• Right shift result may be different if n is signed! – If value of n has sign bit = 0, works same as last slide– If value of n has sign bit = 1, works differently!!
char n = ‘\xa5’; (default is signed)n 10100101 (sign bit is set)n >>2 11101001 (bring in 1’s from left)
• Bringing in extra copies of the sign bit on the left is also called "sign extension"
Signed Right Shift
![Page 54: Starting Chapter 2 K&R. Read ahead.. Call by Value vs Call by Reference Simple variables passed as function parameters in C are actually only copies on](https://reader035.vdocuments.mx/reader035/viewer/2022062805/5697bfd81a28abf838caeb89/html5/thumbnails/54.jpg)
Bit Manipulations
• For signed variable, negative value shifted right by 2 or 4 is still a negative value
‘\xa5’ =10100101
‘\xa5’ >> 2 = 11101001 = ‘\xe9’
• Same result as divide by 4 (22 = 4)
• But, this is not true on all machines
• See K&R pg. 49, lines 8-10.
![Page 55: Starting Chapter 2 K&R. Read ahead.. Call by Value vs Call by Reference Simple variables passed as function parameters in C are actually only copies on](https://reader035.vdocuments.mx/reader035/viewer/2022062805/5697bfd81a28abf838caeb89/html5/thumbnails/55.jpg)
Bit Manipulations
• When dividing a negative value– Different rounding rules than for positive value– Remainder must be negative - not positive
• Note that (-1)/2 = -1
• Note that -(1/2) = 0
![Page 56: Starting Chapter 2 K&R. Read ahead.. Call by Value vs Call by Reference Simple variables passed as function parameters in C are actually only copies on](https://reader035.vdocuments.mx/reader035/viewer/2022062805/5697bfd81a28abf838caeb89/html5/thumbnails/56.jpg)
Forcing Groups of Bits Off• Given char n, how to turn off all bits except
the least significant 5 bits: n = n & ‘\x1f’
n = ‘\xa5’ 10100101
n & ‘\x1f’ 10100101
& 00011111 turn off all bits
00000101 except bottom 5
• Called "masking" the bits -- only see bits on in result where 1's found in mask value
![Page 57: Starting Chapter 2 K&R. Read ahead.. Call by Value vs Call by Reference Simple variables passed as function parameters in C are actually only copies on](https://reader035.vdocuments.mx/reader035/viewer/2022062805/5697bfd81a28abf838caeb89/html5/thumbnails/57.jpg)
Forcing Groups of Bits Off
• x = x & ~077 (octal for a change)
Sets least significant 6 bits in x to 0
Even if you don't know size of x (e.g. size of int) ~077 = ~00 . . . 00111111
= 11 . . . 11000000 of required size
Extends itself with 1 bits on left for length of x
![Page 58: Starting Chapter 2 K&R. Read ahead.. Call by Value vs Call by Reference Simple variables passed as function parameters in C are actually only copies on](https://reader035.vdocuments.mx/reader035/viewer/2022062805/5697bfd81a28abf838caeb89/html5/thumbnails/58.jpg)
Forcing Groups of Bits On
• Given n, how to turn on the MS two bits (if already on, leave on). n = n | ‘\xc0’
n = '\xa5'
n | '\xc0': 10100101
| 11000000 turn on MS 2 bits
11100101
![Page 59: Starting Chapter 2 K&R. Read ahead.. Call by Value vs Call by Reference Simple variables passed as function parameters in C are actually only copies on](https://reader035.vdocuments.mx/reader035/viewer/2022062805/5697bfd81a28abf838caeb89/html5/thumbnails/59.jpg)
“Encryption” with Exclusive Or
• Show that x ^ (x ^ y) == y
char y =‘\xa5’ 10100101 (plain text bits)
char x =‘\x69’ 01101001 (encryption key)
x ^ y 11001100 (cipher text bits)
x ^ (x ^ y) 10100101 (decrypted bits)
Same as original value of y!
![Page 60: Starting Chapter 2 K&R. Read ahead.. Call by Value vs Call by Reference Simple variables passed as function parameters in C are actually only copies on](https://reader035.vdocuments.mx/reader035/viewer/2022062805/5697bfd81a28abf838caeb89/html5/thumbnails/60.jpg)
String Constants• String constant: “I am a string.”
– An array (a pointer to a string) of char values somewhere ending with NUL = '\0', the char with zero value.
– "0" is not same as '0'. The value "0" can't be used in an expression - only in arguments to functions like printf().
• Also have string functions:
See pg. 241, Appendix B and B3, pg. 249
#include <string.h>
With these definitions, can use: len = strlen(msg);
where msg is string in a string array
• NOTE: Write your own string functions for homework!!
![Page 61: Starting Chapter 2 K&R. Read ahead.. Call by Value vs Call by Reference Simple variables passed as function parameters in C are actually only copies on](https://reader035.vdocuments.mx/reader035/viewer/2022062805/5697bfd81a28abf838caeb89/html5/thumbnails/61.jpg)
Enumeration Symbolic Constants
• enum boolean {FALSE, TRUE};– Enumerated names assigned values starting from 0
• FALSE = 0• TRUE = 1
• Now can declare a variable of type enum boolean:enum boolean x;
x = FALSE;
• Just a shorthand for creating symbolic constants instead of with #define statements
• Storage requirement is the same as int
![Page 62: Starting Chapter 2 K&R. Read ahead.. Call by Value vs Call by Reference Simple variables passed as function parameters in C are actually only copies on](https://reader035.vdocuments.mx/reader035/viewer/2022062805/5697bfd81a28abf838caeb89/html5/thumbnails/62.jpg)
Enumeration Symbolic Constants
• If you define months as enum type
enum months {ERR, JAN, FEB, MAR,
APR, MAY, JUN, JUL,
AUG, SEP, OCT, NOV,
DEC};
• Debugger might print value 2 as FEB
![Page 63: Starting Chapter 2 K&R. Read ahead.. Call by Value vs Call by Reference Simple variables passed as function parameters in C are actually only copies on](https://reader035.vdocuments.mx/reader035/viewer/2022062805/5697bfd81a28abf838caeb89/html5/thumbnails/63.jpg)
Code Example of the enum typeint main()
{
enum month {ERR, JAN, FEB, MAR, APR, MAY, JUN,
JUL, AUG, SEP, OCT, NOV, DEC};
enum month this_month;
this_month = FEB;
…
…
}
![Page 64: Starting Chapter 2 K&R. Read ahead.. Call by Value vs Call by Reference Simple variables passed as function parameters in C are actually only copies on](https://reader035.vdocuments.mx/reader035/viewer/2022062805/5697bfd81a28abf838caeb89/html5/thumbnails/64.jpg)
const• "const" declaration is like "final" in Java
– warns compiler that variable value shouldn't change const char msg[ ] = "Warning: . . .";
– Commonly used for function arguments int copy(char to[ ], const char from[ ]);
If logic of the copy function attempts to modify the “from” string, compiler will give a warning
• Exact form of warning and actual behavior of the code is installation defined
![Page 65: Starting Chapter 2 K&R. Read ahead.. Call by Value vs Call by Reference Simple variables passed as function parameters in C are actually only copies on](https://reader035.vdocuments.mx/reader035/viewer/2022062805/5697bfd81a28abf838caeb89/html5/thumbnails/65.jpg)
Operators• Arithmetic Operators:
+ Add- Subtract* Multiply/ Divide% Modulo (Remainder after division ) e.g. 5%7 = 5 7%7 = 0 10%7 = 3
• Examples: int x, y; x / y truncates (no fractional part) x % y is the remainder when x is divided by y. Always true that: x == y*(x/y) + x%y
![Page 66: Starting Chapter 2 K&R. Read ahead.. Call by Value vs Call by Reference Simple variables passed as function parameters in C are actually only copies on](https://reader035.vdocuments.mx/reader035/viewer/2022062805/5697bfd81a28abf838caeb89/html5/thumbnails/66.jpg)
Operators• Logical Operators:
&& logical and|| logical or! Not
• Example:…
int year; if ((year % 4 == 0 && year % 100 != 0) || year % 400 == 0)
printf( "%d is a leap year\n", year); else
printf( "%d is not a leap year\n", year);
• Why are no inner parentheses needed?See precedence table, P 53. Good questions for exams!!
![Page 67: Starting Chapter 2 K&R. Read ahead.. Call by Value vs Call by Reference Simple variables passed as function parameters in C are actually only copies on](https://reader035.vdocuments.mx/reader035/viewer/2022062805/5697bfd81a28abf838caeb89/html5/thumbnails/67.jpg)
Precedence and Associativity of Operators
( ) [ ] -> . Left to right! ~ ++ - - + - * & (type) sizeof right to left* / % left to right+ - left to right<< >> left to right< <= > >= left to right= = != left to right& left to right^ left to right| left to right&& left to right|| left to right?: right to left= += -= *= /= %= &= ^= |= <<= >>= right to left, left to right
Pre
cede
nce
sign dereference address casting Associativity
![Page 68: Starting Chapter 2 K&R. Read ahead.. Call by Value vs Call by Reference Simple variables passed as function parameters in C are actually only copies on](https://reader035.vdocuments.mx/reader035/viewer/2022062805/5697bfd81a28abf838caeb89/html5/thumbnails/68.jpg)
Precedence and Associativity
• Precedence– Operators in the same row have the same precedence
– Operators are in order of decreasing precedence
• Associativity– Determine the order if the operators have the same
precedence
– e.g
x = y +=z -= 4 means
x = y +=(z -= 4)
x =(y +=(z -= 4))
![Page 69: Starting Chapter 2 K&R. Read ahead.. Call by Value vs Call by Reference Simple variables passed as function parameters in C are actually only copies on](https://reader035.vdocuments.mx/reader035/viewer/2022062805/5697bfd81a28abf838caeb89/html5/thumbnails/69.jpg)
Relations / Comparisons
• We call a comparison between two arithmetic expressions a "relation" ae1 <= ae2 (Comparisons: <, <=, = =, !=, >=, > )
• A relation is evaluated as true or false (1 or 0) based on values of given arithmetic expressions
• if ( i < lim-1 = = j < k) – What's it mean? – See precedence table P 53
• Instead of c != EOF, could write !(c = = EOF)