- ECE206 Programming
Lecture 12 Function (Advanced Features)
11/13/07
What do you need to know
Fundamentals Function declaration Forward prototype Forward definition Call-by-value vs. callby-reference Command-line arguments Storage class Advanced topics Function overloading Inline functions Functions with default augments * Function templates * Recursive functions * Function pointer
2
1
C++ storage classes - revisit
Each C++ variable has several attributes:
name, type, size, value storage class, scope, linkage
C++ has four storage classes
auto: the default. Variables are automatically created and initialized when they are defined and are destroyed at the end of the block containing their definition. They are not visible outside that block. register: a type of auto variable. a suggestion to the compiler to use a CPU register for performance. static: a variable that is known only in the function that contains its definition but is never destroyed and retains its value between calls to that function. It exists from the time the program begins execution. extern: a static variable whose definition and placement is determined when all object and library modules are combined (linked) to form the executable code file. It can be visible outside the file where it is defined. 3
Example - register
#include <ctime> register int i, j; int starttime, endtime; starttime = clock() for (i=0; i<LARGENUM; i++) ; endtime = clock(); cout << the duration is << endtime starttime;
4
2
A few more things about register
A modern processor normally has at least 32 registers for integer variables and 32 registers for floating point variables Each register is 32 bit or 64 bit depending on different computer architectures An optimized compiler should allocate the most frequently accessed variables in the register with or without explicitly specifying register storage class Theres only limited amount of registers. What if all the registered are occupied?
5
Example static variables
// compute a running avg. of numbers entered by user #include <iostream> using namespace std; float r_avg(int i); int main() { int num; } float r_avg(int i) { static float sum = 0 static int count = 0; sum += i; count++; return sum / count;
do { cout << Enter numbers (-1 to quit): ; cin >> num; cout << Running average is: << r_avg(num); cout << \n; } while (num > -1); return 0; }
6
3
Another example
int Complex::getCount() { return count; }
// class definition // method implementation class Complex { Complex::Complex() public: Complex(); { Complex(float, float); real = 0; imag = 0; ~Complex(); void setComplex(float, float); count++; void printComplex(); } float getReal() const; float getImag() const; Complex::Complex(float a, float b) void setReal(float); { void setImag(float); real = a; imag = b; static int getCount(); count++; private: float real; } float imag; Complex::~Complex() static int count; }; } { count--;
7
Inline functions
Short frequently used functions are good candidates for inline functions. An inline functions body is inserted directly in the compiled code at the point where the function would normally be called. The advantage is efficiency. Like the register keyword, inline is only a suggestion to the compiler.
8
4
Example
// using inline function to calculate the volume of a cube #include <iostream> using namespace std; inline float cube(float s) { return s * s * s; } int main() { float side; cin >> side; cout << The volume of cube with side << side << is << cube(side); return 0; }
9
Default arguments
Default arguments have a defined value if they are not present in the calling parameter list. Default argument must be the rightmost parameters (so they can be omitted). Default arguments must be specified only once (first appearance of function name, usually in function prototype).
10
5
Example
// inline function definition inline int volume (int length, int width = 1, int height = 1) { return length * width * height; } int main() { int v1, v2, v3; v1 = volume (1,5); // value is 5 v2 = volume // (4); value is 4 v3 = volume (2,2,2); // value is 8 } v1 = 1 * 5 * 1 v2 = 4 * 1 * 1 v3 = 2 * 2 * 2
11
No function call!!! Multiple copies of the function implementation in the object code
Function overloading
One of C++s most exciting feature C++ allows several functions with the same name to be defined, as long as the types and/or numbers of their arguments differ. The functions that share the same name are said to be overloaded Function overloading is one way that C++ achieves polymorphism
12
6
// overloading abs() #include <iostream> using namespace std; // abs() is overloaded in two ways int abs(int i); double abs(double d); int main() { cout << abs(-10) << \n; cout << abs(-11.0) << \n; return 0; } int abs(int i) { if (i<0) return -i; else return i; } double abs(double d) { if (d<0.0) return -d; else return d; }
Example
Consider 2 functions located in the standard library: abs(), fabs(). They are first defined by the C language, and for compatibility, are also included in C++. So for similar tasks, programmer has two names to remember, not just one. C++ can resolve this problem by function overloading
13
* Function Templates
Function templates allow the definition of functions independent of the type of the arguments and return value. This implements a philosophy of writeonce / use-anywhere by allowing parameterized types. Templates form the basis for the C++ Standard Template Library (STL) of algorithms, which we will discuss later.
14
7
* A Function Template Example
int maximum ( int value1, int value2, int value3 ) { int max = value1; if ( value2 > max ) max = value2; if ( value3 > max ) max = value3; return max; } template <class T> T maximum ( T value1, T value2, T value3 ) { T max = value1; if ( value2 > max ) max = value2; if ( value3 > max ) max = value3; return max; }
int main() { int a=1,b=3,c=3; int m; m = maximu<int>(a, b, c); return 0; }
A list of formal type parameters, preceded by the class keyword, is specified 15 between the <>, and is used in place of types in the function definition.
* Recursion
Recursive functions calls itself (directly or through another function). Any C++ function call call itself, but functions that use static and extern variables must do so carefully. Recursion can be used to solve problems by induction:
Do one step, and call itself to solve the remaining problem. Detect and perform the last step (base case).
16
8
...