Problema 3.6

.
A continuación veremos el código C de las funciones analizadas en HolaMundo.Pascal.

función indexOf

   1:
   2:int indexOf(char *s, char c, int offset)
   3:{
   4:   int i = offset;
   5:   while( i<strlen(s) && s[i]!=c )
   6:   {
   7:      i++;
   8:   }
   9:
  10:   // if "in-line"
  11:   return i < strlen(s) ? i : -1;
  12:}
  13:

Lo único que podemos mencionar es que en la línea 11 utilizamos un if "in-line". Esto implica tomar una decisión en una línea. Funciona así: si la expresión lógica que se encuentra antes del signo de interrogación resulta verdadera entonces el resultado del if será lo que se encuentra entre el signo "?" y los "dos puntos". En cambio, si la expresión lógica resulta falsa entonces el resultado será el valor que se encuentra a continuación de los ":".


función indexOf (sobrecargada)

   1:
   2:int indexOf(char *s, char c)
   3:{
   4:   return indexOf(s, c, 0);
   5:}
   6:

Simplemente invoca a la versión anterior pasándole 0 como offset.

Cabe aclarar que en C no es posible sobrecargar funciones. La sobrecarga es posble en C++.


función lastIndexOf

   1:
   2:int lastIndexOf(char *s, char c)
   3:{
   4:   int i = strlen(s) - 1;
   5:   while( i >= 0 && s[i] != c )
   6:   {
   7:      i--;
   8:   }
   9:
  10:   return i >= 0 ? i : -1;
  11:}
  12:

función substring

   1:
   2:char* substring(char *s, int desde, int hasta)
   3:{
   4:   // aloco memoria para el nuevo string 
   5:   // recordemos que siempre se necesita una posicion
   6:   // mas para el caracter '\0' que indica el fin 
   7:   // del string
   8:   char *sub = (char*) malloc(sizeof(char) *
   9:                              (hasta - desde + 1));
  10:   int i, j = 0;
  11:
  12:   for (i = desde; i < hasta; i++)
  13:   {
  14:      sub[j++] = s[i];
  15:   }
  16:
  17:   // el '\0' lo agregamos "a mano"
  18:   sub[j] = '\0';
  19:   return sub;
  20:}
  21:

función substring (sobrecargada)

   1:
   2:char* substring(char *s, int desde)
   3:{
   4:   // desde - "hasta el final"
   5:   return substring(s, desde, strlen(s));
   6:}
   7:

función replicate

   1:
   2:char* replicate(char c, int n)
   3:{
   4:   char *aux = (char*) malloc(sizeof(char) * (n + 1));
   5:   int i;
   6:   for (i = 0; i < n; i++)
   7:   {
   8:      aux[i] = c;
   9:   }
  10:
  11:   aux[n] = '\0';
  12:   return aux;
  13:}
  14:

funciones xpad

   1:
   2:char* lpad(char *s, char c, int n)
   3:{
   4:   char *ret;
   5:   int len = strlen(s) - 1;
   6:
   7:   if (n <= len)
   8:   {
   9:      ret = (char*) malloc(sizeof(char) *
  10:                                 (strlen(s) + 1));
  11:      strcpy(ret, s);
  12:   }
  13:   else
  14:   {
  15:      ret = (char*) malloc(sizeof(char) *
  16:                        (n - len + strlen(s) + 1));
  17:      ret[0] = '\0';
  18:      strcat(ret, replicate(c, n - len));
  19:      strcat(ret, s);
  20:   }
  21:
  22:   return ret;
  23:}
  24:
  25:char* rpad(char *s, char c, int n)
  26:{
  27:   char *ret;
  28:   int len = strlen(s) - 1;
  29:
  30:   if (n <= len)
  31:   {
  32:      ret = (char*) malloc(sizeof(char) *
  33:                                  (strlen(s) + 1));
  34:      strcpy(ret, s);
  35:   }
  36:   else
  37:   {
  38:      ret = (char*) malloc(sizeof(char) *
  39:                        (n - len + strlen(s) + 1));
  40:      ret[0] = '\0';
  41:      strcat(ret, s);
  42:      strcat(ret, replicate(c, n - len));
  43:   }
  44:
  45:   return ret;
  46:}
  47:
  48:char* cpad(char *s, char c, int n)
  49:{
  50:   char *ret;
  51:   int len = strlen(s) - 1;
  52:   int izq, der;
  53:
  54:   if (n <= len)
  55:   {
  56:      ret = (char*) malloc(sizeof(char) *
  57:                                  (strlen(s) + 1));
  58:      strcpy(ret, s);
  59:   }
  60:   else
  61:   {
  62:      ret = (char*) malloc(sizeof(char) *
  63:                        (n - len + strlen(s) + 1));
  64:      izq = (int) ((n - len) / 2);
  65:      der = (n - len) - izq;
  66:      ret[0] = '\0';
  67:      strcat(ret, replicate(c, izq));
  68:      strcat(ret, s);
  69:      strcat(ret, replicate(c, der));
  70:   }
  71:
  72:   return ret;
  73:}
  74:

funciones xtrim

   1:
   2:char* ltrim(char *s)
   3:{
   4:   int i = 0;
   5:   while (s[i] != '\0' && s[i++] == ' ')
   6:      ;
   7:   return substring(s, i - 1);
   8:}
   9:
  10:char* rtrim(char *s)
  11:{
  12:   int i = strlen(s) - 1;
  13:   while (i >= 0 && s[i--] == ' ')
  14:      ;
  15:   return substring(s, 0, i + 2);
  16:}
  17:
  18:char* ctrim(char *s)
  19:{
  20:   return ltrim(rtrim(s));
  21:}
  22:

funciones toUpperCase, toLowerCase, isEmpty

   1:
   2:int isEmpty(char *s)
   3:{
   4:   return strlen(s) == 0;
   5:}
   6:
   7:char* toUpperCase(char *s)
   8:{
   9:   char *ret=(char*)malloc(sizeof(char)*(strlen(s)+1));
  10:   char c;
  11:   int i;
  12:
  13:   for (i = 0; s[i] != '\0'; i++)
  14:   {
  15:      c = s[i];
  16:      if (c >= 'a' && c <= 'z')
  17:      {
  18:         c = c - 'a' + 'A';
  19:      }
  20:      ret[i] = c;
  21:   }
  22:
  23:   ret[i] = '\0';
  24:
  25:   return ret;
  26:}
  27:
  28:char* toLowerCase(char *s)
  29:{
  30:   char *ret=(char*)malloc(sizeof(char)*(strlen(s)+1));
  31:   char c;
  32:   int i;
  33:
  34:   for (i = 0; s[i] != '\0'; i++)
  35:   {
  36:      c = s[i];
  37:      if (c >= 'A' && c <= 'Z')
  38:      {
  39:         c = c - 'A' + 'a';
  40:      }
  41:      ret[i] = c;
  42:   }
  43:
  44:   ret[i] = '\0';
  45:
  46:   return ret;
  47:}
  48:

En la línea 39 entramos si c es mayor o igual que 'A' y menor o igual que 'Z'. En C los char son valores enteros que coinciden con el código ASCII del caracter.

Analicemos la línea 39:

c = c - 'A' + 'a'

Si c vale 'A' entonces c vale 65, que al restarle 'A' quedará en cero y luego, al sumarle 'a' quedará en el còdigo ASCII del caracter 'a', o lo que es lo mismo: 'a'. Convertimos de mayúscula a minúscula.

Si c vale 'B' entonces la resta c-'A' será igual a 1, sumando 'a' obtendremos 'b' y Asì...


funciones tokenizer, tokenCount y tokenAt

   1:
   2:int tokenCount(char *s, char sep)
   3:{
   4:   int i = 0, n = strlen(s), cont = 1;
   5:   while (i < n)
   6:   {
   7:      if (s[i] == sep)
   8:      {
   9:         cont = cont + 1;
  10:      }
  11:      i++;
  12:   }
  13:
  14:   return cont;
  15:}
  16:
  17:int tokenizer(char *s,char sep,char **buf,int *offset)
  18:{
  19:   int desde, hasta;
  20:   if (*offset > strlen(s))
  21:   {
  22:      return 0;
  23:   }
  24:
  25:   desde = (*offset);
  26:   hasta = indexOf(s, sep, desde);
  27:
  28:   if (hasta < 0)
  29:   {
  30:      hasta = strlen(s) + 1;
  31:   }
  32:
  33:   (*offset) = hasta + 1;
  34:
  35:   strcpy(*buf, substring(s, desde, hasta));
  36:   return 1;
  37:}
  38:
  39:char *tokenAt(char *s, char sep, int i)
  40:{
  41:   int x, offset = 0;
  42:   char *buff;
  43:
  44:   for (x = 0; x <= i; x++)
  45:   {
  46:      //printf("%d-->\n",x);
  47:      tokenizer(s, sep, &buff, &offset);
  48:   }
  49:   return buff;
  50:}
  51:

.