1. CPSC 230Computers and Programming I Fall 2004 Dr. Lynn Lambert

2. This course will teach you: • C++ • Object-oriented concepts • Programming • Some stabs at problem solving

3. How computers work • Computers understand machine language only • Each computer has its own language • All computer languages are in binary (1s and 0s) • No computer understands English, Powerpoint, or C++

4. A computer program: Add X to Y and store in Z In machine language: • 01040100 (already simplified to decimal) • 01050160 • 04040506 • 02060180 HUH!?

5. Assembly Each machine instruction has matching, more English-like assembler: • Load X (was: 01040100) • Load Y (was: 01050160) • Add X Y Z (was: 04040506) • Store Z (was: 02060180) Better, but … all this for one addition!?

6. z=x+y; Much better! BUT, no machines understand source code. Only machine code. C++

7. Designing a Program • Decide the problem to solve. • Design the solution!!!!!! • Translate design to C++ • Type the C++ program (source code) using an editor (emacs): program.cc • Compile (g++). Translates C++ into machine language (object, machine, executable code) • Link (g++). Creates executable. Can be done with step 5 or separately. • Run the program (after 1-6).

8. At each step: • Think • Do • Debug • Test

9. Write a program to calculate the volume of a sphere • Problem well-defined • Design solution: • Read radius • Calculate volume: V = 4/3(p)r3 • Print answer

10. Extreme Programming • Also called Agile Programming, Agile Methods • Goal is to produce easily modifiable, reliable code that corresponds to user wants • Pairs programming, tests created before program is written

11. Test for volume program • Radius input: 2.0 // nice normal test • Answer should be: 33.5 • Radius input: 2 // testing integer input • Answer should be: 33.5 • Radius input: 0 // ALWAYS test for 0 • Answer should be: 0 • Others tests: negative, large, small, etc.

12. C++ Program #include <iostream> // allows reading in and out using namespace std; // standard namespace int main() { float radius; // radius of a sphere float volume; // volume of sphere; float is decimal. // other types are int, char, bool, double

13. const float mypi = 3.14159; // const values cannot be changed // M_PI also defined in cmath cout << “This program calculates the volume “ << “of a sphere given its radius.” << endl; // lots of other ways to do this cout. cout << “Enter the radius> “; cin >> radius;

14. // volume = 4/3 p r3 try 1: volume = 4/3 M_PI r …? 3? try 2: volume = 4 / 3 * M_PI * r * r; try 2.b: volume = 4/3 * M_PI * pow(r, 3); // pow is in cmath cout << "The volume of a sphere with radius "; cout << radius << " is " << volume << endl; return EXIT_SUCCESS; // in <cstdlib> }

15. Now, let’s do it

16. great. except it doesn't work.

17. Class Work Write a program that converts a user entered number of inches to the equivalent number of centimeters (1 inch = 2.54 centimeters). • Work with your partner. • Write an algorithm first • Write the tests next (input value for what variable, why this test, expected answer) • Gradually convert the algorithm to C++

18. FunctionsChapter 3 (modified from Deitel & Deitel web page)

19. Why functions? • divide and conquer • repeatable. reuse reliable code • encapsulated

20. Program Components in C++ • Modules: functions and classes • Programs use new and “prepackaged” modules • New: programmer-defined functions, classes • Prepackaged: from the standard library • Functions invoked by function call • Function name and information (arguments/parameters) it needs • Function definitions • Only written once

21. Program Components in C++ • Boss to worker analogy • A boss (the calling function or caller) asks a worker (the called function) to perform a task and return (i.e., report back) the results when the task is done

22. Library Functions • Functions called by writing • functionName(argument1, argument2, …); • Perform common mathematical calculations • Include the header file <cmath> • Call the appropriate function

23. Library Functions • Example volume = 4.0 / 3.0 * M_PI * pow(r, 3); • pow (exponentiation) function returns baseexponent (pow(2,3) would return 8) • Other math functions listed on p. 173 of text • All functions in math library return a double

24. Parameters/Arguments • Function arguments can be • Constants • sqrt( 4 ); • Variables • sqrt( x ); • Expressions • sqrt( sqrt( x ) ) ; • sqrt( 3 - 6x );

25. Header Files • Header files contain • Function prototypes • Definitions of data types and constants • Header files ending with .h • Programmer-defined header files #include “myheader.h” • Library header files #include <cmath>

26. Other libraries • Perform string operations, include <string> • Perform character manipulations, include <cctype> • file handling, <fstream> • standard constants and routines <cstdlib> • Lots of others

27. To find a function or library • Look in your textbook • Ask your partner/class mates • Ask me • Look on google (or other search engine) • Look on google groups

28. Writing your own functions • To call a function, you need: • Function call – invokes function execution • done • To write your own function, you need: • Function call (e.g., pow, sqrt). We know this. • Function prototype (shown in function libraries, like <cmath> -- contains interface information) • Function definition– contains the C++ that defines how that function will be executed (e.g., main). Really, we know this.

29. Function call • Calling/invoking a function • Tells C++ to go do function. If never called, never performed • nothing new. No change in how library functions, your functions are called • After finished, passes back result. Calling function can store or use result • x = pow(2, 3); • cout << pow(2, 3);

