2. FALL 2001ICOM 4015 - Lecture 21 ICOM 4015 Advanced Programming Lecture 2 Procedural Abstraction Reading: LNN Chapter 4, 14 Prof. Bienvenido Velez

3. FALL 2001ICOM 4015 - Lecture 22 Procedural Abstraction Topics Topic 1 –Functions as abstract contracts –Parameter passing –Scoping Topic 2 –Functional arguments Topic 3 –Top-down modular design –Stepwise refinement Topic 4 –Recursive functions –Recursion vs. Iteration Topic 5 –Further procedural abstraction –Function overloading and templates

4. FALL 2001ICOM 4015 - Lecture 23 Procedural Abstraction I Outline Functions as abstract contracts Value/Reference parameters Procedural Abstraction Defined Scope Rules

5. FALL 2001ICOM 4015 - Lecture 24 Example 0 Finding the roots of ax2 +bx + c #include // roots(a, b, c, r1, r2) - returns the number of // real roots of ax^2 + bx + c. If two roots exists // they are returned is r1 and r2. If only one root // exists, it is returned in r1. Otherwise the value // of r1 and r2 is undetermined. int roots(float a, float b, float c, float& r1, float& r2) { float d = b * b - 4.0 * a * c; if (d < 0) { return 0; } r1 = (-b + sqrt(d)) / (2.0 * a); if (d == 0) { return 1; } r2 = (-b - sqrt(d)) / (2.0 * a); return 2; } roots.cc int roots(float a, float b, float c,float& r1, float& r2); roots.h declarations definitions WHAT? HOW? formal parameters

6. FALL 2001ICOM 4015 - Lecture 25 Procedural Abstraction A function should accomplish ONE well defined and easy to remember task A function establishes a contract between callers and implementers The implementer may select any implementation that satisfies the contract. The contract should specify WHAT task the function accomplishes, NOT HOW it accomplishes it “HOW” is hidden or abstracted out, hence the name procedural abstraction

7. FALL 2001ICOM 4015 - Lecture 26 Scope Rules & Parameter Passing Mechanisms #include // Forward definitions int f(int& x); // Global definitions static int x = 0; int y = 0; int main() { for (int i=0; i < 5; i++) { int arg = x; int r = f(x); cout " << r; cout << " Glob x=" << x << endl; cout << " Glob y=" << y << endl; } int f(int& x) { int y=0; static int z=0; y++; z+=2; x = y + z; cout << " Loc x=" << x; cout << " Loc y=" << y; cout << " Loc z=" << z; return z; } [bvelez@amadeus] ~ >> scope1 Loc x=3 Loc y=1 Loc z=2 f(0) -> 2 Glob x=3 Glob y=0 Loc x=5 Loc y=1 Loc z=4 f(3) -> 4 Glob x=5 Glob y=0 Loc x=7 Loc y=1 Loc z=6 f(5) -> 6 Glob x=7 Glob y=0 Loc x=9 Loc y=1 Loc z=8 f(7) -> 8 Glob x=9 Glob y=0 Loc x=11 Loc y=1 Loc z=10 f(9) -> 10 Glob x=11 Glob y=0 [bvelez@amadeus] ~ >> Global in Module Global Local to For Loop Local to Block Local to Function

8. FALL 2001ICOM 4015 - Lecture 27 Diagramas de Bloques main: f: x: y: x: y: z: for: i: arg: r:

9. FALL 2001ICOM 4015 - Lecture 28 Procedural Abstraction I Summary of Concepts Value parameters – changes remain local to function. Function works with a copy of the argument. Reference parameters – changes propagate to argument. Function works with original argument. Procedural abstraction – a function establishes a contract with its callers on what it accomplishes, hiding how it accomplishes it.

10. FALL 2001ICOM 4015 - Lecture 29 Procedural Abstraction I - Scoping Summary of Concepts II Definition: Scope of a declaration –region of code where declaration is active Scope rules allow better control over the namespace Local namespaces (e.g. functions, blocks) independent of each other Local declarations take precedence over global declarations

11. FALL 2001ICOM 4015 - Lecture 210 Procedural Abstraction II Outline Procedural arguments

