1. First Program

2.  The type of all data used in a C program must be specified  A data type is a description of the data being represented ▪ That is, a set of possible values and a set of operations on those values  There are many different C types  So far we’ve only seen ints and floats ▪ Which represent different types of numbers

3.  Integers are whole numbers  Like 1, 7, 23567, -478  There are numerous different integer types ▪ int, short, long, long long, unsigned int ▪ These types differ by size, and whether or not negative numbers can be represented  Floating point numbers can have fractional parts  Such as 234.65, -0.322, 0.71, 3.14159  There are also different floating point types ▪ double, float, long double

4.  In addition to numbers it is common to represent text  Text is made up of character sequences ▪ Often not just limited to a-z and A-Z  The char type represents single characters  To distinguish them from identifiers, characters are placed in single quotes ▪ char ch = 'a'  Remember that strings are in ""s

5.  Boolean values represent the logical values true and false  These are used in conditions to make decisions  In C the _Bool type represents Boolean values  The value 1 represents true, and the value 0 represents false

6.  Numeric values (and _Bool values) do not have to be distinguished from identifiers  Identifiers cannot start with a number or a –  Representing large amounts of text with single characters would be cumbersome  Text enclosed in ""s is referred to as a string ▪ A sequence of characters ▪ More on this later...

7.  The purpose of a variable is to store data  The type of a variable describes what kind of data is being stored  An int stores whole numbers  A char stores a single character  And so on  Why do we have to specify the type?

8.  When we communicate we generally don’t announce the type of data that we are using  Since we understand the underlying meaning of the words we use in speech, and  The symbols we use are unambiguous  For example, do these common symbols represent words or numbers?  eagle  256

9.  A computer has a much more limited system for representation  Everything has to be represented as a series of binary digits  That is 0s and 1s  What does this binary data represent?  0110 1110 1111 0101 0001 1101 1110 0011  It could be an integer, a float or a string ▪ But there is no way to determine this just by looking at it

11.  A single binary digit, or bit, is a single 0 or 1  bit = binary digit  Collections of bits of various sizes  byte – eight bits, e.g. 0101 0010  kB – kilobyte = 2 10 bytes = 1,024 bytes = 8,192 bits  MB – megabyte = 2 20 bytes = 1,048,576 bytes ▪ = 8,388,608 bits  GB – gigabyte = 2 30 bytes = 1,073,741,824 bytes ▪ = 8,589,934,592 bits  TB – terabyte = 2 40 bytes

12.  Modern computer architecture uses binary to represent numerical values  Which in turn represent data whether it be numbers, words, images, sounds,...  Binary is a numeral system that represents numbers using two symbols, 0 and 1  Whereas decimal is a numeral system that represents numbers using 10 symbols

13.  We usually count in base 10 (decimal)  But we don’t have to, we could use base 8, 16, 13, or 2 (binary)  What number does 101 represent?  It all depends on the base (or radix) used – in the following examples the base is shown as a subscript to the number  101 10 = 101 10 (wow!) ▪ i.e. 1*10 2 + 0*10 1 + 1*10 0 = 100 + 0 + 1 = 101  101 8 = 65 10 ▪ i.e. 1*8 2 + 0*8 1 + 1*8 0 = 64 + 0 + 1 = 65  101 16 = 257 10 ▪ i.e. 1*16 2 + 0*16 1 + 1*16 0 = 256 + 0 + 16 = 257  101 2 = 5 10 ▪ i.e. 1*2 2 + 0*2 1 + 1*2 0 = 4 + 0 + 1 = 5

14.  What does 12,345 10 represent?  1*10 4 + 2*10 3 + 3*10 2 + 4*10 1 + 5*10 0  Or 12,345 16 ?  1*16 4 + 2*16 3 + 3*16 2 + 5*16 1 + 5*16 0 = 74,565 10  And what about 11,001 2 ?  1*2 4 + 1*2 3 + 0*2 2 + 0*2 1 + 1*2 0 = 25 10  The digit in each column is multiplied by the base raised to the power of the column number  Counting from zero, the right-most column

15. base 1010 4 (10,000)10 3 (1,000)10 2 (100)10 1 (10)10 0 (1) 12,34512345 base 1616 4 (65,536)16 3 (4,096)16 2 (256)16 1 (16)16 0 (1) 12,34512345 base 22 4 (16)2 3 (80)2 2 (4)2 1 (2)2 0 (1) 11,00111001

17.  There is an obvious way to represent whole numbers in a computer  Just convert the number to binary, and record the binary number in the appropriate bits in RAM  However there are two broad sets of whole numbers  Unsigned numbers ▪ Which must be positive  Signed numbers ▪ Which may be positive or negative

