CAAM 420 FALL 2012 Lecture 9. Mishael Owoyemi

Transcription

1 CAAM 420 FALL 2012 Lecture 9 Mishael Owoyemi September 21, 2012

2 Table of Contents 1 Variables Recap and Introduction Recap Introduction Quick Summary Function Introduction Structure of a Function Basic Structure of a Function Scope Scope Analogy Interacting with variables Machine Precision and Pointers Machine Precision Pointers

3 1. Variables 1.1 Recap and Introduction Recap Last lecture we learned that there are two different types of variables with different internal structures: integer variables and floating point variables. Integer variables are quite straight forward (unless it is a negative integer). They binary is used to represent the integer number. Floating Point are more complicated and are made up of multiple parts: the significant, the sign bit, and the exponent Introduction It makes sense for C to represent different types of variables with different variable types. In this lecture we will discuss the most commonly used variable types in C. These include : int float double char variables that are typically 32 bit integer variables. variables that are typically 32 bit floating point variables. variables that are typically 64 bit floating point variables. variables that are used to represent characters. These are typically 8 bit variables and the smallest variable type available in C. Other less well known or less commonly used variable types include the: short int long int long double that are typically 16 bit integer variables. that are typically 32 bit integer variables. that are typically 64 bit floating point variables. Note: There are no variable types smaller than the char. Specifically there is no single bit variable type (sometimes refered to as bool) in C. The main historically reason for the smallest variable type being 8 bit is that when C was being built, it was arranged in segments of bytes (8 bits) and the hardware working with the variables worked in 8 bits. Therefore it did not make sense to have variables of 1 bit (one eighth of a segment). Size of variables also depend on the operating system. To find out the size of a variable type we can print it out with the following code. Code to print the size of variable type : 1 printf ( sizeof ( char ) = %d\n, sizeof ( char )); 2 printf ( sizeof ( int ) = %d\n, sizeof ( int )); 3 printf ( sizeof ( float ) = %d\n, sizeof ( float )); 4 printf ( sizeof ( double ) = %d\n, sizeof ( double )); 5 printf ( sizeof ( short int ) = %d\n, sizeof ( short int )); 6 printf ( sizeof ( long int ) = %d\n, sizeof ( long int )); 7 printf ( sizeof ( long double ) = %d\n, sizeof ( long double )); 3

4 1.2 Quick Summary We have taken a look at the variable types that come pre-packed with C (it is possible to create a new variable types as we will see later on in the course). We know variables have different sizes and identifying the size for each variable type will be important in the future. 4

5 2. Function 2.1 Introduction Now we will move on to the topic of functions. Let us say we want to evaluate this function for many x s. A simple code : 1 float x = 1. 2; 3 4 printf ( f(%f) = %f\n, x, ( oneplusx - 1) / x); We could do something like this and just continue to repeat the same code like so: 1 float x = 1. 2; 3 printf ( f(%f) = %f\n, x, ( oneplusx - 1) / x); 4 5 x = 1. 8; 6 oneplusx = 1. + x; 7 printf ( f(%f) = %f\n, x, ( oneplusx - 1) / x); 8 9 x = 0. 3; 10 oneplusx = 1. + x; 11 printf ( f(%f) = %f\n, x, ( oneplusx - 1) / x); Or we could use a function to accomplish the same task for any x we desire. 1 float x = 1. 2; 2 printf ( f(%f) = %f\n, x, monster (x)); 3 4 x = 1. 8; 5 printf ( f(%f) = %f\n, x, monster (x)); 6 7 x = 0. 3; 8 printf ( f(%f) = %f\n, x, monster (x)); This simple example exemplifies the reason we use functions when coding: we do not want to write the same piece of code over and over again just because we have different inputs. A function allows us to take a piece of code and apply it to multiple inputs without having to rewrite the piece of code over and over again. 2.2 Structure of a Function Basic Structure of a Function What is a function? A function is sequence of operations. Every function is typically made up of a certain specifications that include: 5

