1. FUNCTION DEFINITION. // Square root function. #include <iostream.h> #include <math.h> void main() { double x=25, y=0;

Transcription

1 Object Oriented Programming in C++ Function and Pointers Up to now we have only used one function main() in our C++ program. In is section we will learn how to create functions which you will be able to use as building blocks to create your own programs. This section will also illustrate the use of pointers to return data from functions. The functions available in C++ come in two forms. First, the built in functions that are made available through system defined header files (eg. iostream.h) and secondly the functions that are user defined, which reside in user defined header files. We have already studied about the built in functions and how these can be called. An example program using system defined function is given below. // Square root function. #include <math.h> void main() double x=25, y=0; y=sqrt(x); cout << "The square root of " << x << " is " << y << endl; 1. FUNCTION DEFINITION We now look at the main components of a user defined function via an example. We also use this example to point out the two different ways in which the function prototype can be defined. Note how the function accepts parameters and returns the computed variable. Only a single value can be returned from a function. You will see that this limitation can be overcome by using various other data structures to return data. Using return without an argument will return the function to the calling environment immediately. Calling return with an argument will return the function to the calling environment with the argument value. Note that if the return variable type is not the same as what is specified in the function definition, the program will return a warning at the time of compilation. That is, the type will be explicitly type cast to the calling variable type.

2 // Finding the of two integers int min(int x, int y) if (x<y) return x; else return y; void main() int j,k,m; cout << "Input two integers: "; cin >> j >> k; m = min(j,k); cout << \n << m << " is the minimum of " << j << " and " << k << endl; int min(int x, int y); void main() int j,k,m; cout << "Input two integers: "; cin >> j >> k; m = min(j,k); cout << \n << m << " is the minimum of " << j << " and " << k << endl; int min(int x, int y) if (x<y) return x; else return y; User defined functions can be placed in an external header file if needed. For example, if the function min is placed in a file called myheader.h the program should contain a preprocessor directive #include "myheader.h" at the beginning of the file. Note that now the header file is defined using quotes. If the header file is not placed in the same directory as the file containing the main function, the absolute path should be specified. 2. FUNCTION OVERLOADING The C++ language allows you to have functions with the same name in a file. However the list of function arguments should be different. This will enable the compiler to differentiate the functions. This process is known as function overloading and is a feature unique to the C++ language. The two types of function overloading; one depending on the number of arguments and the other depending on the type of argument is given below. // Multiple argument overloading void Say(int N1); void Say(int N1, int N2); // Argument type overloading void Say(char C); void Say(int I); 3. STATIC STORAGE CLASS The static storage class can be used for variables within functions as well as defining the function itself as static.

3 3.1 Static variables A variable of type static is immortal between function calls. the following program demonstrates that the value of a variable of static storage class is retained between function calls. // Program to demonstrate the static storage class void Say(void); void SaySay(void); void main(void) float x; // local variable x = 1.0; cout << "Main " << x << endl; Say(); x = 2.0; cout << "Main " << x << endl; SaySay(); x = 3.0; cout << "Main " << x << endl; void Say(void) static float x; //Local static variable cout << "Say " << x << endl; x += 1.0; cout << "Say " << x << endl; void SaySay(void) Say(); The program when executed outputs the following Main 1 Say 0 Say 1 Main 2 Say 1 Say 2 Main 3 As you can see, during the first call, Say() outputs Say 0 and Say 1. The first output 0 is an illustration of the fact that the static variables, like global ones, are initialized to 0. The next output shows that the function has added 1.0 to this variable. During the subsequent calls, Say() outputs Say 1 and Say 2. The first 1 is the x value which this variable retained after the first call. This shows that a static variable is not destroyed during the breaks between calls to the function in which it is declared. 3.2 Static functions To demonstrate the use of static as a storage class for functions we will use several definitions of functions that reside in files other than the file containing the main program. In order to make the function definitions available to all files we use the keyword extern. The keyword extern tells the compiler to look for it elsewhere, either in this file or some other file. Thus the two files can be compiled separately. If its in the Visual C++ IDE, the file with external function definitions can be attached as an additional C++ source/header file. Hence at the time of building the IDE, all files will be explicitly compiled.

4 // File 1: contains the main function call static void StaticFunction(); extern void ExternFunction(); int main() cout << "File 1. Main function calls ExternFunction\n"; ExternFunction(); cout << "File 1. Main function calls StaticFunction\n"; StaticFunction(); return 0; static void StaticFunction() cout << "File 1. StaticFunction is speaking\n"; // File 2. Static function with the same name static void StaticFunction(); extern void ExternFunction(); extern void ExternFunction() cout << "File 2. ExternFunction is speaking\n"; cout << "File 2. ExternFunction calls StaticFunction\n"; StaticFunction(); static void StaticFunction() cout << "File 2. StaticFunction is speaking\n"; The output of this program is File 1. Main function calls ExternFunction File 2. ExternFunction is speaking File 2. ExternFunction calls StaticFunction File 2. StaticFunction is speaking File 1. Main function calls StaticFunction File 1. StaticFunction is speaking One can see that both files have a function called StaticFunction() with the same declaration. The keyword static makes StaticFunction() in file 2 invisible from the outside, for example to file 1. In the program in file 1, the compiler does not hesitate over which of the two StaticFunction() to call here. In this context it sees only the definition in its file. The same applies to the function StaticFunction() in file 2. So declaring a function as static makes it visible only within the limits of the file where it is defined.