18.  Any variable type has a finite size  This size sets an upper limit of the size of the numbers that can be stored  The limit is dependent on how the number is represented  Attempts to store values that are too large will result in an error  The exact kind of error depends on what operation caused the overflow

19. JJust convert the number to binary and store it HHow large a positive number can be represented in 32 bits? 11111 1111 1111 1111 1111 1111 1111 1111 oor 4,294,967,295 10 September 2004John Edgar19 2 29 = 536,870,912 + … 2 30 = 1,073,741,824 + 2 31 = 2,147,483,648 +

20.  Binary addition can be performed in the same way as decimal addition  Though 1 2 + 1 2 = 10 2  and 1 2 + 1 2 + 1 2 = 11 2  But how do we perform subtraction, and how do we represent negative numbers?  Since a – sign isn't a 1 or a 0 … 10000133 +011101+29 11111062

21.  Our only unit of storage is bits  So the fact that a number is negative has to somehow be represented as a bit value  i.e. as a 1 or a 0  How would you do it?  We could use one bit to indicate the sign of the number, signed integer representation

22.  Keep one bit (the left-most) to record the sign  0 means – and 1 means +  But this is not a good representation  It wastes a bit (the sign bit) and  Has two representations of zero  It requires special logic to deal with the sign bit and ▪ It makes implementing subtraction difficult and  For reasons related to hardware efficiency we would like to avoid performing subtraction entirely

23.  There is an alternative way of representing negative numbers called radix complement  That avoids using a negative sign!  To calculate the radix complement you need to know the maximum size of the number  That is, the maximum number of digits that a number can have  And express all numbers using that number of digits ▪ e.g. with 4 digits express 23 as 0023

24. NNegative numbers are represented as the complement of the positive number TThe complement of a number, N, in n digit base b arithmetic is: b n – N. LLet’s look at two base 10 examples, one using 2 digit arithmetic, and one 3 digit arithmetic ccomplement of 24 in two digit arithmetic is: ▪ 10 2 – 24 = 76 ccomplement of 024 in three digit arithmetic is: 0 3 – 24 = 976

25. CComplements can be used to do subtraction IInstead of subtracting a number add its complement aand ignore any number past the maximum number of digits LLet’s calculate 49 – 17 using complements: WWe add 49 to the complement of 17 ▪T▪The complement of 17 is 83 449 + 83 = 132, ignore the 1, and we get 32

26. WWhat did we just do? TThe complement of 17 in 2 digit arithmetic is 100 – 17 = 83 AAnd we ignored the highest order digit TThe 100 in 132 (from 49 + 83 = 132) TThat is, we took it away, or subtracted it SSo in effect 49 + complement(17) equals: 449 + (100 – 17) – 100 or 449 – 17

27. SSo it looks like we can perform subtraction by just doing addition (using the complement) BBut there might be a catch here – what is it? TTo find the complement we had to do subtraction! bbut let’s go back to binary again