12. FALL 2001ICOM 4015 - Lecture 211 Integration Without Procedural Arguments #include // Forward definitions double integrateSqr(double a, double b, double n); double integrateCube(double a, double b, double n); int main() { cout << "Integral of x^2 in [0,1] = " << integrateSqr(0.0, 1.0, 10000) << endl; cout << "Integral of x^3 in [0,1] = " << integrateCube(0.0, 1.0, 10000) << endl; } double integrateSqr(double a, double b, double n) { double delta = (b-a) / double(n); double sum = 0.0; for (int i=0; i<n; i++) { float x = a + delta * i; sum += x * x * delta; } return sum; } double integrateCube(double a, double b, double n) { double delta = (b-a) / double(n); double sum = 0.0; for (int i=0; i<n; i++) { float x = a + delta * i; sum += x * x * x * delta; } return sum; } [bvelez@amadeus] ~/icom4015/lec05 >> example2 Integral of x^2 in [0,1] = 0.333283 Integral of x^3 in [0,1] = 0.24995 [bvelez@amadeus] ~/icom4015/lec05 >>

13. FALL 2001ICOM 4015 - Lecture 212 Example 3 Integration With Procedural Arguments #include // Forward definitions double integrate(double a, double b, double n, double f(double x)); double cube(double x); double sqr(double x); int main() { cout << "Integral of x^2 in [0,1] = " << integrate(0.0, 1.0, 10000, sqr) << endl; cout << "Integral of x^3 in [0,1] = " << integrate(0.0, 1.0, 10000, cube) << endl; } double integrate(double a, double b, double n, double f(double x)) { double delta = (b-a) / double(n); double sum = 0.0; for (int i=0; i<n; i++) { sum += f(a + delta * i) * delta; } return sum; } double cube(double x) { return x * x * x; } double sqr(double x) { return x * x; } [bvelez@amadeus] ~/icom4015/lec05 >> example2 Integral of x^2 in [0,1] = 0.333283 Integral of x^3 in [0,1] = 0.24995 [bvelez@amadeus] ~/icom4015/lec05 >>

14. FALL 2001ICOM 4015 - Lecture 213 Procedural Abstraction II Functional Arguments Summary of Concepts Functional arguments –Allow abstraction over processes and functions

15. FALL 2001ICOM 4015 - Lecture 214 Procedural Abstraction III Outline Top-down stepwise refinement

16. FALL 2001ICOM 4015 - Lecture 215 Step 0 - Outline // top-down.cc // Computes weighted average score of grades. Grades // include two assignments two midterm exams and one final exam. // All grades are input from standard input, but the weights of // each type of grade are hard coded. // C header files extern "C" { } // Standard C++ header files #include // My own C++ header files // Macro definitions // Forward definitions of auxiliary functions // Global declarations // Main function int main() { // Read assignment grades // Read exam grades // Read final exam grade // Calculate average // Print report return 0; } // Auxiliary functions

17. FALL 2001ICOM 4015 - Lecture 216 Step 1 – Code + Stubs int main() { float assignment1, assignment2; float exam1, exam2; float finalExam; readAssignmentGrades(assignment1, assignment2); readExamGrades(exam1, exam2); readFinalGrade(finalExam); float avg; avg = calculateAverage(assignment1, assignment2, exam1, exam2, finalExam); printReport(assignment1, assignment2, exam1, exam2, finalExam, avg); return 0; } // Auxiliary functions void readAssignmentGrades(float& assignment1, float& assignment2) {} void readExamGrades(float& ex1, float& ex2) {} void readFinalGrade(float& final) {} float calculateAverage(float assignment1, float assignment2, float exam1, float exam2, float finalExam) {} void printReport(float assignment1, float assignment2, float exam1, float exam2, float finalExam, float average) {}

18. FALL 2001ICOM 4015 - Lecture 217 Step 2 - Refine // Auxiliary functions void readAssignmentGrades(float& assignment1, float& assignment2) { // Read a float in [0,100] into assignment1 // Read a float in [0,100] into assignment2 } void readExamGrades(float& ex1, float& ex2) { // Read a float in [0,100] into ex1 // Read a float in [0,100] into ex2 } void readFinalGrade(float& final) { // Read a float in [0,100] into final } float calculateAverage(float assignment1, float assignment2, float exam1, float exam2, float finalExam) { // Calculate assignments average // Calculate exams average // Calculate weighted average } void printReport(float assignment1, float assignment2, float exam1, float exam2, float finalExam, float average) { // print assignment grades // print exam grades // print final exam grades // print weighted average }

