Defining a Function Parameter Again as a Local Variable Within the Function Is a Logic Erro

Examples:

          int add together( int a, int b );         int  add( int, int );

Exercise:  Write function prototypes for:

1. A function which takes an int and a float, and returns a double.
   • Reply: double myfunction( int, float );
2. A function which takes no arguments and returns no value.
   • Reply: void yourfunction( void );

Functioning

Calling a Office

• A function is called by using the office proper noun, followed by a set of parentheses containing the data to be passed to the part.
• The data passed to the function are referred to as the "actual" parameters.  The variables inside the function which receive the passed data are referred to as the "formal" parameters.
• The formal parameters are local variables, which exist during the execution of the role only, and are just known by the called function.  They are initialized when the function starts by copies of the data passed as actual parameters.  This mechanism, known as "laissez passer past value", ensures that the called part can not directly change the values of the calling functions variables.  ( Exceptions to this will be discussed later. )
• To call a function which takes no arguments, utilize an empty pair of parentheses.
• Example:         full = add together( five, 3 );
• VERY Important: It is crucial that the number and types of actual parameters passed match with the number and types of parameters expected by the functions formal parameter list. ( If the number of arguments matches but the data types do not, and then the compiler MAY insert some type conversion code if the correct data types are known, only information technology is safer not to rely on this. )
• NOTE Advisedly: The bodily parameters passed by the calling program and the formal parameters used to receive the values in the called role volition often take the same variable names. Still information technology is very important to recognize that they are totally different independent variables ( considering they be in different scopes , see below ), whether they happen to have the same name or not.
  • Case: In the lawmaking below, the variables x, y, z, and x once more in primary are used to initialize the variables x, z, b, and c in the function. The fact that x and z appear in both primary and the role is irrelevant - They are independent variables with independent values.

                void func( double x, double z, double b, double c );                  int main( void ) {                      double x( 1.0 ), y( two.0 ), z( 3.0 );                          func( x, y, z, x );

  • The call to the part in a higher place initializes the function parameters equivalently to the following assignment statements:
    • x in func = x in main
    • z in func = y in main
    • b in func = z in main
    • c in func = x in chief

Returning from a Function

• A function may render a single value by ways of the return statement.
• Any variable changes made within a function are local to that function.  A calling function'south variables are not affected by the deportment of a chosen office.  ( When using the normal laissez passer-past-value passing mechanism for not-arrays. See as well the section on alternate passing mechanisms below. )
• The calling role may choose to ignore the value returned by the called part.  For example, both printf and scanf return values which are usually ignored.
• The value returned past a function may be used in a more than circuitous expression, or it may exist assigned to a variable.
• Notation carefully that in the sample programme shown below, it is the assignment statement which changes the value of y in the master program, non the function.

Sample Programme Calling a Part

          int add_two( int x ); // Adds 2 to its argument and returns the result          main() { // <----------------------------------------------------------- int main( void )                      int y = 5;                          cout << "Before calling any function, y = " << y << endl;                          add_two( y );                          cout <<  "After calling the office once, y = " << y << endl;                          y = add_two( y );                          "Subsequently calling the function twice, y = " << y << endl;                          return 0;                      } // main                  int add_two( int x ) { // <---------------------------------------- int add_two( int )              cout <<  "In function, x changed from " <<  x;                          x += 2;                          cout <<  " to " <<  ten << endl;                          return 10;                      } // add_two        

Output:

          Earlier calling whatsoever function, y = 5         In office, x changed from v to 7         After calling the function one time, y = 5         In part, x changed from 5 to 7         Afterwards calling the function twice, y = 7

Data Passing Mechanisms

Pass Past Value

• Ordinary data types ( ints, floats, doubles, chars, etc ) are passed by value in C/C++, which means that only the numerical value is passed to the role, and used to initialize the values of the functions formal parameters.
• Under the pass-by-value machinery, the parameter variables within a function receive a copy of the variables ( data ) passed to them.
• Whatsoever changes made to the variables inside a function are local to that function only, and do not affect the variables in principal ( or any other function called the electric current function. ) This is truthful whether the variables have the aforementioned name in both functions or whether the names are different.

Passing Arrays and/or Array Elements

• When 1 element of an array is passed to a function, it is passed in the same style as the blazon of information contained in the array. ( I.e. pass-by-value for basic types. )
• Nevertheless when the entire array is passed, it is effectively passed past reference. ( Actually by pointer/accost, to be explained completely in the section on arrow variables. )
• Run into "Passing Arrays to Functions" below.

( Laissez passer by Pointer / Address )

• Laissez passer by pointer / address is another type of data passing that volition be covered later under the section on pointer variables.
• ( It is ofttimes mistakenly termed pass-by-reference in some C textbooks, because the actual pass-by-reference passing mechanism is but available in C++. )
• Laissez passer by pointer / address requires utilise of the address operator ( & ) and the pointer dereference operator ( * ), to be covered later.

( Pass past Reference )

• C++ introduced a new passing mechanism, pass by reference , that is not available in ordinary C, and will not exist discussed further in these notes.

Passing Arrays to Functions

• Recall that ordinary data types ( ints, floats, doubles, etc. ) are passed to functions by value , in which the function receives a copy and all changes are local.
• If an individual chemical element of an array is passed to a role, it is passed according to its underlying data blazon.
  • So if nums was declared every bit a 1-dimensional assortment of ints, then passing nums[ i ] to a function would behave the exact way as passing any other int, i.eastward. pass-by-value.
• When an entire array is passed to a function, however, it is finer passed past reference .
  • ( It is actually passed by pointer/address, to exist covered later, but effectively it is pass-past-reference. )
  • The net result, is that when an unabridged array is passed to a part, and the part changes variables stored in that assortment, information technology does affect the data in the calling office's assortment.
  • Considering arrays are passed by reference, there is by and large no need for a function to "return" an array. - It merely needs to fill in an array provided by the calling function. ( It is possible for functions to render arrays but it requires the utilize of pointers and addresses, and frequently dynamic retentiveness allocation, none of which nosotros are ready for nevertheless. )
  • In guild to prevent the part from changing the array values, the array parameter can be modified with the keyword const.
    • Due east.yard. "void printArray( const int information[ ], int nValues );"
• When an entire array is passed to a function, the size of the array is usually passed as an additional argument.
• For a one dimensional assortment, the function's formal parameter list does not need to specify the dimension of the assortment.  If such a dimension is provided, the compiler will ignore information technology.
• For a multi-dimensional array, all dimensions except the first must be provided in a functions formal parameter list.  The get-go dimension is optional, and will exist ignored by the compiler.
• [ Advanced: A partially qualified multi-dimensional assortment may be passed to a function, and will be treated as an assortment of lower dimension.  For instance, a single row of a ii dimensional array may be passed to a function which is expecting a i dimensional array.  ( Question:  Why is it possible to pass a row this way, simply not a cavalcade? ) ]
• Examples: Annotation the use of arrays and functions in the post-obit sample plan.  Note that in the calculation of max4, nosotros accept passed a ii dimensional array containing two rows of three elements as if information technology were a single dimensional array of 6 elements.  This is cheating, but it happens to work considering of the way that the rows of a multidimensional assortment are stored.

            /* Plan Illustrating the apply of Arrays and Functions */                  #include <stdlib.h>         #include <stdio.h>                  // Finds max in the array         double maxArray( const float numbers[ ], int arraySize );                   int primary( void ) {                      double array1[ ] = { 10.0, 20.0, 100.0, 0.001 };             double array2[ 2 ][ iii ] = { { 5.0, 10.0, xx.0 },                                         { viii.0, 15.0, 42.0 } };                          int sizes[ 2 ] = { 4, iii };             double max1, max2, max3, max4, max5;                          max1 = maxArray( array1, 4 );             max2 = maxArray( array1, sizes[ 0 ] );             max3 = maxArray( array2[ i ], 3 );            // Advanced            max4 = maxArray( array2[ 0 ], 6 );            // Very Avant-garde            max5 = maxArray( array1, -iv ); // Generates an fault - returns 0.0;                         printf( "Maximums are %f, %f, %f, %f, and %f\north", max1, max2, max3, max4, max5 );             return 0;                      }                  double maxArray( const double numbers[ ], int arraySize ) {                      /* Function to find the maximum in an array of doubles                Notation the utilize of the keyword "const" to prevent irresolute assortment data */                          int i;             double max;              if( arraySize <= 0 ) {                 render 0.0;             }                                     max = numbers[ 0 ];                          for( i = 1; i < arraySize; i++ )                 max = ( numbers[ i ] > max ) ? numbers[ i ] : max;                              return max;                      }

• New: In C99 it is possible to declare arrays using variable dimensions, providing the variable has a ( positive integer ) value at the time the declaration is made. It turns out that this carries over to the announcement of arrays in part parameters as well, which can be particularly useful for multi-dimensional arrays.
• For instance, in the image:

int arrayFunction( int nRows, int nCols, double 10[ nRows ],                     double y[ nRows ][ nCols ] );

the variable dimension on ten is informative to the human being simply not necessary for the computer, since we could have alleged it equally 10[ ]. However the nCols dimension on y is very useful, because otherwise the part would have to exist written for arrays with pre-determined row sizes, and now we tin write a function that will work for arrays with any row length.

Using Arrays to Return Multiple Values from Functions

• Based on what we have learned so far, functions tin only render a single value, using the "return" mechanism.
• One way around that limitation is to laissez passer an array to the part, and to let the function fill up in the assortment.
  • The size of the assortment could range from a single element to as many values as you desire the function to return.
  • The difficulty is that all the array elements must be the same type, and do non get separate names.
  • For instance, some of the earlier code could be improved to return an error lawmaking as well every bit a result:
  • The maxarray function shown above tin now exist improved as shown below. Programs using the improved version of maxArray should check the value of errorCode[ 0 ] before using the results.
• Eventually nosotros volition learn how to get around this limitation using arrow / address statement passing, and/or structs.
  • ( Global variables, discussed beneath, can likewise technically become effectually this limitation, but there are very good reasons for avoiding global variables at all times unless absolutely necessary. )
• Improved maxarray code:

            double maxArray( const double numbers[ ], int arraySize, int errorCode[ ] ) {                      /* Part to find the maximum in an assortment of doubles                Note the use of the keyword "const" to prevent changing assortment data */                          int i;             double max;              if( arraySize <= 0 ) {                 errorCode[ 0 ] = -1;  // Errors found in input.  Results invalid.                 return 0.0;             }              errorCode[ 0 ] = 0;  // No errors in input                                     max = numbers[ 0 ];                          for( i = 1; i < arraySize; i++ )                 max = ( numbers[ i ] > max ) ? numbers[ i ] : max;                              return max;                      }          

Exercises

Write the following functions:

• double average( const double x[ ], int nValues );
  • Calculates the average of the values in ten.
  • nValues is how many elements to calculate
  • Function should return 0.0 if errors are encountered
• double dot( const double x[ ], const double y[ ], int nValues );
  • Calculates the dot production of 10 and y.
  • nValues is how many elements to summate
  • Function should return 0.0 if errors are encountered
• int calcSins( const double x[ ], double sinX[ ], int nValues );
  • Calculates the sin of each element of x, and stores the results in sinX.
  • nValues is how many elements to calculate
  • The render value is the actual number of values calculated. It should be equal to nValues if all goes well, or some other value ( e.g. zero ) if in that location is a problem.

Recursion

• Any part in C may call whatever other function, including itself!
• When a function calls itself, it is called recursion.
• Information technology is also possible for a set up of functions to exist circularly recursive, in which a function does non call itself directly, but does so indirectly through some other function(s). ( E.g. function A calls function B which calls role C which calls function A. )
• A very of import issue when writing recursive functions is that at that place be a defined stopping condition that will end the recursion and forestall it from calling itself forever in an infinitely recursive loop, and that in that location exist a guarantee that once the function is called, it will eventually reach that stopping condition.
• The classic instance of recursion is the calculation of factorials.
  • The definition of the factorial of 10, denoted as X! , is the product of 10 * ( Ten - ane ) * ( 10 - 2 ) * . . . * 1.
  • Ten! can likewise exist defined recursively as:
    • X! = 1 for all X less than or equal to ane
    • X! = X * ( X - 1 )! for all X greater than i
  • This can be programmed as:

                  long int factorial( int X ) {          	if( X <= 1 )             	return 1;              return X * factorial( 10 - 1 );         }

Character Strings as Arrays of Characters

• The traditional method for handling character strings in C is to utilise an array of characters.
• A null byte ( character constant cipher, '\0' ) is used equally a terminator signal to marker the stop of the string.
• Ordinary quoted strings ( "Please enter a number > " ) are stored equally null-terminated arrays of characters.
• The string library contains a number of functions for dealing with traditional arrays of characters.
  • ( #include <cord.h> )

Variable Scope

• Variable scope refers to the range ( the telescopic ) in which a variable is defined and in which information technology exists.
• In that location are four variable scopes: ordinary local variables, role parameters, global variables, and very local variables.

  Ordinary Local Variables

  • Most of the variables that we accept used so far are ordinary local variables.
  • Ordinary local variables are alleged inside of a function, and outside of whatever braced blocks such every bit while or for loops.
  • The scope of these variables ( the range in which they exist and are valid ) is from the point of their declaration to the stop of the role.
  • Every bit a general dominion, all ordinary variables are ordinarily declared at the very beginning of a function.
    • This was required in traditional C, but is simply a programming style in C99.
    • Programmers who work from printouts, and/or who have all-encompassing programming experience in C, tend to ascertain all their variables at the outset of each part. This has the reward, especially when working from printouts, of listing all variables in one place, equally a sort of comprehensive inventory or checklist.
    • Programmers who work mostly or exclusively on the screen, peculiarly those who learned to plan originally in C++ and not C, may prefer to declare their variables as shut to where they are first used every bit possible. This has the advantage of keeping variable declarations and their use on the same screen, or at least within a short distance of each other. There is as well some argument for improving compiler optimization performance and for avoiding conflicts with other variables having the same names. ( See "very local variables" and "variable eclipsing" below. )
    • For this form yous may use either mode that you wish, provided you are consistent.
  • Ordinary local variables are not initialized automatically. They must be initialized by the developer, or else they will first out with unknown random values. ( Possibly zeros in some cases, merely you lot can't count on that. )

  Part Parameters

  • Part parameters accept the same telescopic as ordinary local variables.
  • The merely departure is that part parameters get initialized with the values passed to them by the calling role.

  Global Variables

  • Global variables are declared outside of any office, unremarkably at the very beginning of the file.
  • The scope of global variables is from the point of declaration down to the end of the file.
    • ( Global variables can be made available to functions in other files also, simply that is across the telescopic of these notes. )
  • Global variables are accessible to all functions within a file ( beyond the point of declaration ), without having to be passed.
  • Global variables introduce many opportunities for very hard-to-notice bugs, as any role can change them and information technology can often exist very difficult to effigy out how a global variable is beingness changed.
  • Some systems may initialize globals to zero ( encounter static storage below ), but you should non count on that.
  • Global variables should be avoided whenever possible. Showtime programmers should not use global variables.
    • Globals are almost often required when using callback functions, non covered in this course.
    • The introduction of Exceptions in C++ ( likewise not covered in this course ) has eliminated much of the former need for global variables.

  Very Local Variables

  • Variables declared within a { braced cake }, such as a loop, if, or switch construct are termed very local variables.
  • The telescopic of very local variables is from the point of annunciation to the end of the cake in which they are alleged.
    • ( They should normally be alleged at the kickoff of the block. )
  • Programmers sometimes declare very local variables for temporary variables that are only needed within a particular block.
    • This is usually done to avoid proper name conflict problems with other variables having the same proper name alleged in a more than general telescopic. ( See eclipsing beneath. )
  • Very local variables can make code hard to read and empathise, and should simply be used when there is a very expert reason to do and then.
  • One mutual use of very local variables is in the code fragment:

                for( int i = 0; i < limit; i++ ) {

• In this case the loop counter i exists within the body of the loop, and ceases to be when the loop exits.
• In that location will be no conflict between this variable i and whatsoever other declared at a more general telescopic. ( See below. )

• If you cull the variable declaration fashion of declaring all ordinary local variables at the beginning of the function, then any very local variables y'all declare should be declared at the starting time of the block in which they are defined.

Variable Eclipsing

• If the same variable name is used in multiple scopes ( due east.yard. global, local, very local ), and the scopes overlap,so in the regions of overlap the more specific variable will eclipse, or hibernate the more general variable(s).
• When the more specific variable goes out of telescopic, and so the next more general variable becomes visible once more, unchanged by any may accept occurred while it was eclipsed.
• Instance. In the code beneath the comments indicate which X will exist printed at which locations.

              void func( int );          double x( 0.0 ); // Global scope          int chief( void ) {              printf( "First x = %f\n", ten ); // prints the global, 0.0                  int x = 42;   // Ordinary local                  printf( "Second x = %d\north", x ); // prints the ordinary local, 42                  if( ten > 40 ) {                      char x( 'A' ); // Very local, value = 65                          printf( "Third x = %c\n", x ); // Prints very local, 'A'                          func( x ); // Passes the very local char, converted to an int.                      }         printf( "Fifth  10 = %d\n", x ); // Ordinary local 42 once more                  return 0;     }          void func( int x ) { // local parameter          	printf( "Fourth x = %d\north", x ); // Local parameter, 65                  render;     }

Programme Output: Outset x = 0.0 Second x = 42 Third x = A Fourth x = 65 5th 10 = 42

Storage Class

• Variables can be in one of four storage classes, depending on where in figurer memory they are stored.

  Automatic Variables

  • Automatic variables, ( a.k.a. auto variables ) are stored on a data structure known as "the stack".
  • The stack grows and shrinks as a program executes.
  • In particular, when a new part is entered, space is allocated on the stack to store all of the local variables for that part. ( Actually infinite is allocated for each variable at the time when information technology first goes into telescopic, i.east. when information technology is declared. )
  • More than importantly, when the office exits, the stack space allocated to that role is freed upwardly, and becomes available for other uses. ( The stack shrinks. )
  • Local variables, function parameters, and very local variables are ordinarily car variables stored on the stack.
  • Whatsoever data stored in auto variables is lost when the variables go out of telescopic, i.e. when a role exits. The side by side fourth dimension the variable comes back into telescopic ( i.e. when the function gets called again ), the variable is allocated new infinite, and re-initialized if an initialization is given.

  Static Variables

  • Static variables are stored in a separate storage area known as "the heap".
  • Infinite for static variables is allocated one time just, before chief( ) begins, and never expires.
  • Global variables are normally static. Other variables may be declared static.
  • In detail, if part variables are declared as "static", then they are only initialized once, and retain their values between function calls. ( The variables can still become out of scope, but when they come back into scope they will still retain their previous values. )
  • Example: The post-obit code will generate the output shown below the code:

              void staticExampleFunction( void );                          int main( void ) {                              for( int i = 0; i < 5; i++ )                 	staticExampleFunction( );                                      return 0;                              } // main                          void staticExampleFunction( void ) {                              int normalInt = 0;                 static int staticInt = 0;                                  printf( "The normal int = %d.  The static int = %d.\n", ++normalInt, ++staticInt );                                  render;             }

Output:

              The normal int = i.  The static int = 1.             The normal int = 1.  The static int = 2.             The normal int = 1.  The static int = 3.             The normal int = 1.  The static int = 4.             The normal int = 1.  The static int = 5.

• Static variables can be used to count how many times a role is called, or to perform some special behavior the get-go time a function is called. ( Declare a static variable "firstTime" initialized to true. If firstTime is truthful, do the special code and then prepare firstTime to false. )
• Variation: The static keyword practical to a global variable makes information technology global to this file but, and not visible from other files, ( in a multi-file development project. )

Extern Variables

• The "extern" keyword applied to a variable indicates that it is declared and allocated infinite in another file.
• A declaration with the discussion "extern" is like a function prototype - Information technology tells the compiler of the existence of the variable, without actually creating information technology or allocating whatsoever infinite for information technology.
• All such variables must be declared exactly in one case, ( i.eastward. in one file merely of a multi-file development project ) without the "extern", so that space tin can be allocated for it.
• Exterm variables are global in the file in which they are declared without "extern", but may be either local or global in other files.
• Extern will be covered more fully under the topic of multi-file development.

Register Variables

• The keyword "annals" suggests to the compiler that the given variable be stored in i of the CPU registers , ( for faster access ), instead of in regular memory.
• Register variables act as automobile variables, except they do not have an "accost", and so cannot be referred to by arrow variables or past the address operator, &.
• Loop counters are the most common and obvious employ of register variables.
• Modern optimizing compilers have elminated nearly need for the keyword register.

Summary of Variable and Parameter Proclamation Qualifiers

The following example shows all possible qualifiers for variables and part parameters, and how those qualifiers touch the variables in iii key areas:

1. Storage elapsing, indicating whether the detail continues to exist when it goes out of scope ( static storage ), or whether it is re-created and re-initialized every fourth dimension that it goes into telescopic ( car storage. )
2. Telescopic, indicating whether the particular is available to the remainder of the file ( file scope ), or just through the residual of the cake in which it is defined ( block scope. )
3. Linkage, indicating whether the item is as well accessible from other files ( external linkage ) or whether it is private to multiple functions but within this file ( internal linkage ), or whether it is accessible only within a block ( no linkage, i.due east. none. )

              int a;         extern int b;         static int c;                  void f( int d, annals int e ) {         	car int g;             int h;             static int i;             extern int j;             register int thousand;         }

Proper name	Storage Duration	Telescopic	Linkage
a	static	file	external
b	static	file	??? - see below
c	static	file	internal
d	auto	block	none
due east	automobile	block	none
f	auto	cake	none
g	auto	block	none
h	auto	block	none
i	static	block	none
j	static	cake	??? - see below
k	machine	block	none

??? - The linkage for b and j depends on their original declaration, simply are normally external

Inline Functions ( C99 only )

In that location is also one additional qualifier that can be practical to functions only: inline

The ordinary office phone call-and-return mechanism involves a sure corporeality of overhead, to save the state of the original function on the stack, create stack space for a render address and the local ( machine ) variables needed for the new function and its parameters, transfer control to the new role, do the work, store the return value back on the stack, clean upwards the stack, and and then transfer command dorsum to the original calling function.

For certain small fast functions, this overhead can add significantly to the processing time of the office, oftentimes greatly surpassing the effort needed to perform the piece of work of the function.

Therefore the inline qualifier applied to a office suggests to the compiler to simply re-create the instructions for the function into this location in the calling function'south code, instead of invoking all of the overhead of the telephone call and return process.

An alternative to inlined functions is parameterized macros, implemented with #define, which are covered elsewhere.

Related Topics

The post-obit topics are not covered here, merely may exist found in many books on C Programming

• Functions with variable statement lists (. . . )

wyckoffconers41.blogspot.com

Source: https://www.cs.uic.edu/~jbell/CourseNotes/C_Programming/Functions.html

Share this post