28.  In binary we can calculate the complement in a special way without doing any subtraction  Pad the number with 0s up to the number of digits  Flip all of the digits (1's become 0, 0's become 1's)  Add 1  Let's calculate 6 – 2 in 4 digit 2's complement arithmetic then check that it is correct  Note: no subtraction will be used!

29. Base 10Flip BitsAdd 1Base 10 0000111(1)0000 001+1110111 010+2101110-2 011+3100101-3 100-4011100-4 101-3010011+3 110-2001010+2 111000001+1

30. 6 in binary 2 in binary 0110 0010 flip the bits add 1 add it to 6 result ignore left digit 1101 1110 + 10100 0110 =0100  Calculate 6 – 2 in binary using 2’s complement in 4 digit arithmetic  The answer should be 4, or 0100 in binary  Remember that a number has to be padded with zeros up to the number of digits (4 in this case) before flipping the bits

31.  32 bits is 2 * 31 bits  We can use 31 - 1 bits for the positive numbers,  31 bits for the negative numbers, and  1 bit for zero  A range of 2,147,483,647 to –2,147,483,648  2 31 – 1 positive numbers,  2 31 negative numbers  and 0

32.  To add two numbers x + y  If x or y is negative calculate its 2’s complement  Add the two numbers  Check for overflow ▪ If both numbers have the same sign, ▪ But the result is a different sign then, ▪ There is overflow and the resulting number is too big to be represented!  To subtract one number from another x - y  Calculate x + 2’s complement (y)

33.  Here are examples of signed integers  short (16 bits) ▪ −32,768 to +32,767  int (32 bits) ▪ −2,147,483,648 to +2,147,483,647  long long (64 bits) ▪ −9,223,372,036,854,775,808 to +9,223,372,036,854,775,807

34.  It is not possible to represent every floating point number within a certain range  Floating point numbers can be represented by a mantissa and an exponent  e.g. 1.24567 * 10 3, or 1,245.67  mantissa = 0.124567  exponent = 4

35.  The mantissa and exponent are represented by some number of bits  Dependent on the size of the type  The represented values are evenly distributed between 0 and 0.999...  Consider a 32 bit (4 byte) float  mantissa: 23 bits  exponent: 8 bits  sign bit: 1 bit

36.  There are only two Boolean values  True  False  Therefore only one bit is required to represent Boolean data  0 represents false  1 represents true

37.  How many characters do we need to represent?  A to Z, a to z, 0 to 9, and  `!@#$%^&*()-=_+[]{}\|;’:”./?  So how many bits do we need?  26 + 26 + 10 + 31 = 93

38.  Each character can be given a different value if represented in an 8 bit code  so 2 8 or 256 possible codes  This code is called ASCII  American Standard Code for Information Interchange  e.g. m = 109, D = 68, 0 = 111

39.  Unicode is an alternative to ASCII  It can represent thousands of symbols  This allows characters from other alphabets to be represented

40.  To represent a string use a sequence made up of the codes for each character  So the string representing Doom would be:  01000100 01101111 01101111 01101101 ▪ 01000100 2 = 68 10 which represents D ▪ 01101111 2 = 111 10 which represents o ▪ 01101101 2 = 109 10 which represents m  There is more to this as we will discover later

41.  Remember this number from the last slide?  01000100 01101111 01101111 01101101  That represented “Doom” – or did it?  Maybe it is actually an integer! ▪ In which case it represents the number 1,148,153,709  This is why C needs to keep track of types to know what the bits actually represent

43.  When a program runs it requires main memory (RAM) space for  Program instructions (the program)  Data required for the program  There needs to be a system for efficiently allocating memory  We will only consider how memory is allocated to program data (variables) code storage data storage

44.  We will often refer to main memory  By which we mean RAM or random-access memory  RAM is both readable and writable  RAM can be thought of as a (very long) sequence of bits  In this simplified model we will number this sequence in bytes

45.  RAM is a long sequence of bytes  Starting with 0  Ending with the amount of main memory (-1)  RAM is addressable and supports random access  That is, we can go to byte 2,335,712 without having to visit all the preceding bytes

46. 012345678 …10737418161073741817107374181810737418191073741820107374182110737418221073741823 *1 GB = 1,073,741,824 bytes Consider a computer with 1GB * of RAM This is a simplified and abstract illustration 910111213141516… RAM can be considered as a sequence of bytes, addressed by their position

47.  Declaring a variable reserves space for the variable in main memory  The amount of space is determined by the type  The name and location of variables are recorded in the symbol table  The symbol table is also stored in RAM  The symbol table allows the program to find the address of variables ▪ We will pretty much ignore it from now on!

48. data address204820492050205120522053205420552056205720582059206020612062... For simplicity's sake assume that each address is in bytes and that memory allocated to the program starts at byte 2048 int x, y; x = 223; x = 17; Creates entries in the symbol table for x and y data address204820492050205120522053205420552056205720582059206020612062... data223 address204820492050205120522053205420552056205720582059206020612062... data17 address204820492050205120522053205420552056205720582059206020612062... These lines change the values stored in x and y, but do not change the location or amount of main memory that has been allocated variableaddress x2048 y2052 y = 3299; data173299 address204820492050205120522053205420552056205720582059206020612062...

49.  There are two things that we might wish to find out about a variable  Most of the time we just want to find what value is stored in a variable  By the end of the previous example the variable x had the value 17 stored in it  Sometimes we* might want to know where a variable is located – its address  The address of x was 2,048 ▪ *OK, we probably don’t want to know this, but a program might need this information

50.  Variables are stored in main memory in sequence  We can find out the value of a variable  And its address ▪ To retrieve the address write the variable name preceded by an ampersand (&)  The value of a variable can be changed by assignment  But its storage location and the amount of memory allocated to a variable cannot change

51.  We can use the printf function to print the value of a variable, or its address  int x = 12;  printf("x = %d, ", x);  printf("the address of x is %d", &x);  Here is another example  float y = 2.13;  printf(“y = %f, ", y);  printf("the address of y is %d", &y); I wouldn't usually use x or y as the name of a variable since it doesn't convey any meaning, but in this example they are just arbitrary values Note the use of %f to print a floating point value, and also note that the address of y is still an integer so its format specification is still %d