CPS120: Introduction to Computer Science

1. CPS120: Introduction to Computer Science Variables and Constants

2. Compilers • Compiler: a program that translates a high-level language program into machine code • High-level languages provide a richer set of instructions that makes the programmer’s life even easier

3. Compilers Compilation process

4. Programming Language Paradigms • A paradigm? • A set of assumptions, concepts, values, and practices that constitute a way of viewing reality

5. Programming Language Paradigms Portability provided by standardized languages versus interpretation by Bytecode

6. Programming Language Paradigms • Imperative or procedural model • FORTRAN, COBOL, BASIC, C, Pascal, Ada, and C++ • Functional model • LISP, Scheme (a derivative of LISP), and ML

7. Programming Language Paradigms • Logic programming • PROLOG • Object-oriented paradigm • SIMULA and Smalltalk • C++ is as an imperative language with some object-oriented features • Java is an object-oriented language with some imperative features

8. 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

9. Strong Typing • Strong typing: the requirement that only a value of the proper type can be stored into a variable • A data type is a description of the set of values and the basic set of operations that can be applied to values of the type

10. Data Types • Integer numbers • Real numbers • Characters • Boolean values • Strings

11. Declarations • A declaration is a statement that associates an identifier with a variable, an action, or some other entity within the language that can be given a name so that the programmer can refer to that item by name

12. Declarations (cont.)

13. Data Types • You need to first choose an appropriate data type when you use a variable.Values can either be: • whole numbers • decimal numbers • letters (i.e. characters) • whole words (i.e. string values

14. Choosing a Type • Most computer languages have a select number of different data types • You must select the proper data type for each variable that you use in a program in order to program efficiently • This decreases memory (RAM) usage • This increases the speed of your program

15. Integers • The range varies depending upon how many bytes are assigned to represent an integer value • Some high-level languages provide several integer types of different sizes • Operations that can be applied to integers are the standard arithmetic and relational operators

16. 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.

17. Reals • Like the integer data type, the range varies depending on the number of bytes assigned to represent a real number • Many high-level languages have two sizes of real numbers • The operations that can be applied to real numbers are the same as those that can be applied to integer numbers

18. 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)

19. Characters • It takes one byte to represent characters in the ASCII character set • Two bytes to represent characters in the Unicode character set • Our English alphabet is represented in ASCII, which is a subset of Unicode

20. Characters • Applying arithmetic operations to characters doesn’t make much sense • Comparing characters does make sense, so the relational operators can be applied to characters • The meaning of “less than” and “greater than” when applied to characters is “comes before” and “comes after” in the character set

21. 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.

22. Strings • A string is a sequence of characters considered as one data value • For example: “This is a string.” • Containing 17 characters: one uppercase letter, 12 lowercase letters, three blanks, and a period • The operations defined on strings vary from language to language • They include concatenation of strings and comparison of strings in terms of lexicographic order

23. 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

24. Boolean • The Boolean data type consists of two values: true and false • Not all high-level languages support the Boolean data type • If a language does not, then you can simulate Boolean values by saying that the Boolean value true is represented by 1 and false is represented by 0

25. 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

26. Other Data Types • unsigned char, short, unsigned int, long, and unsigned long for whole numbers • float and long double for decimal values

27. 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

28. Remember • A reserved word is a word in a language that has special meaning • Case-sensitive means that uppercase and lowercase letters are considered the same

29. 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

30. 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)

31. break case char const default do double else extern float for if int long return switch void while Common Reserved Words

32. 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 = 685;char letterGrade = 'A';string firstName = "Paul";

33. Assignment statement • Assignment statement: an action statement (not a declaration) that says to evaluate the expression on the right-hand side of the symbol and store that value into the place named on the left-hand side

34. Assignment Statement

35. Constants • Named constant: A location in memory, referenced by an identifier, that contains a data value that cannot be changed

36. 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

37. Use of Constants (Literals) • Numeric 5 3.14159 -17.29 • Characters 'a' '7' '*' • Strings (a sequence of symbols "I will be an better person "

38. 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 • Can’t use reserved words

39. 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

40. Type Compatibilities • You cannot store a value of one type in a variable of a different type – a type mismatch occurs • Promotion occurs automatically • 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);