19. FALL 2001ICOM 4015 - Lecture 218 Top-down stepwise refinement cycle outline refine code + stubs

20. FALL 2001ICOM 4015 - Lecture 219 Procedural Abstraction III Top-down design – Stepwise Refinement Summary of Concepts Top-Down design / stepwise refinement –A cyclic development technique –Each cycle adds a level of detail to the code –We have a functioning (although incomplete) program after every iteration of the process

21. FALL 2001ICOM 4015 - Lecture 220 Procedural Abstraction IV Outline Recursive Functions –Activation records, call stacks –Expressiveness of recursion vs. iteration –Efficiency concerns function call overhead duplication of work process complexity

22. FALL 2001ICOM 4015 - Lecture 221 Example 0 Factorials // factorials.cc // Implements recursive and interative versions of algorithms for // computing the factorial (N!) of a number. // Standard C++ header files #include // Forward definitions of auxiliary functions long recFactorial(long n); long iterFactorial(long n); int main() { long number; while(true) { cout << "Please enter a positive number (or negative to end): "; cin >> number; if (number < 0) return 0; cout << "Recursive: " << number << "! = " << recFactorial(number) << endl; cout << "Iterative: " << number << "! = " << iterFactorial(number) << endl; } long recFactorial(long n) { if (n==0) { return 1; } else { return (n * recFactorial(n - 1)); } long iterFactorial(long n) { long product = 1; for (long i=1; i<=n; i++) { product *= i; } return product; } [bvelez@amadeus] ~/icom4015/lec07 >>factorials Please enter a positive number (or negative to end): 3 Recursive: 3! = 6 Iterative: 3! = 6 Please enter a positive number (or negative to end): 4 Recursive: 4! = 24 Iterative: 4! = 24 Please enter a positive number (or negative to end): 5 Recursive: 5! = 120 Iterative: 5! = 120 Please enter a positive number (or negative to end): 6 Recursive: 6! = 720 Iterative: 6! = 720 Please enter a positive number (or negative to end): -1 [bvelez@amadeus] ~/icom4015/lec07 >>fibonacci

23. FALL 2001ICOM 4015 - Lecture 222 Example 1 Fibonacci Numbers // fibonacci.cc // Iterative and recursive algorithms for computing Fibonacci numbers... // Auxiliary Functions long recFibonacci(long n) { if (n==0) { return 0; } else if (n==1) { return 1; } else { return (recFibonacci(n-1) + recFibonacci(n-2)); } long iterFibonacci(long n) { if (n==0) { return 0; } else if (n==1) { return 1; } long F0 = 0; long F1 = 1; long FN; for (long i=1; i<n; i++) { FN = F0 + F1; F0 = F1; F1 = FN; } return FN; } [bvelez@amadeus] ~/icom4015/lec07 >>fibonacci Please enter a positive number (or negative to end): 3 Recursive: F(3) = 2 Iterative: F(3) = 2 Please enter a positive number (or negative to end): 4 Recursive: F(4) = 3 Iterative: F(4) = 3 Please enter a positive number (or negative to end): 8 Recursive: F(8) = 21 Iterative: F(8) = 21 Please enter a positive number (or negative to end):

24. FALL 2001ICOM 4015 - Lecture 223 Example 1 Fibonacci Numbers // fibonacci.cc // Iterative and recursive algorithms for computing Fibonacci numbers // Standard C++ header files #include // Forward definitions of auxiliary functions long recFibonacci(long n); long iterFibonacci(long n); int main() { long number; while(true) { cout << "Please enter a positive number (or negative to end): "; cin >> number; if (number < 0) return 0; cout << "Recursive: F(" << number << ") = " << recFibonacci(number) << endl; cout << "Iterative: F(" << number << ") = " << iterFibonacci(number) << endl; } …...

25. FALL 2001ICOM 4015 - Lecture 224 Procedural Abstraction IV Iteration vs. Recursion Summary of Concepts Recursion is as expressive as iteration Iteration can yield faster code –less duplication of work –less function call overhead Recursion can yield cleaner code –may rely on a “smart” optimizing compiler to minimize call overhead