30. Function Call • Syntax • nameoffunction(arg1, arg2, …) • square(x); • Parentheses an operator used to call function • Pass argument x • Function gets its own copy of arguments • Write a function call that prints the result of sqrt of 4. Discuss with 2 others.

31. Function definition • Format for function definition return-value-type function-name( parameter-list ){ declarations and statements} • Parameter list • Comma separated list of arguments • Data type needed for each argument • If no arguments, use void or leave blank • Return-value-type • Data type of result returned (use void if nothing returned)

32. Function definition • Example function int square( int y ) { return y * y; } • return keyword • Returns data, and control goes to function’s caller • If no data to return, use return; • Function ends when reaches right brace • Control goes to caller • Functions cannot be defined inside other functions

33. You try • Write a function definition, sum3, that returns the sum of 3 integers.

34. Function Prototypes • Purpose • Tells compiler argument(s) type and return type of function • int square( int ); • Function takes an int and returns an int • Syntax • Function name • Parameters (number and data type) • Return type (void if returns nothing) • Only needed if definition after function call • semicolon (unlike header in function definition)

35. Function Prototypes • Prototype must match function header • Function prototype int sqr(int); • Function Header in Function Definition int sqr(int y) { … } • Write a function prototype for sum3

36. // Fig. 3.3: fig03_03.cpp. But modified from code in book // Creating and using a programmer-defined function. #include<iostream> #include <cstdlib> using namespace std;// modified from code in book int square( int ); // function prototype intmain() { int number; // Ask user for number square then square that number cout << “This program calculates the square of an integer.” << endl; cout << “Enter a number> “; cin >> number; // next line is function call cout << number << “ squared is “ << square(number) << endl; returnEXIT_SUCCESS;// indicates successful termination }// end main Function prototype: specifies data types of arguments and return values. square expects and int, and returns an int. Function call.: Parentheses () cause function to be called. When done, it returns the result.

37. // this continues program begun on previous slide // square function definition returns // square of an integer int square( int y ) // y is a copy of argument to function { return y * y; // returns square of y as an int } // end function square OR int square(int nbr) { int answer; answer = nbr * nbr; return answer; } function body: C++ statements in between {}s. function header: return type function name, parameter list.

38. void • Empty parameter lists • void or leave parameter list empty • Indicates function takes no arguments • Function print takes no arguments and returns no value • void print(); • void print( void );

39. print function example • Prototype • void printinfo(void); • Function call int main () { ... printinfo(); … }

40. print function example cont'd • function definition void printinfo() { cout << "this program calculates"; cout << " the area of a sphere"; cout << endl; }

41. void can be anywhere or nowhere Return type OR argument list OR both or neither can be void • void printint(int x) • int getint() • void printinstructions() • int square(int x)

42. Function overloading • Function overloading • Functions with same name and different parameters • Should perform similar tasks • i.e., function to square ints and function to square floats int square( int x) {return x * x;} float square(float x) { return x * x; } • Similar to overloaded +, /, etc. operators

43. Function overloading cont'd • Overloaded functions distinguished by signature • Based on position, number, and type of parameters (order of parameters matters) • Name mangling • Encodes function identifier with parameters • Type-safe linkage • Ensures proper overloaded function called

44. // Fig. 3.25: fig03_25.cpp 2 // Using overloaded functions. 3 #include <iostream> 4 5 using std::cout; 6 using std::endl; 7 8 // function square for int values 9 int square( int x ) 10 { 11 cout << "Called square with int argument: " << x << endl; 12 return x * x; 13 14 } // end int version of function square 15 16 // function square for double values 17 double square( double y ) 18 { 19 cout << "Called square with double argument: " << y << endl; 20 return y * y; 21 } // end double version of function square 23

45. 24 int main() 25 { 26 int intResult = square( 7 ); // int version called 27 double doubleResult; 28 doubleResult= square( 7.5 ); // calls double version 29 cout << "\nThe square of integer 7 is " << intResult 30 << "\nThe square of double 7.5 is " 31 << doubleResult << endl; 32 33 return 0; // indicates successful termination 34 35 } // end main Called square with int argument: 7 Called square with double argument: 7.5 The square of integer 7 is 49 The square of double 7.5 is 56.25

46. Class Work • With your partner, write a program that calculates the volume of a sphere, and uses a function calcspherevolume. • Talk to your neighbors • Use the book • Use your notes

47. If Statements Sections 1.25, 2.4-2.6

48. Control Structures • All code thus far executes every line of code sequentially • We want to be able to repeat, to choose some lines of code • Three types of control: sequence, conditional, repetition/iteration

49. Types of control structures • Sequence – default in C++, execute each instruction sequentially as it reached • Conditional – choose whether to execute some C++ statement (if, if -else switch) • Iteration – loop. Repeat some set of statements multiple times

50. Conditional • Choose which statement to execute. • Form: if (some condition is true), then do some action • If (comparison) then (action) • Many examples in English: • If raining, wear raincoat. • If cold, wear winter coat. • When in Rome, do as the Romans (if in Rome, act like a Roman)