5 4. POINTERS In this section we will see how pointers can be used to return more than one value from a function. Hence we discuss the usage of pointers. Pointers are used in programs to access memory and manipulate addresses. if v is a variable, then &v is the address, or location, in memory of its stored value. The declaration int* p; sets p to be of type pointer to int. The operator * is called the dereferencing or the indirection operator. The following program illustrates the definition procedure for pointers: int i=5, j; int* p=&i; // pointer initialized to address of i cout << *p << " = i stored at " << p << endl; j = p; // illegal pointer not convertible to integer j = *p + 1; // legal and will result in j=6 p = &j; // the pointer p now points to j Passing a pointer to a function will result in the value of the variable in the calling environment to be changed from within the called function. For example // Pointer-based call-by-reference example void order(int*, int*); int main() int i=7, j=3; cout << i << \t << j << endl; // 7 3 is printed order(&i,&j); cout << i << \t << j << endl; // 3 7 is printed void order(int* p, int* q) int temp; if (*p > *q) temp=*p; *p=*q; *q=temp; 4.1 Arrays and Pointers Arrays and array manipulations are closely related to the pointers described above. The definition of an array A[3]=1,2,3, the expressions *A = 1, *(A+1) = 2 and *(A+2) = 3. Hence now passing A or &A[0] into a function will result in the entire set of values to be transferred into the function as parameters and furthermore, the entire set of values can also be returned from a function by merely returning a pointer. For example

6 void order1(int* a); int * order2(int* a); int main() int A[]=7,3; int* p=a; // initializing the pointer cout << *A << \t << *(A+1) << endl; order1(a); cout << *A << \t << *(A+1) << endl; p=order2(a); //pointer to int is returned cout << *p << \t << *(p+1) << endl; void order1(int* a) int temp; if (*a > *(a+1)) temp=*a; *a=*(a+1); *(a+1)=temp; int * order2(int* a) int temp; if (*a < *(a+1)) temp=*(a+1); *(a+1)=*a; *a=temp; return a; The output of the program will print the following Note that both functions essentially use the matrix A in the same manner. In general when a variable is input as a parameter to a function a new copy (or memory location) is what gets passed into the function. However when a variable is passed into a function by means of a pointer, a new copy is not created, the reference to its address location is what gets passed into the function. Hence pointer arithmetic is efficient since it uses less memory. This is clearly seen in function order1() where the array is passed into the function by reference and nothing is returned; however the manipulation carried out within the function is available inside the main() function. In order2() the pointer that was passed into the function is passed out too. However it is seen that this is unnecessary unless one dynamically changed the allocation pointed too by the pointer that is passed into the function. Exercise 1. Write a program that performs string reversal using pointer arithmetic. Exercise 2. Write a program to compare two given strings. Modify the program to identify if the first n locations of the two strings match.

7 4.2 Strings and Pointers The type char* is taken to be a pointer to a string. In general the string variable is terminated by a null character which is also the char value zero. Note that the for the following initialization the null terminator is a part of the initialization. char* s = "C++"; // s[0]= C, s[1]= +,s[2]= +, s[3]=0 The cstring.h contains many other definitions that can be used for string related manupulations. 5. DYNAMIC ARRAY ALLOCATION Dynamic array allocaitons can be carried out by using the operators new and delete. Thelifetime of the memory allocated for objects can be directly controlled by the user. The programmer can create the array object using new. The following is an example of creating a dynamic array for storage. void main(void) int x, i; int *p; cout << "Enter numbers : "; cin >> x; p = new int[x]; for(i=0;i<x;i++) cout << "Enter value " <<i+1<<" : "; cin >> p[i]; The creation can also be done using new int(x) statement. Then the allocation will be initialized. The object can be destroyed using the statements delete expression or delete [] expression. The first form are for simple variables and the second form is for arrays. 6. STORAGE CLASS REGISTER The storage class register tells the compiler that the associated variables should ne stored in high-speed memory registers. Common candidates for this type of storage is the index variable in a for loop structure. for(register i=0;i<x;i++). Exercise 3. Perform a string reversal using storage allocation with new. Assume that s1 ends up with the reverse of the string s2, and use the new to allocate s1 of length strlen(s2)+1, which is adquate to store s1.