26. FALL 2001ICOM 4015 - Lecture 225 Procedural Abstraction V Outline Further procedural abstraction –Function overloading –Function templates

27. FALL 2001ICOM 4015 - Lecture 226 Function Overloading SQR Function Family int sqr (int x) { return x * x } long sqr(long x) { return x * x; } float sqr(float x) { return x * x } int intSqr (int x) { return x * x } long longSqr(long x) { return x * x; } float floatSqr(float x) { return x * x } Without overloading With overloading

28. FALL 2001ICOM 4015 - Lecture 227 Function Templates SQR Function Family template T sqr (T x) { return x * x } With templates int sqr (int x) { return x * x } long sqr(long x) { return x * x; } float sqr(float x) { return x * x } With overloading

29. FALL 2001ICOM 4015 - Lecture 228 SQR’aring different types // Standard C++ header files #include // Forward definitions of local auxiliary functions template T sqr(T x); // Main function int main() { cout << " i" << " sqr(i)" << " sqr(float(i))" << " sqr(double(i))" << endl; for (int i=0; i<10; i++) { cout << setw(16) << i << setw(16) << sqr(i) << setw(16) << sqr(float(i)) << setw(16) << sqr(double(i)) << endl; } // Local auxiliary functions template T sqr(T x) { return x * x; } Templates can reduce code duplication dramatically

30. FALL 2001ICOM 4015 - Lecture 229 Output [bvelez@amadeus] ~/icom4015/lec09 >>sqr i sqr(i) sqr(float(i)) sqr(double(i)) 0 0 0 0 1 1 1 1 2 4 4 4 3 9 9 9 4 16 16 16 5 25 25 25 6 36 36 36 7 49 49 49 8 64 64 64 9 81 81 81 [bvelez@amadeus] ~/icom4015/lec09 >>

31. FALL 2001ICOM 4015 - Lecture 230 Anatomy of a Function Template template function Templates are C++’s implementation of Parametric Polymorphism Inside this function T represents any type T is a type parameter

32. FALL 2001ICOM 4015 - Lecture 231 Example 2 // Standard C++ header files #include // Forward definitions of local auxiliary functions template void swap(T& a, T& b); template void doSwap(T a, T b); // Main function int main() { cout << "***** doSwap(1,0)" << endl; doSwap(1,0); cout << endl << endl << "***** doSwap(1.0/3.0, 2.0/3.0)" << endl; doSwap(1.0/3.0, 2.0/3.0); cout << endl << endl << "***** doSwap(true, false)" << endl; doSwap("hello", "world"); } // Local auxiliary functions template void doSwap(T a, T b) { T x = a; T y = b; cout << "x = " << x << " y = " << y << endl; swap(x,y); cout << "swap(x,y)" << endl; cout << "x = " << x << " y = " << y << endl; swap(x,y); cout << "swap(x,y)" << endl; cout << "x = " << x << " y = " << y << endl; } template void swap(T& a, T& b) { T temp = a; a = b; b = temp; } Variable declaration of type T

33. FALL 2001ICOM 4015 - Lecture 232 Example 2 Output [bvelez@amadeus] ~/icom4015/lec09 >>swap ***** doSwap(1,0) x = 1 y = 0 swap(x,y) x = 0 y = 1 swap(x,y) x = 1 y = 0 ***** doSwap(1.0/3.0, 2.0/3.0) x = 0.333333 y = 0.666667 swap(x,y) x = 0.666667 y = 0.333333 swap(x,y) x = 0.333333 y = 0.666667 ***** doSwap(true, false) x = hello y = world swap(x,y) x = world y = hello swap(x,y) x = hello y = world

34. FALL 2001ICOM 4015 - Lecture 233 Procedural Abstraction V Function Overloading Summary of Concepts Related functions can be grouped under a common name Overloaded functions may have different return types, but must have different parameters. The importance of overloading will become clearer when we get into classes and object- oriented programming

35. FALL 2001ICOM 4015 - Lecture 234 Procedural Abstraction V Function Templates Summary of Concepts Programmer declares one function parameterized over some type T Compiler instantiates potentially many functions for all the different argument types provided among all function calls Instances must be well typed, that is, all objects should only be used according to their types.