View
217
Download
3
Embed Size (px)
Citation preview
1
CS 105 Lecture 2
VariablesWed, Jan 19, 2011, 5:07 pm
2
• Go to www.cs.iit.edu/~cs105/wed_eve, click on Syllabus, review Lecture 01 notes, course schedule.
• Make sure you go to Lab 0.
• (Make sure you go to Lab 0 even if didn’t miss last week :-)
If You Missed Last Week
3
• Write pseudocode (Design)
• Translate pseudocode into C++ source code (Coding)
• Edit code
• Compile
• Link
Writing a C++ Program
4
• English-like written solution to a programming problem.
• Somewhere between informal description and program written in C++.
• How do we get pseudocode?• How do we solve problems?• Design issues apply to almost any
vocation.
What Is Pseudocode?
5
• Steps in creating pseudocode:
• Understand the problem.
• Decide how to solve the problem.
• Write the solution using a logical sequence of statements.
• Typically, we break down large problems into smaller subproblems and solve those.
Creating Pseudocode
6
• Source code is the actual program code that will run once compiled and linked.
• Pseudocode should be easily translatable into source code.
Pseudo vs Source Code
7
• Every C++ Program Must Have:
• int
• main()
• {
• }
C++ Required Elements
8
// Sam Smith// CS 105// Section 07#include <iostream>using namespace std;intmain(){ cout << “Hello World!!” << endl; return (0);}
Your First Program
9
• Actually uses multiple programs to translate source code program into machine code (executable by hardware).
• Preprocessor
• Actual compiler
• Linker
Compiler
10
• Preprocessing is the actions taken before a source file is handed off to the compiler
• Outcome of preprocessing must still be a correct source code file
• #include is an example
Preprocessing
11
• #include: Replace w/text of specified file.
• #include usually occurs at top of program.
• Pound sign (#) must be in first column.
• Ex: #include <iostream> for typical input and output operations in C++
• Error if file to include can’t be found.
#include
12
• Converts source code into an object file or machine code.
• Each change to source file requires a recompilation before re-execution.
• Compiler also looks for malformed programs — syntax errors a.k.a. “compile time errors”.
Actual Compiler
13
• Syntax error: A non-proper, not allowable, sequence of characters or words given a particular language.
• Typical syntax errors:
• Spelling mistakes
• Punctuation mistakes
• Wrong type of data for operation
Syntax Error
14
• Undefined variable name
• C++ is case sensitive
• Example: “Hi” >> cout (not COUT).
• Unrecognized keyword
• Certain “key” words have special meaning in C++. Example: int.
Spelling Errors Examples
15
• Missing, extra, or misplaced parentheses, braces, commas, semicolons...
• Parentheses unbalanced or of wrong shape.
• Comments malformed.
• Syntax errors are typically listed at bottom of screen when compilation is complete.
Punctuation Error Examples
16
• Two kinds of syntax error messages:
• Warning: Compiler finds possible error, lets it go by without failing.
• Error: Compiler finds an error that causes compile to fail.
Syntax Error Messages
17
• First error in program may “cause” other errors to show up.
• General advice: Fix the first error (and any obvious errors), then recompile.
Syntax Error Messages
18
• Linking connects (i.e. links) your object code with external libraries (external = not written as part of this program).
• Object library contains already-written and compiled code to use with other programs.
• Example: Code for iostream includes definition of “<<“ and “>>”
Linking
19
• If linker cannot find the libraries, error messages are generated.
• Successful linking creates an executable file.
• An executable file can be run.
• (.exe file in Windows)
Linking
20
• Also called semantic or run-time errors.
• Program compiles, but doesn’t produce the expected results.
• Results wrong, missing, extra.
• Program halting wrongly.
• Errors may be repeatable or intermittent.
Logic Errors – “Bugs”
21
• Halts early.
• Never halts (infinite loop).
• Halts due to bad operation.
• Possible example: Dividing by zero.
• Compiler does type checking to avoid wrong kinds of data at runtime.
Halting Problems
22
• (From Navy website for Adm. Grace Murray Hopper)
• 1947: Moth found shorting a relay in early computer.
• “Bugs” and “debugging” already used as terms, but this is first example of a bug being caused by an actual bug.
The “First” Bug
23
The “First” Bug
24
• Test-run program with different inputs.
• Test plan: series of tests (e.g., inputs) that have predetermined expected outputs.
• Test-run program under all potential conditions.
• May need simulator, other tools to look at data & operations during program run.
Detecting Bugs
25
• Debugging: Finding and removing bugs.
• When errors detected, analysis is needed.
• Work backward from symptom: What can cause this symptom?
• Example: We printed x and got the wrong value. Where did x get set/changed? Why was x set to a bad value?
Debugging
26
• Comments are used to help the person reading the program understand it.
• Good comments are invaluable.
• Typically two types of comments.
• Summary of program or major part of it.
• Descriptions of data/variables.
Comments
27
• Summary comment typically describes intent of larger piece of program.
• E.g. overall summary at beginning of program.
• With data/variable definition, comments describe properties, uses of data/variable.
• E.g. x should be ≥ 0 and ≤ y.
Types of Comments
28
• Don’t generally need to comment “what” is happening unless it’s especially complicated.
• Comments are good for saying things you can’t easily infer from the program.
• Why are we doing something?
• What are the properties of and relationships between variables?
What Goes in Comments?
29
• Two ways to write comments in C++
• // Comment to end of line
• /* Comment until star slash */
• First occurrence of star slash (not “matching” like parentheses).
• Can be many lines away.
Comments in C++
30
• Summary Comments
• Preprocessor statements (e.g., #include)
• Namespace declaration
• Main Function
Elements of a Program
31
• Main Function:
int main(){ // statements; return 0;}
Main Function
32
• White Space:
• Not recognized by compiler
• Used by humans to show program structure.
• Indent (e.g. 3 spaces) for each new function, selection, or loop
Program Format
33
• Variables are names (identifiers) used to store values that may change.
• Every variable has a value and a type.
• Type: the kind of value (integer, floating point, character, etc.) being stored.
• Value gets assigned/reassigned as program runs
Variables
34
• In C++, we “declare” variables.
• Tells compiler to set aside storage space.
• Tells compiler the variable’s type (what type of value it will hold)
• May or may not specify an initial value for the variable.
• Must declare variable before using it.
Declarations of Variables
35
int main() { int num1; variable declaration num1 = 10; variable assignment cout << num1; variable output}
•Declaration int num1 includes type and name of variable (no initial value).
Example
36
• int num;
• num = 10;
• num = 15;
<garbage>
num
10
num
Main Memory
15
num
Variables and Main Memory
37
• Storage location of data in a computer.
• Used when a program is running.
• RAM = “Random Access Memory”
• “Wiped clean” when computer rebooted.
• Byte: basic unit of storage (8 bits; can store one letter of English alphabet)
Main Memory
38
• Kilobyte (KB): 1000 (or 1024) Bytes
• Bug photo was 100 KB
• Megabyte (MB): 1,000,000 Bytes
• CD holds 700 MB
• Gigabyte (GB): 1,000,000,000 Bytes
• DVD holds 4.7 GB
Main Memory
39
• Initialization: Giving a value to a variable when its space is allocated (specified in declaration).
• Assignment: Giving a value to a variable after it’s been allocated.
• Use assignment statement to do this.
Initialization/Assignment
40
int main() { int num1 = 10; variable declaration
with initialization
cout << num1; variable output}
Variable Initialization
41
• C++ supports some built-in/”primitive” data types. (Correspond to types of data typically supported by hardware.)
• Various kinds of numbers (integral and floating-point).
• Characters.
Built-In Datatypes
42
• int: Integer, typically -32768 to 32767 (de-pends on machine/compiler). No commas!!
• float: Real number, range typically 10-38 to 1038. E.g. 6.02e23 for 6.02 × 10²³.
• double: Larger exponents, more significant digits than float (typically 10e-308 to 10e308).
Built-In Numeric Types
43
• Can use letters, digits 0–9 and underscores.
• Can’t start with a digit.
• Case-sensitive (Example: NumWidgets is not the same as numwidgets).
• Can’t contain spaces or other characters.
• Practical maximum of 32 characters.
• Cannot use C++ keywords.
Identifiers
44
• Use a meaningful, descriptive name so that variable’s use is easily understood. (E.g. counter, second, minute, length, width.)
• Separate internal words with underscores or with capitalization. (Example: averageRainfall or average_rainfall, not averagerainfall.)
Naming Variables (Cont)
45
• Scope: Area of a program within which a variable can be referenced.
• Typical variable has local scope, within the { … } in which it was defined.
• Later on we’ll see function parameters; they have local scope too.
Scope of a Variable