CPS120: Introduction to Computer Science

1
CPS120 Introduction to Computer Science

• Lecture 8

2
Comparing the Conventions
3
Sign-magnitude Operations

• Addition of two numbers in sign-magnitude is
  carried out using the usual conventions of binary
  arithmetic
• If both numbers are the same sign, we add their
  magnitude and copy the same sign
• If different signs, determine which number has
  the larger magnitude and subtract the other from
  it. The sign of the result is the sign of the
  operand with the larger magnitude
• If the result is outside the bounds of 2 n1 to
  2 n-1 1, an overflow results

4
Twos Complement Convention

• A positive number is represented using a
  procedure similar to sign-magnitude
• To express a negative number
• Express the absolute value of the number in
  binary
• Change all the zeros to ones and all the ones to
  zeros (called complementing the bits)
• Add one to the number obtained in Step 2
• The range of negative numbers is one larger than
  the range of positive numbers
• Given a negative number, to find its positive
  counterpart, use steps 2 3 above

5
Twos Complement Operations

• Addition
• Treat the numbers as unsigned integers
• The sign bit is treated as any other number
• Ignore any carry on the leftmost position
• Subtraction
• Treat the numbers as unsigned integers
• If a "borrow" is necessary in the leftmost place,
  borrow as if there were another invisible
  one-bit to the left of the minuend

6
Overflows in Twos Complement

• The range of values in twos-complement is 2
  n1 to 2 n-1 1
• Results outside this band are overflows
• In all overflow conditions, the sign of the
  result of the operation is different than that of
  the operands
• If the operands are positive, the result is
  negative
• If the operands are negative, the result is
  positive

7
Ones Complement

• Devised to make the addition of two numbers with
  different signs the same as two numbers with the
  same sign
• Positive numbers are represented in the usual way
• For negatives
• STEP 1 Start with the binary representation of
  the absolute value
• STEP 2 Complement all of its bits

8
One's Complement Operations

• Treat the sign bit as any other bit
• For addition, carry out of the leftmost bit is
  added to the rightmost bit end-around carry

9
Error Detection Even Parity

• Bytes Transmitted
• 01100011
• 11100001
• 01110100
• 11110011
• 00000101 Parity Block
• B
• I
• T

• Bytes Received
• 01100011
• 11100001
• 11111100
• 11110011
• 00000101 Parity Block
• B
• I
• T

10
A Simple C Program

• Comments //Simple C Program
• //
• // Purpose To demonstrate the
• // parts of a simple C program
• Compiler Directive include ltiostream.hgt
• Main Function main ( )
• Braces
• Statements cout ltlt "This is a simple program
  "
• return 0

11
Sample Comments
At the start of the program /
Miles Per
Gallon Programmer Paul J.
Millis Purpose Calculate mile per
gallon and price per mile given miles,
gallons and gas price
/
Within specific lines of code float PricePerMile
0.00 //store the price per mile float
MilesPerGallon 0.0 //stores the miler per
gallon achieved
12
Compiler Directives

• Instructions to the compiler rather than part of
  the C language
• Most common directive is include
• For Example include ltiostream.hgt
• A .h file is a header file. It serves as a link
  between program code and standard C code needed
  to make programs run

13
Functions

• A function is a block of code that carries out a
  specific task
• Every C program has a main function that
  executes when a program initiates
• Includes open parenthesis to designate a function
• Ends with a return 0 statement

14
Braces

• Mark the beginning and ending of blocks of
  related code
• Every opening brace must have a closing brace

15
Semicolons

• There must be a semicolon after every statement
• To tell the compiler that the statement is
  complete
• Function definitions and compiler directives are
  exempt

16
Uppercase or Lowercase

• Be careful to use the same combination of
  uppercase or lowercase lettering when you enter
  source code
• Commands and other reserved words are all lower
  case

17
Variables

• Used to store values in virtually every computer
  program
• Used for remembering things during program
  execution
• Variables have names, types and values
• Values can change during execution

18
Data Types - Whole Numbers

• To store whole numbers in a variable, we use a
  variable of the int data type.
• An int variable uses 4 bytes of memory.
• An int variable can store a number as low as
  -2,147,483,648.
• An int variable can store a number as high as
  2,147,483,647.

19
Data Types - Decimal Numbers

• To store decimal numbers in a variable, we use a
  variable of the double data type
• A double variable uses 8 bytes of memory
• A double variable can store a number as low as
  -1.7 x 10308
