Function Basics

Functions in C
Design of Embedded Computer Systems
By Juan C. Giraldo
Department of Electronics
School of Engineering
Pontificia Universidad Javeriana
February 2018
A basic function in C language
declaration-listopt;
return-typeopt
Function( parameter-listopt )
{
statement-listopt;
} /* Function */
Format of a Function in C
return-typeopt
{
statement-listopt;
returnopt;
} /* Function */
return-typeopt
{
statement-listopt;
returnopt;
} /* Function */
The BUMBEST function
A tiny function in C
The SMALLEST function of them all
_(){}
Blocks in C Language
Bloque (in Spanish)
Un bloque permite agrupar a un conjunto de
declaraciones y proposiciones en una unidad
sintáctica.
[ISO/IEC 9899, pag. 131, par. 3]
{
statement-listopt;
} /* block */
Every block has this kind of structure
{
statement-listopt;
} /* block */
for( expopt; expopt; expopt )

{
statement-listopt;
} /* for */
switch( expression )
{
statement-listopt;
} /* switch */
while( expression )
{
statement-listopt;
} /* while */
if( expression )
{
statement-listopt;
} /* if */
if( expression )
{ ... }
else
{
statement-listopt;
} /* if-else */
while( expression ) {
statement-listopt;
if( expression ) {
statement-listopt;
} /* if */
} /* while */
while( expression ) {
statement-listopt;
if( expression ) {
statement-listopt;
} /* if */
} /* while */
… even when it is used in a FUNCTION:
A_Function()
{
statement-listopt;
} /* A_Function */
How to use “return”
Sin un return explícito,
SIEMPRE con la llave de cierre se retorna
int
Dummy()
{
return;
} /* Simple */
“Return statements are optional and they have
the following formats [A&A, 1989, page 5]”:
return;
return exp;
return( exp );
return-type
Ambos son del mismo tipo

Function()
{
...
return( expression );
} /* Function */
¿Qué tipos de datos retorna una función?
return-type
Function()
{
...
return( expression );
} /* Function */
Se puede retornar cualquiera de los tipos escalares (entero, flotante y apuntador).

Adicionalmente se puede retornar un tipo de dato estructura. En C no se puede
retornar ni arreglo, ni función. Sin embargo, si se puede retornar un apuntador a
arreglo y un apuntador a función.
MANY trivial functions
(and others not that trivial)

Function Always_TRUE is always true…
Always_TRUE()
{
return 1;
} /* Always_TRUE */
Function Follower returns what receives
double
Follower( double entrada )
{
return entrada;
} /* Follower */
Function Twos_Complement computes 2’
int
Twos_Complement( int number )
{
number = ~(number);
return number += 1;
} /* Twos_Complement */
Function Twos_Complement computes 2’
void
Twos_Complement(
int *number )
{
*number = ~(*number);
*number += 1;
} /* Twos_Complement */
Function Maximum returns maximum
int
Maximum( int x, int y )
{
return( (x > y) ? x : y );
} /* Maximum */
int main( void )

{
fprintf( stdout, “Max: %d\n”,
Maximum(a,b) );
} /* main */
Function Minimum returns minimum
int
Minimum( int x, int y )
{
return( (x < y) ? x : y );
} /* Manimum */
int main( void )

{
fprintf( stdout, “Min: %d\n”,
Minimum(a,b) );
} /* main */
Function Is_Greater queries for greater
int
Is_Greater( int a, int b )
{
if( a > b )
return 1;
else
return 0;
} /* Is_Greater */
Function Square computes squared
double
Square( double x )
{
return( x * x );
} /* Square */
Function Add does what the name indicates...
Add( int x, int y )

{
return x + y;
} /* Add */
Function Multiply does what the name says...
int
Multiply( int x, int y )
{
return x * y;
} /* Multiply */
Function Divide does what the name says...
double
Divide( double x, double y )
{
return x / y;
} /* Divide */
Function Return_NOTHING hace eso…
Return_TRUE( int a, int b )

{
int add = a + b;
return 1;
} /* Return_TRUE */
Function Anticipated quits before reach end…
Anticipated( int a, int b )

{
return;
/* Nothing is executed */
return a + b;
} /* Anticipated */
Function Not negates what receives…
int
Not( int input )
{
return !input;
} /* Not */
Function And using operator &&
int
And(
int input_1, int input_2 )
{
return input_1 && input_2;
} /* And */
int And( int input_1, int input_2 )

{
if( input_1 && input_2 )
return 1;
else
return 0;
} /* And */
int And( int input_1, int input_2 )

{
int output = 0;
if( input_1 && input_2 )

output = 1;
return output;
} /* And */
Function And WITHOUT using operator &&
int And( int in1, int in2 )

{
int out[] = { 0, 0, 0, 1 };
in1 = (in1 ? 2 : 0);

in2 = (in2 ? 1 : 0);
return out[in1|in2];
} /* And */
Function And WITHOUT using operator &&
int And( int in1, int in2 )

{
int index, out[] = { 0,0,0,1 };
index = (in1 ? 2 : 0);

index |= (in2 ? 1 : 0);
return out[index];
} /* And */
Function Or using operator ||
int Or( int input_1, int input_2 )

{
return input_1 || input_2;
} /* Or */
Function Xor … ¿What does this do?
int Xor( int in1, int in2 )

{
return
Or(In1,In2) && !And(In1,In2);
} /* Xor */
THE END

Function Basics

Uploaded by

Document Information

Original Title

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

Function Basics

Uploaded by

Copyright:

Available Formats

Functions in C

Design of Embedded Computer Systems

for( expopt; expopt; expopt )

Ambos son del mismo tipo

Se puede retornar cualquiera de los tipos escalares (entero, flotante y apuntador).

(and others not that trivial)

int main( void )

int main( void )

Add( int x, int y )

Return_TRUE( int a, int b )

Anticipated( int a, int b )

int And( int input_1, int input_2 )

int And( int input_1, int input_2 )

if( input_1 && input_2 )

int And( int in1, int in2 )

in1 = (in1 ? 2 : 0);

int And( int in1, int in2 )

index = (in1 ? 2 : 0);

int Or( int input_1, int input_2 )

int Xor( int in1, int in2 )

You might also like