Functions

• The C language is built on the concept of building blocks, called functions.
• A C program is a collection of one or more functions.
• A function is a collection of one or more related C statements that performs a specific task (such as printing, inputting data, sorting an array, calculating cube root, etc.)
• A function is independent. That is, it can perform its task without interference from or interfering with other parts of the program.
• An opening brace has to precede the first statement in the function and a close brace ends the function.
• Each function has an unique name. The name main is a reserved name. The program can execute the statements inside a function by calling the function. A function can be called from within another function.
• A function can (optionally) return a value to the calling program.
• A function also has zero or several arguments. An argument is a value that is passed into the function. Function arguments are separated by commas.

The general format of a function is:

type function_name(parameter list) 
{         /* opening brace begins the body of the function*/
          The 
          body of
          the func
          comes here
     /* Each statement ends with a semicolon*/
}         /* closing brace ends the function*/

Function Header:   type function_name(parameter list) 

Return data types- Examples:

int func1(....)
float func2( ...)
void func3(...) 

Function Name: examples:

func1(int x, float y, char z)
func2(void)

Example:
#include <stdio.h>
long cube(long  x);  /*this is a function prototype containing
                 the name, the list of variables passed to it, and the
                 type of variable  it returns */
void main()
{
  long input, answer;
  printf("Enter an integer value: ");
  scanf("%d", &input);
  answer = cube(input);
  /* Note: %ld is the conversion specifier for */
  /* a long integer */
  printf("\nThe cube of %ld is %ld.", input, answer);
}
long cube(long  x)
{
  long x_cubed;
  x_cubed = x * x * x;
  return x_cubed;
}

Example:
#include <stdio.h>
long cube(); 
void main()
{
  long input, answer;
  printf("Enter an integer value: ");
  scanf("%d", &input);
  answer = cube(input);
    printf("\nThe cube of %ld is %ld.", input, answer);
}
long cube(x)
long x;
{
  long x_cubed;
  x_cubed = x * x * x;
  return x_cubed;
}

The value of an argument changes :

#include <stdio.h>
float half_of(float);
void main()
{
  float x = 3.5, y = 65.11, z;
  /* In this call, x is the argument to half_of(). */
  z = half_of(x);
  printf("The value of z = %f\n", z);
  /* In this call, y is the argument to half_of(). */
  z = half_of(y);
  printf("The value of z = %f\n", z);
}
float half_of(float k)
{
  /* k is the parameter. Each time half_of() is called, */
  /* k has the value that was passed as an argument. */
  return (k/2);
}

Returning a Value:
- The return statement terminates the function and returns a value to the calling program
- A function can have multiple return statements

Example 1:
int func1(int var)
{
   int x;
   ....
   return x;
}

Example 2:
/* Demonstrates using multiple return statements in a function. */
#include <stdio.h>
int larger_of( int, int);
void main()
{
  int x, y, z;
  puts("Enter two different integer values: ");
  scanf("%d%d", &x, &y);
  z = larger_of(x,y);
  printf("\nThe larger value is %d.", z);
}
int larger_of( int a, int b)
{
  if (a > b)
    return a;
  else
    return b;
}

More on Functions