• A double variable can store a number as high as
  1.7 x 10308
• A double variable can store a number with up to
  15 digits of precision (significant digits)

20
Data Types - Characters

• To store a letter or a single character (such as
  , , , etc.), we use a variable of the char
  data type.
• A char variable only uses 1 byte of memory.
• A char variable can only hold one letter, digit,
  or character.

21
Data Types Words / Phrases

• To store a word or phrase (string value), we use
  a variable that is a string
• Technically string is not a data type
• You can think of it as a data type for now

22
Data Types True and False

• The data type bool is useful to store true and
  false values
• Alternatively, we can simply use an int variable
  with either a 1 value (to represent true) or a 0
  value (to represent false) if necessary

23
Other Data Types

• unsigned char, short, unsigned int, long, and
  unsigned long for whole numbers
• float and long double for decimal values

24
Using Variables in C

• Variables must be declared before they are used
  in C. Get into the habit of doing this at the
  top of your functions
• char grade // a students semester
  grade
• int numStudents // number of students in our
  class
• double price // price of item
• string userName // user's name

25
Variable Names

• Variable names are technically known as
  identifiers
• Choose your own variable names but you must be
  careful to use valid ones. Otherwise, the
  compiler will be confused and errors will result.
  When choosing your variable names
• do not use keywords that are defined in the
  programming language (Reserved Words)
• do not include spaces or other disallowed
  characters
• do not use more than 31 characters
• do begin the identifier with a letter
• Remember, C is completely case sensitive

26
Common Reserved Words

• break
• case
• char
• const
• default
• do
• double
• else
• extern

• float
• for
• if
• int
• long
• return
• switch
• void
• while

27
Conventions for Naming Variables

• Use a conventional method of making your
  variables easy to read at a quick glance. For
  example
• Begin variable identifiers with lowercase letters
  (eg. score)
• if you wish to use more than one word within the
  identifier, you must capitalize the following
  words or parts of words (eg. semesterGrade,
  testScore)
• Separate successive words with underscore
  characters ( _ ) (eg. semester_grade, card_value)
  
• Hungarian notation
• Begin with type (eg. iTestScore)

28
Initializing Variables

• C does not automatically initialize all
  variables to the value 0
• If you do not initialize a variable to a certain
  value, the variable will have an indeterminate
  value that can corrupt the logic of your program
• You should usually initialize your variables at
  the same time that you declare them. This is done
  with a declaration statement that is also an
  initialization statement
• int numberOfPizzas 3          double
  monthlyCarPayment 685char letterGrade
  'A'string firstName "Paul"

29
Constants

• Sometimes you need to use the same value many
  times throughout a program. In this case, it is
  proper to use a constant rather than a variable
• Constants allow you to give a name to a value
  used several times in a program
• The value never changes

30
Use of Constants (Literals)

• Numeric
• 5
• 3.14159
• -17.29
• Characters
• 'a'
• '7'
• ''
• Strings (a sequence of symbols
• "I will be an better person "

31
Naming Constants

• Constants are defined in a way that is similar
  to variables
• Select a data type and give the constant a name
• Any valid identifier name can be used to name a
  constant
• Start with letter or underscore
• Cant use reserved words

32
Conventions for Naming Constants

• Traditionally, all uppercase letters have been
  used when naming constants
• Use the underscore character ( _ ) between
  consecutive words. This allows other programmers
  to be able to "pick out" your constants at a
  quick glance
• Examples
• const double PI 3.14159
• const double PA_SALES_TAX 0.06
• const int SPEED_OF_LIGHT 299792458 // commas
  can't be used here

33
Type Compatibilities

• You cannot store a value of one type in a
  variable of a different type a type mismatch
  occurs
• You can typecast
• Supply the name of the data type you want to use
  to interpret the variable followed by the
  variable placed in parenthesis
• C PI float (diameter)

34
Common Arithmetic Operators

• for addition
• - for subtraction
• for multiplication
• / for division
• for modulus (like finding the remainder
  of a division problem)

35
Order of Operations

• Obey the order of operations
• Perform the following mathematical operations in
  this order Parentheses, Exponentiation,
  Multiplication, Division, Addition and
  Subtraction
• Multiplication and division are of equal
  precedence, so you must work left to right within
  an algebraic expression
• The modulus operator () has the same precedence
  as and / but is higher in precedence than and
  -.
• Addition and subtraction work left to right
  within an algebraic expression as well
• Use parentheses if necessary to override the
  order of operations in order to produce the
  desired result