Simtel MSDOS 1992 December

home *** CD-ROM | disk | FTP | other *** search

/ Simtel MSDOS 1992 December / simtel1292_SIMTEL_1292_Walnut_Creek.iso / msdos / pascal / pasctxt.arc / CHAP5.TXT < prev next >

Wrap

Text File | 1988-01-15 | 28KB | 653 lines

CHAPTER 5 - The Pascal procedures and functions In order to properly define procedures and functions we need to lay some groundwork in the form of a few definitions. These are important concepts, so pay close attention. Program Heading - This is the easiest part since it is only one line, at least it has been in all of our programs up to this point. It is simply the "program" line, and it never needs to be any more involved than it has been up to this point in TURBO Pascal. Declaration Part - This is the part of the Pascal source code in which all constants, variables, and user defined auxiliary operations are defined. In some of the programs we have examined, there have been one or more var declarations. These are the only components of the declaration part we have used to this point. There are actually five components in the declaration part, and the procedures and functions are the fifth part. We will cover the others in the next chapter. Statement Part - This is the last part of any Pascal program, and it is what we have been calling the main program. It is one compound statement bracketed with the reserved words "begin" and "end". It is very important that you grasp the above definitions because we will be referring to them constantly during this chapter, and throughout the remainder of this tutorial. With that introduction, lets go on to our first Pascal program with a procedure in it, in fact, it will have three procedures. THE FIRST PROCEDURES Load PROCED1 as your first example file with a procedure and display it on your monitor. You will notice that it doesn't look like anything you have seen up to this point because it has procedures in it. Lets go back to our definitions from above. The first line is the Program Heading which should pose no difficulty. The Declaration Part begins with the var statement in line 4 and continues down through and including all three procedures ending in line 19. Lines 21 through 26 constitute the Statement Part. It may seem strange that what appears to be executable Pascal statements, and indeed they are executable statements, are contained in the Declaration Part rather than the Statement Part. This is because of the Pascal Page 26 CHAPTER 5 - The Pascal procedures and functions definition and it will make sense when we have completed our study of procedures and functions. Continuing to examine PROCED1, we will make note of the program itself, which is the Statement Part. The program, due to the nature of Pascal and the carefully chosen procedure names, clearly tells us what it will do. It will write a header, eight messages, and an ending. The only problem we are faced with is, how will it write these messages? This is where the Declaration Part is called upon to define these operations in detail. The Declaration Part contains the three procedures which will completely define what is to be done by the procedure calls in the main program. It should be clear to you that the definitions of the procedures should be in the Definition Part of the program because that is exactly what they do. In the case of a var, a variable is defined for later use by the main program, and in the case of a procedure, the procedure itself is defined for later use by the main program. Lets arbitrarily pick one of the procedures, the first, and examine it in detail. The first executable statement we come to in the main program is line 22 and says simply, Write_A_Header, followed by the usual end of statement, the semicolon. This is a simple procedure call. When the compiler finds this statement it goes looking for a predefined procedure of that name which it can execute. If it finds one in the Declaration Part of the program, it will execute that procedure. If it doesn't find a user defined procedure, it will search the Pascal library for a system defined procedure and execute it. The Write and Writeln statements are system procedures, and you have already been using them quite a bit, so procedures are not completely new to you. If it doesn't find the procedure defined in either place, it will generate an error message. HOW TO CALL A PROCEDURE To call a procedure, we simply need to state its name. To define a simple procedure, we use the reserved word "procedure" followed by its calling name, with a semicolon as a terminator. Following the Procedure Heading, there is the Declaration Part of the procedure followed by a body which is nothing more than a compound statement bracketed by the reserved words "begin" and "end". This is identical to the Statement Part of the main program except that the procedure ends with a semicolon instead of a period. Any valid Pascal statements can be put between the begin and Page 27 CHAPTER 5 - The Pascal procedures and functions end, and in fact, there is no difference in what can be put in a procedure and what can be put in the main program. The program we are examining would be no different if we would eliminate the first procedure completely and move the Writeln contained in it down to the Statement Part in place of Write_A_Header. If that is not clear, go back and reread the last two paragraphs until it is. Lines 23 and 24 will cause the procedure named Write_A_Message to be called 8 times, each time writing a line of output. Suffice it to say at this time that the value of the variable Count, as defined here, is available globally, meaning anywhere in the entire Pascal program. We will define the scope of variables shortly. Finally, the last procedure call is made, causing the ending message to be displayed, and the program execution is complete. Having examined your first Pascal procedures, there is a fine point that is obvious but could be easily overlooked. We mentioned the unbroken rule of Pascal in an earlier chapter and it must be followed here too. "Nothing can be used in Pascal until it has been defined". The procedures must all be defined ahead of any calls to them, once again emphasizing the fact that they are part of the Declaration Part of the program, not the Statement Part. Compile and run PROCED1 to verify that it does what you expect it to do. MORE PROCEDURE CALLS Assuming you have run PROCED1 successfully and understand its output, lets go on to PROCED2 and examine it. In this program we will see how to call a procedure and take along some data for use within the procedure. To begin with, notice that there are three procedure calls in the Statement Part of the program and each has an additional term not contained in the calls in the last program, namely the variable name Index within brackets. This is Pascals way of taking a variable parameter to the procedure when it is called. You will notice that the variable Index is defined as an integer variable in the very top of the Declaration Part. Since we are taking an integer type variable along when we visit the procedure Print_Data_Out, it had better be expecting an integer variable as input or we will have a type mismatch. In fact, observing the procedure heading itself in line 7, indicates that it is indeed expecting an integer variable but it prefers to call the variable Puppy Page 28 CHAPTER 5 - The Pascal procedures and functions inside of the procedure. Calling it something different poses no problem as long as the main program doesn't try to call its variable Puppy, and the procedure doesn't try to use the name Index. Both are actually referring to the same piece of data but they simply wish to refer to it by different names. Observe that the next procedure is called with Index as a parameter and the procedure prefers to call it by the name Cat. In both cases, the procedures simply print out the parameter passed to it, and each then try to modify the value passed to it before passing it back. We will see that one will be successful and the other will not. We are in a loop in which Count is incremented from 1 to 3 and Pascal does not allow us to modify the loop variable so we make a copy of the value in line 21 and call it Index. We can then modify Index in the main program if we desire. CALL BY VALUE In line 7, the procedure heading does not contain a var in front of the passed parameter and therefore the parameter passing is only one way because of the way Pascal is defined. Without the reserved word var in front of the variable Puppy, the system makes a copy of Index, and passes the copy to the procedure which can do anything with it, using its new name, Puppy, but when control returns to the main program, the original value of Index is still there. The copy of Index named Puppy is modified in the procedure, but the original variable Index remains unchanged. So you can think of the passed parameter without the var as one way parameter passing. This is a "call by value" because only the value of the variable is passed to the procedure. CALL BY REFERENCE In line 13, the second procedure has the reserved word "var" in front of its desired name for the variable, namely Cat, so it can not only receive the variable, it can modify it, and return the modified value to the main program. A copy is not made, but the original variable named Index is actually passed to this procedure and the procedure can modify it, therefore communicating with the main program. The name Catin the procedure is actually another name for the variable named Index in the main program. A passed parameter with a var in front of it is therefore a two way situation. This is a "call by reference" since the reference to the original variable is passed to the procedure. Page 29 CHAPTER 5 - The Pascal procedures and functions SOME NEW TERMINOLOGY The parameter name in the calling program is referred to as the actual parameter, and the parameter name in the procedure is referred to as the formal parameter. In the last example then, the actual parameter is named Index and the formal parameter in the procedure is named Cat. It should be pointed out that it is called a formal parameter whether it is a "call by reference" or a "call by value". This terminology is used in many other programming languages, not only in Pascal. When you run this program, you will find that the first procedure is unable to return the value of 12 back to the main program, but the second procedure does in fact succeed in returning its value of 35 to the main program. Spend as much time as you like studying this program until you fully understand it. It should be noted that as many parameters as desired can be passed to and from a procedure by simply making a list separated by commas in the calls, and separated by semicolons in the procedure. This will be illustrated in the next example program. Compile and run PROCED2 and study the output. You should be able to comprehend all of the output. If it is not clear, reread the last few paragraphs. For your own enlightenment, examine PROCED3 for an example of a procedure call with more than one variable in the call. Normally, you would group the three input values together to make the program more readable, but for purposes of illustration, they are separated. Observe that the variable Fruit is a two way variable because it is the 3rd variable in the actual parameter list and corresponds to the 3rd formal parameter in the procedure header. Compile and run PROCED3 to see that it does what you expect it to do based on the above explanation. "CALL BY REFERENCE" OR "CALL BY VALUE"? It may seem to you that it would be a good idea to simply put the word var in front of every formal parameter in every procedure header to gain maximum flexibility, but using all "call by references" could actually limit your flexibility. There are two reasons to use "call by value" variables when you can. First is simply to shield some data from being corrupted by the procedure. This is becoming a very important topic is Software Engineering known as "information hiding" and is the primary basis behind Object Page 30 CHAPTER 5 - The Pascal procedures and functions Oriented Programming which is far beyond the scope of this tutorial. Secondly is the ability to use a constant in the procedure call. Modify line 17 of PROCED3 as follows; Add_The_Fruit(12,Orange,Fruit,Pear); and compile and run the program. Since Value1 is a "call by value", the constant 12 can be used and the program will compile and run. However, if you change line 17 to; Add_The_Fruit(Apple,Orange,32,Pear); you will find that it will not compile because Total is a "call by reference" and the system must be able to return a value for the formal parameter Total. It cannot do this because 32 is a constant, not a variable. The prior discussion should indicate to you that both "call by value" and "call by reference" have a useful place in Pascal programming and it is up to you to decide which you should use. When you are satisfied with the present illustration, we will go on to study the scope of variables using PROCED4. A MULTIPLY DEFINED VARIABLE If you will examine PROCED4, you will notice that the variable Count is defined twice, once in the main program var block and once in the var block contained within the procedure named Print_Some_Data. This is perfectly legal and is within the Pascal definition. The variable Index is defined only in the main program var block and is valid anywhere within the entire Pascal program, including the procedures. The variable Count is also defined in the main program var block and is valid anywhere within the entire Pascal program, except within the procedure where another variable is defined with the same name Count. The two variables with the same name are in fact, two completely different variables, one being available only outside of the procedure and the other being available only within the procedure. The variable More_Stuff is defined within the procedure, so it is invisible to the main program, since it is defined at a lower level than that of the main program. Any variable is available at any point in the program following its definition but only at the level of definition Page 31 CHAPTER 5 - The Pascal procedures and functions or below. This means that any procedure in the Declaration Part of a program can use any variable defined in the Declaration Part of the program provided that the definition occurs prior to the procedure. Any variable defined in a procedure cannot be used by the main program since the definition is at a lower level than the main program. Be sure to compile and run PROCED4 before continuing on to the next example program. PROCEDURES CALLING OTHER PROCEDURES Load and examine PROCED5 to see an example of procedures that call other procedures. Keep in mind that, "Nothing can be used in Pascal until it has been previously defined", and the order of procedures will be clear in this example. Note that procedure Three calls procedure Two which in turn calls procedure One. Compile and run PROCED5 and study the output until you understand why it outputs each line in the order that it does. Now that you have a good working knowledge of procedures, we need to make another important point. Remember that any Pascal program is made up of three parts, the Program Heading, the Declaration Part, and the Statement Part. The Declaration Part is composed of five unique components, four of which we will discuss in detail in the next chapter, and the last component, which is composed of some number of procedures and functions. We will cover functions in the next example, so for now simply accept the fact that it is like a procedure. A procedure is also composed of three parts, a Procedure Heading, a Declaration Part, and a Statement Part. A procedure, by definition, is therefore nothing more or less than another complete Pascal program embedded within the main program, and any number of procedures can be located in the Declaration Part of the main program. These procedures are all in a line, one right after another. Since a procedure is defined like the main program, it would seem to be possible to embed another procedure within the Declaration Part of any procedure. This is perfectly valid and is often done, but remember that the embedded procedure can only be called by the procedure in which it is embedded, not by the main program. This is a form of information hiding which is becoming popular in modern software engineering. Page 32 CHAPTER 5 - The Pascal procedures and functions The previous paragraph is probably a bit difficult to grasp. Don't worry about it too much now, as you become proficient as a Pascal programmer, you will very clearly see how that is used. NOW LET'S LOOK AT A FUNCTION Now to keep a promise, lets examine the program named FUNCTION to see what a function is and how to use it. In this very simple program, we have a function that simply multiplies the sum of two variables by 4 and returns the result. The major difference between a function and a procedure is that the function returns a single value and is called from within a mathematical expression, a Writeln command, or anywhere that it is valid to use a variable, since it is really a variable itself. Observing the Function Heading of the function, in line 6, reveals the two input variables inside the parenthesis pair being defined as integer variables, and following the parenthesis is a colon and another "integer". The last "integer" is used to define the type of the variable being returned to the main program. Any call to this function is actually replaced by an integer upon completion of the call. Therefore in line 14, the function is evaluated and the value returned is used in place of the function call. The result of the function is assigned to the variable Feet. Note that a function always returns a value and it may return additional values if some of its parameters are defined as "call by reference". Be sure to compile and run this program. NOW FOR THE MYSTERY OF RECURSION One of the great mysteries of Pascal to many people, is the recursion of procedure calls. Simply defined, recursion is the ability of a procedure to call itself. Examine the Pascal example file RECURSON for an example of recursion. The main program is very simple, it sets the variable Count to the value 7 and calls the procedure Print_And_Decrement. The procedure prefers to refer to the variable by the name Index but that poses no problem for us because we understand that the name of the formal parameter can be any legal identifier. The procedure writes a line to the video display with the value of Index written within the line, and decrements the variable. The if statement introduces the interesting part of this program. If the variable is greater than zero, and it is now 6, then the procedure Print_And_Decrement is called Page 33 CHAPTER 5 - The Pascal procedures and functions once again. This might seem to create a problem except for the fact that this is perfectly legal in Pascal. Upon entering the procedure the second time, the value of Index is printed as 6, and it is once again decremented. Since it is now 5, the same procedure will be called again, and it will continue until the value of Index is reduced to zero when each procedure call will be completed one at a time and control will return to the main program. ABOUT RECURSIVE PROCEDURES This is really a stupid way to implement this particular program, but it is the simplest recursive program that can be written and therefore the easiest to understand. You will have occasional use for recursive procedures, so don't be afraid to try them. Remember that the recursive procedure must have some variable converging to something, or you will have an infinite loop. Compile and run this program and observe the value decrementing as the recursion takes place. THE FORWARD REFERENCE Occasionally you will have a need to refer to a procedure before you can define it. In that case you will need a forward reference. The program FORWARD has an example of a forward reference in it. In this program, each one of the procedures calls the other, a form of recursion. This program, like the last, is a very stupid way to count from 7 to 0, but it is the simplest program possible with the forward reference. The first procedure, Write_A_Line, has its header defined in exactly the same manner as any other procedure but instead of the normal procedure body, only the reserved word "forward" is given. This tells the compiler that the procedure will be defined later. The next procedure is defined as usual, then the body of Write_A_Line is given with only the reserved word "procedure" and the procedure name. The variable reference has been defined earlier. In this way, each of the procedure names are defined before they are called. It would be possible, by using the forward reference in great numbers, to move the main program ahead of all procedure definitions and have the program structured like some other languages. This style of programming would be perfectly legal as far as the compiler is concerned, but the resulting program would be very nonstandard and confusing. You would do well to stick with conventional Pascal Page 34 CHAPTER 5 - The Pascal procedures and functions formatting techniques and use the forward reference sparingly. Be sure you compile and run this program. PROGRAMMING EXERCISES 1. Write a program to write your name, address, and phone number with each Writeln in a different procedure. 2. Add a statement to the procedure in RECURSON to display the value of "Index" after the call to itself so you can see the value increasing as the recurring calls are returned to the next higher level. 3. Rewrite TEMPCONV putting the centigrade to fahrenheit formulas in a function call. Page 35