• colocar en la pila el estado actual de las variables del programa principal
• colocar en la pila la dirección retorno de la función (la siguiente instrucción a ser ejecutada luego de regresar de la misma)
• colocar en la pila los argumentos de llamada de la función
• cambiar la dirección del apuntador de programa a la primera instrucción ejecutable de la función que es llamada (esto es propiamente, invocar la función)
• ejecutar la función y al encontrar el return, colocar en la pila el valor de retorno de la misma
• rescatar de la pila la dirección de retorno al programa principal
• rescatar de la pila el estado de las variables del programa (no se bien si estos dos últimos pasos son así o al revés)

int signo = -1;
 
for (i = 1;  i<= n; i++, signo *= -1) 
   pi = pi + signo * 1.0/(2*i+1);

double str_to_dbl( const char *s, int *index_ptr ) {
 
   char c;
   int i;
   int int_start, int_end;		/* indices de inicio y fin de parte entera */
   int frac_start,frac_end;	/* indices de inicio y fin de parte fraccionaria */
   char sign = 0;		/* flag de signo, 1 para negativo */
   double number, base;
 
   /* descartamos espacios en blanco iniciales */
   i = 0;
   while ( s[i] == ' ' )
      i++;
 
   /* reconocemos el carácter de signo (opcional) */
   if ( ( c = s[i] ) == '+' || c == '-' ) {
      if ( c == '-' ) sign = 1;
      i++;
   }
 
   /* reconocemos la parte entera, si la hay */
   int_start = -1;
   while ( ( c = s[i] ) >= '0' && c <= '9' ) {
      if ( int_start == -1 ) int_start = i;
      i++;
   }
   if ( int_start != -1 )
      int_end = i - 1;
 
   /* caracter de punto decimal */
   if ( s[i] == '.' ) {
 
      i++;
      /* reconocemos la parte decimal, si la hay */
      frac_start = -1;
      while ( ( c = s[i] ) >= '0' && c <= '9' ) {
         if ( frac_start == -1 ) frac_start = i;
         i++;
      }
      if ( frac_start != -1 )
         frac_end = i - 1;
   }
 
   /* calcular el número */
   number = 0;
   if ( int_start != -1 ) {
      base = 1;
      while ( int_end >= int_start ) {
         number += (s[int_end] - '0') * base;
         int_end--;
         base *= 10;
      }
   }
   if ( frac_start != -1 ) {
      base = 10;
      while ( frac_start <= frac_end ) {
         number += (s[frac_start] - '0') / base;
         frac_start++;
         base *= 10;
      }
   }
   if ( sign ) number *= -1;
 
   if ( int_start != -1 || frac_start != -1 )
      *index_ptr = i;
   else
      *index_ptr = -1;
 
   return number;
}

if ( int_start != -1 || frac_start != -1 )
   /* ... */

void cuentavocales(char frase[])
{
   int vocales[5] = {0};
   char * fp;
 
   printf("Introduce una frase: \n");
   gets(frase);
 
   /* La idea es que fp recorra el arreglo frase. Se inicializa al primer
    * ELEMENTO (no el primer INDICE) del arreglo. */
   fp = frase;
 
   while ( *fp != '\0' )
   {
      if (*fp=='a'|| *fp=='A') (*vocales)++;
      else if (*fp=='e' || *fp=='E') (*(vocales + 1))++;
      else if (*fp=='i' || *fp=='I') (*(vocales + 2))++;
      else if (*fp=='o' || *fp=='O') (*(vocales + 3))++;
      else if (*fp=='u' || *fp=='U') (*(vocales + 4))++;
 
      fp++;		/* aumentamos el puntero que recorre la frase */
   }
   //Mostramos los resultados por pantalla
   printf("Estadística \n");
   printf("as: %d \n", *vocales);
   printf("es: %d \n", *(vocales + 1));
   printf("is: %d \n", *(vocales + 2));
   printf("os: %d \n", *(vocales + 3));
   printf("us: %d \n", *(vocales + 4));
   printf("\n TOTAL: %d\n", *vocales + *(vocales + 1) + *(vocales + 2)
          + *(vocales + 3) + *(vocales + 4) );
}
 

void cuentavocales2(char frase[5])
{
   int i=0,vocales[5]= {0};
   int * pv;
   pv = vocales;
 
   printf("Introduce una frase: \n");
   gets(frase);
   for(i=0; i<strlen(frase); i++)
   {
      if(frase[i]=='a'|| frase[i]=='A')
         (*pv)++;
      else if(frase[i]=='e' || frase[i]=='E')
         (*(pv+1))++;
      else if(frase[i]=='i' || frase[i]=='I')
         (*(pv+2))++;
      else if(frase[i]=='o' || frase[i]=='O')
         (*(pv+3))++;
      else if(frase[i]=='u' || frase[i]=='U')
         (*(pv+4))++;
   }
 
//Mostramos los resultados por pantalla
   printf("Estadística \n");
   printf("as: %d \n",*pv);
   printf("es: %d \n",*(pv+1));
   printf("is: %d \n",*(pv+2));
   printf("os: %d \n",*(pv+3));
   printf("us: %d \n",*(pv+4));
   printf("\n TOTAL: %d\n",*pv+*(pv+1)+*(pv+2)+*(pv+3)+*(pv+4));
}
 

#include <stdlib.h>
#include <stdio.h>
#include <string.h>
 
/* Imprimir una tabla alineada en columnas, con justificación a la izquierda
 * By Yoel, xD */
int main() {
 
   int i, j;
   int ColumnsWidth[4];
   size_t width;
 
   /* Contenido de la tabla, pones luego el código que la genera */
   char *tabla[2][4] = {{"Hacker", "Perro", "Labrador", "Macho"},
      {"Fugi", "Camaleon", "Silvestre", "Hembra"}
   };
   char *titulos[4] = {"Nombre", "Animal", "Raza", "Sexo"};
 
   for ( j = 0; j < 4; j++ ) {
      ColumnsWidth[j] = 0;
      /* calcula el mayor ancho entre todos los campos de la columna j */
      if ( ( width = strlen(titulos[j]) ) > ColumnsWidth[j] )
         ColumnsWidth[j] = width;
      for ( i = 0; i < 2; i++ )
         if ( ( width = strlen(tabla[i][j]) ) > ColumnsWidth[j] )
            ColumnsWidth[j] = width;
      /* dos espacios adicionales */
      ColumnsWidth[j] += 2;
   }
 
   /* Ahora luego de imprimir cada palabra, colocas espacios en blanco hasta completar
    * el ancho que debe tener la columna, más dos espacios adicionales */
   for ( j = 0; j < 4; j++ ) {
      width = strlen( titulos[j] );
      printf( "%s", titulos[j] );
      while ( width++ < ColumnsWidth[j] ) putchar(' ');
   }
   printf( "\n\n" );
   for ( i = 0; i < 2; i++ ) {
      for ( j = 0; j < 4; j++ ) {
         width = strlen( tabla[i][j] );
         printf( "%s", tabla[i][j] );
         while ( width++ < ColumnsWidth[j] ) putchar(' ');
      }
      printf( "\n" );
   }
 
   return 0;
}

Nombre  Animal    Raza       Sexo    

Hacker  Perro     Labrador   Macho   
Fugi    Camaleon  Silvestre  Hembra