6 Name Arguments Return Type Body Scope What the function is called. Variables that are passed into the function for it to use. The type of variable the function returns. The set of statements that define what the function accomplishes (found inside the brackets). The range of the variables of the function These elements are usually arranged as follows: Return Type Name (Arguments){body}, as can be observed in the example function, monster. [3] 1 float monster ( float x){ 3 return ( oneplux - 1) / x; 4 } 2.3 Scope Scope Analogy The scope of a function is marked by the space between the curly braces in the structures. But what is the scope exactly? We can think of functions as islands each with its own set of inhabitants (variables). The function and its variables generally can only see variables that live in the same function and only know of the existence of other functions that are above then in the program. The scope of a function is basically how many other elements can interact with that function. At the moment we have only encountered variables with scopes limited within their functions (islands) which are often refered to as local variables. There also exist variables whose scope reach beyond their function known as global variables [4], but we have yet to discuss these variables. [1] The default scope of a function, includes all functions above the function. So if one wants the scope of the main function to reach all functions in the program, it would have to the last function written in the code. To allow for more flexibility in where a programmer can put each program, the programmer may make use of the prototypes. [2] A prototype is a declaration of the existence of a function. It allows programmers to extend the scope of a function so that other functions can interact with that function without worrying about its physical location in the program file. A prototype acts as a promise between the programmer and the complier that a function that is been prototyped exists in the code and therefore the programmer may use the code. When the complier sees that a function with a prototype has been called, it checks that the called function s structures matches that of its corresponding prototype and expects to find the function of that prototype somewhere in the program file. Like any serious promise, if the programmer fails to follow through on his promise there are grave consequences (the complier will not compile the program). An example of prototype : 1 float monster ( float x); Interacting with variables Even though the variables we are currently interacting with are limited to their functions, it is possible for a varible to interact with a different function. There are two ways for a function to 6

7 interact with a variable from a another function. The first method is by passing a variable into a function through the function s input arguments. When a variable is passed into another function. The original variable is kept intact and untouched and a copy of the variable is sent to the function. Consequently, if one changes the value of a passed in argument, the original variable from which the argument was created stays the same. Therefore in the example case of the monster function shown below the original variable x found in the main function is not changed by the assignment made in the monster function. 1 float monster ( float x){ 3 x = 5. 0; 4 return ( oneplux - 1) / x; 5 } 6 7 main (){ 8 float x = 1. 2; 9 printf ( f(%f) = %f\n, x, monster (x)); 10 } In the above code, variable x in main is still 1.2 but not 5.0. The second method for function to interact with variables within other functions scopes is by a return argument. A return argument allows a function to pass a variable s value from inside its own scope to another function where it can be assigned to a variable. 1 float monster ( float x){ 3 x = 5. 0; 4 float j = ( oneplux - 1) / x; 5 return j; 6 } 7 8 main (){ 9 float x = 1. 2; 10 float p = moster (x); 11 printf ( f(%f) = %f\n, x, p); 12 } The monster function s j value is passed into main function s variable p through a return argument. Note: C is flexible enough that it is possible for one to pass in the wrong input argument type into a function and the program will still compile. For example, the code below would still compile even though the variable type of the input argument of the monster function is a double instead of a float. 1 float monster ( float x){ 3 x = 5. 0; 4 float j = ( oneplux - 1) / x; 5 return j; 7

8 6 } 7 8 main (){ 9 double x = 1. 2; 10 float p = moster (x); 11 printf ( f(%f) = %f\n, x, p); 12 } 8

9 3. Machine Precision and Pointers 3.1 Machine Precision For this class, we used the monster function as an example function. This function is unique because as one approaches machine precision the monster begins to return strange values in which (1 + x) is either over estimated or under estimated. Therefore the smaller the input x for this function, the less likely it is to be give an accurate result. Though this case is not necesarily common it is still important to keep in mind. For more information please click here. 3.2 Pointers Passing the variable to other function by cloning can be a pain, so next class we will work on passing in the actual address of the variable to other function. This address that allows the programmer to more directly interact with passed in variables is known as a pointer. A pointer is simply the offset in memory where the variable can be found. Next class will be explorer pointers in more detail. 9

10 Bibliography [1] C Programming Language. C variables, [2] The Open C Book Project. Function declaration and function prototypes, 2001, 2002, [3] rajkishor09. Function call by name in c programming language, June. [4] tutorialspoint. Variable scope in c++,