• C places no length restrictions on the number of statements in a function (it is recommended that you keep them relatively short
• A function cannot contain the definition of another function
• all other statements such as if, loops, assignment are allowed inside a function
• other functions can be called within a function
• if a function takes multiple arguments, they are assigned to function parameters in the same order.

  Function call:     		 funct1(a, b, c);
  Function header:   	void func1(int x, int y, int z)

• an argument can be a valid expression; such as a constant, variable, mathematical or logical expression, or even another function.

  x = half_of(square(half_of(y)));

• multiple functions can be placed in an expression

  x = half_of(y) +  half_of(z);

• return value of a function can be used in an if statement

  if ( half_of(x) > 10)
  {
       statements;
  }

Recursive functions

A function call is within the same function.

Example:
Computing the factorial of a number:
factorial
factorial
factorial

The expression of the value of the factorial of n in terms of the value of the factorial of (n-1) is called a recursive definition, since the value of a factorial is based on the value of another factorial.

int factorial_f(int x)
{
	int result;
	if (x == 0)
		result=1;
	else
		result=x* factorial_f(x-1);
	return(result);
}
main()
{
	int n, fact_value;
	printf("enter value n ?\n");
	scanf("%d",&n);
	fact_value=factorial_f(n);
	printf("it factorial=%d",fact_value);
}

Structured Programming

• Functions allow structured programming in which individual program tasks are performed by independent sections of program code.
• it is easier to write a structured program because
  • complex problems can be broken down into number of smaller simpler programs
  • each task can be performed by a function in which code and variables can be isolated from the rest of the program
  • a programmer can make faster progress by dealing with these relatively simple tasks one at a time
• it is easier to debug a structured program. That is, if a program has a bug, a structured design makes it easy to isolate the problem to a specific section of code (function)
• redundancy can be controlled
• programmers usually take a top-down approach where a program structure resembles an inverted tree. The leaves or tips perform the real work, whereas the functions closer to the trunk direct program execution

main function

• main is a special function since it is the first function called when the program executes.
• The main function can be anywhere in the program, although it is recommended to have it at the beginning of the program for the sake of clarity.
• In a given C program, there has to be one and only one main function.

Declarations of Variables: Storage class

There are three basic places in a C program where variables will be declared:

• Inside function - such variables are local variables.
• Outside all functions - such variables are external variables.

Local Variables

• local variables must be referenced only by the statement that are inside the function (or even a block) in which the variable are declared.
• Local variables are not known to other functions outside their own
• In C, local variables are created when the function (block) is called and destroyed when the function (block) is exited.
• all local variables must be initialized

Automatic versus Static Local variables:

Use a static local variable to retain its value between calls

/* Demonstrates automatic and static local variables. */
#include <stdio.h>
void func1(void);
void main()
{
  int count;
  for (count = 0; count < 20; count++)
  {
    printf("At iteration %d: ", count);
    func1();
  }
}
void func1(void)
{
  static int x = 0;
  int y = 0;
  printf("x = %d, y = %d\n", x++, y++);
}

Replace the above function with the following and observe the result:
void func1(void)
{
  static int x = 0;
  int y ;
  printf("x = %d, y = %d\n", x++, y++);
}

External Variables

• external variables are defined outside of any function (including main)
• the variable definition must be placed before main
• its scope is the entire program. Therefore visible to main and every other function in the program.

  int x = 1; /* global declaration*/
  main()
  {
      {
           {
  	printf("innermost x =%d\n",x);
            }
           printf("middle x = %d\n",x);
       }
       printf("outermost x=%d\n",x);
  }
  
  Program output:
  
  innermost 1
  middle 1
  outermost 1

• if a local variable is defined with the same name, then the local declaration takes effect within its own function.

  int x=1; /* global declaration*/
  main()
  {
          /* Note: there is a conflict of names between 
          global and local variables - the local persists */
          int x;
          x=10;   /* outermost block */
          {
  	int x;
  	x=100;  /* middle block*/
                    {
                          int x;
                          x=1000;  /* innermost block */
  	        printf("innermost x=%d\n",x);
  	   }
  	printf("middle x=%d\n",x);
             }
            printf("outermost x=%d\n",x);
  }
  
  Program output:
  
  innermost 1000
  middle 100
  outermost 10

• use them only when necessary (only if all or most functions use this variable)

Register Variables

• They are stored in the CPU's registers, thus operations can be performed on them much faster as compared to regular variables. Thus frequently used variables can be stored as register variables.
• Register variables are declared as: register int x or register float
• Unlike C, a typical high-level language does not enable a programmer to access a CPU's registers.
• register keyword is only a suggestion but not an order. Depending on the needs of the program, a register may not be available for the variable.

Scope of Variables

Storage Class Lifetime Location of Scope definition

Automatic temporary in a function local

Static temporary in a function local

Register temporary in a function local

External Permanent outside a function global

About this document ...

This document was generated using the LaTeX2HTML translator Version 96.1 (Feb 5, 1996) Copyright © 1993, 1994, 1995, 1996, Nikos Drakos, Computer Based Learning Unit, University of Leeds.

The command line arguments were:
latex2html -split 0 -html_version 3.0 c3.tex.

The translation was initiated by Vijay & on Thu Feb 12 11:03:06 EST 1998