CAPITULO 8: FUNCIONES DE MANEJO DE STRINGS

1. INTRODUCCION

Si bien ya hemos realizado variadas operaciones de manejo de string , dada su importancia, pues son cuando menos el medio de comunicación de los programas con el operador, trataremos acá de sintetizar los conceptos relativos a los mismos, y resumir aquellas funciones ya vistas, con el agregado de otras nuevas.
La mayoría de las que veremos a continuación, responden a la norma ANSI C, por lo que serán independientes del compilador que usemos. Estas tienen sus prototipos definidos en los archivos de encabezamiento stdio.h, stdlib.h, string.h y ctype.h.
Agregaremos tambien algunas que caen fuera de la norma, por lo que su portabilidad a otros compiladores distintos al que fueron extraidas, no es segura. Seran aquellas declaradas en Headers no citados arriba. Sin embargo, hoy en día practicamente todos los compiladores las traen ó tienen otras similares, con nombres parecidos. De cualquier forma, antes de compilar los ejemplos aquí suministrados, en caso de encontrarse alguna de estas, verifique con su manual de Libreria la existencia y compatibilidad de la misma.
Refresquemos, antes de comenzar, algunas de las características básicas de los strings. Estos pueden aparecer en un programa como una constante simbólica, de la forma siguiente:

#define TITULO "Capitulo 9"

en este caso, en cada lugar donde aparece TITULO se reemplazará esta constante simbólica por la DIRECCION de la C del texto con que fué definida .
Así, será correcto escribir:

char *p = TITULO ;

Recordemos tambien que en la memoria, el string se guardará de la siguiente forma:

Donde los números son el código ASCII que representa a cada caracter del string , en particular , note que 20 corresponde al espacio , terminandose con un NULL (código 0 ) .
A los efecttos prácticos, para las funciones de manejo de los mismos, es como si en realidad hubieramos memorizados directamente los caracteres:

El código ASCII de los caracteres imprimibles vá entre el 31 y el 127 , reservándose los códigos entre el 0 y 30 , para los caracteres de control (retorno de carro, avance de linea, tabulador, etc).
Si en cambio , hubieramos escrito el string de una manera ortográficamente más correcta :

#define TITULO "Capítulo 9"

(con la i acentuada) estaríamos introduciendo un caracter del conjunto ASCII Extendido , ya que su código supera a 127 y está representado por 173 .
Lo correcto en este caso sería definir , aunque muchos compiladores ya lo presuponen por omisión, para asegurar la portabilidad :

unsigned char *p = TITULO ;

de esta forma se garantiza que el alcance de la variable sea de 255 , ó en su defecto :

int *p = TITULO ;

Es correcto tambien declarar el puntero , y asignarlo posteriormente

char *p ;

p = TITULO ;

Esta asignación solo dá , al contenido del puntero la dirección del string global predefinido .
Sin embargo , si en lugar de un puntero deseamos usar un array , en este caso es correcta la inicialización del mismo , pero no así su asignación posterior:

char nombre[] = TITULO ;         /* Correcto */

.................

char nombre[11] ;

nombre = TITULO ;                  /* Incorrecto */

Ya que si bien, el nombre de un array es un puntero , es de índole constante , negándose el compilador a cambiar su dirección.
Si estuvieramos en el caso de ingresar un string variable , por ejemplo leyendolo desde el teclado , podríamos utilizar un array, de la siguiente forma :

char nombre[128] ;

scanf("%s" , nombre ) ;

en este caso la única precaución es que , el array tenga suficiente longitud para albergar a cualquier string escrito . En el caso de trabajar bajo DOS, basta con darle 128 caracteres, ya que el buffer de lectura de ese sistema operativo no supera dicha cantidad .
Hay que hacer notar que la longitud de un string puede ser mayor que la del texto válido contenido , ya que este termina donde se encuentra el NULL , quedando los bytes sobrantes desaprovechados .
Seria incorrecto leer este string mediante un puntero declarado , pero al que no se le ha reservado memoria:

char *p ;

scanf("%s" , p )      /* Incorrecto */

ya que la dirección contenida por p no ha sido inicializada aún con ningun valor válido . Lo correcto en éste caso es:

char *p ;

p = (char *)malloc(128 * sizeof(char)) ;

scanf("%s" , p )                           /* Correcto */

reservando memoria previamente a cargar el string.
Otro punto sobre el que quiero volver, a fín de evitar confusiones, es el sentido de la constante NULL , y el de variables nulas.
Segun éste se aplique a caracteres, strings ó punteros, su significado varia:

• Un caracter nulo tiene el valor ASCII cero. Un string siempre estará terminado por un caracter NULL .
• Un string nulo ó vacio, no tiene longitud cero, sino que su primer caracter es un NULL .
• Un puntero nulo, no corresponde a un string vacio, sinó que su contenido ha sido asignado a la dirección 0 ó NULL, es decir que no apunta a ningun string aún.

Hay que recalcar que, practicamente todas las funciones que describiremos a continuación , basan su operatoria en la suposición que los strings que se le pasan como argumento , terminan en el caracter NULL , si por error esto no fuera así , los resultados son catastróficos , produciendose generalmente la destrucción de los datos y el aborto del programa .

2. FUNCIONES DE IMPRESION DE STRINGS
Daremos un análisis de las funciones que permiten la impresión en pantalla de strings , muchas de ellas pueden obviamente , utilizarse para imprimir otro tipo de variable , pero aquí sólo describiremos su aplicación particular sobre el tema de nuestro interes.

PRINTF()

• Header :
• Prototipo : int printf( const char *formato , argumento , ......... )
• Portabilidad : Definida en ANSI C. No es compatible con Windows

• Comentario : Retorna un entero igual a la cantidad de caracteres que ha impresso , ó un EOF (End Of File , por lo general -1 ) en caso de error ú operación fallida . Tiene un uso más generalizado que el que aquí describimos , ya que por el momento veremos sólo su aplicación a strings . El string de formato puede ser construido directamente en la función , delimitándolo con comillas , ó definido antes en el listado , y pasado como argumento por medio de un puntero . Puede contener , directamente el texto a imprimir , si éste es una constante , en cuyo caso no se pasarán más argumentos , ó una mezcla de texto constante con secuencias de control de formato para la impresión del resto de los parámetros pasados. La secuencia de control comienza con el caracter % . En caso de impresión de strings , el comando debe terminarse con la letra s. Entre el comienzo (%) y el fín (s) de la secuencia de control , pueden introducirse opcionalmente modificadores cuyo sentido , en el caso de los strings , es el siguiente : % [justificación] [longitud] [.presicion] s La (longitud) dá la cantidad MINIMA de caracteres a imprimir , independientemente de cuantos caracteres tenga el string . Si este valor es mayor que la cantidad de caracteres del string , se rellenará con blancos el sobrante , colocandose los mismos a la derecha ó izquierda , segun sea la justificación . Si la (longitud) es menor que la del string , este quedará truncado . La precisión es un número , que debe estar precedido por un punto , e indica el máximo número de caracteres del string , que se imprimirán . La justificación "default" es hacia la derecha , un signo menos en este campo impone una justificacion a la izquierda . Dentro de la secuencia de comando pueden ubicarse secuencias de escape como las vistas en capítulos anteriores . Un caso especial se dá , cuando en el lugar de la longitud se coloca un asterisco (*) , éste implica que la longitud vendrá expresada por el argumento que sigue al string en la lista de los mismos (un entero) .
• Ejemplos : En los ejemplos siguientes se ha colocado el caracter | adelante y atras de la secuencia de comando , para mostrar donde empieza y donde termina la impresión del string .

              ...........

              p = "Lenguaje C" ;    /* 10 caracteres */

              ...........

              printf("|%15s|" , p )     ;    /* imprime : |     Lenguaje C|  */

              printf("|%15.8s|" , p )   ;    /*    "    : |       Lenguaje|  */

              printf("|%-15s|" , p )    ;    /*    "    : |Lenguaje C     |  */

              printf("|%-15.8s|" , p )  ;    /*    "    : |Lenguaje       |  */

              printf("|%.6s|" , p )     ;    /*    "    : |Lengua|           */

              ancho = printf("|%15s|" , p ); /* imprime : |     Lenguaje C|  */

              printf("|%*.8s|" , p , ancho); /*    "    : |       Lenguaje|  */

Existe otra función más específica que la anterior , aunque más restrigida , puts() .

PUTS()

• Header :
• Prototipo : int puts( const char *s )
• Portabilidad : Definida en ANSI C. No es compatible con Windows
• Comentario : Copia un string terminado con un NULL y apuntado por s en la salida estandar , normalmente stdout ó video . Si la salida fué exitosa retorna un valor positivo , caso contrario EOF . Luego de impreso el string agrega automaticamente un \n ó avance de línea . Es más rápida que la anterior , ya que escribe directamente el buffer de video . Solo es aplicable a variables del tipo strings
• Ejemplo :

              #include 

              main()

              {

              char p[] = "Uno" , s[] = "Dos" ;

              puts(p) ;

              puts(s) ;

              }

              /* imprime :    Uno

                              Dos       */

3. FUNCIONES DE ADQUISICION DE STRING

Cuando se necesita leer un string enviado desde el teclado , se utilizará alguna de las funciones abajo citadas , debiendose tener los recaudos descriptos antes , ya que la longitud del mismo es desconocida.

SCANF()

• Header :
• Prototipo : int scanf( const char *formato , direccion , ......... )
• Portabilidad : Definida en ANSI C. No es compatible con Windows
• Comentario : Esta función es la inversa del printf() y valen para ella los mismos comentarios respecto a su generalidad. La analizaremos desde el punto de vista exclusivo de los strings . Las secuencias de control dentro del string de formato , comenzarán con % y terminarán con s , siendo optativo colocar entre ambas los siguientes modificadores: % [*] [longitud] [N ó F] s El * en éste caso suprime el asignamiento del valor ingresado a la variable. Longitud es un entero que indica el máximo de caracteres a cargar en la dirección dada por el puntero . N ó F intruyen a la función a forzar al puntero entregado como parámetro a ser Near ó Far . Se pueden poner varios especificadores de formato seguidos, en ese caso , la cantidad de argumentos debe coincidir co la de aquellos , ó por lo menos no ser menor, ya que si así fuera los resultados son impredecibles y por lo general desastrosos . En cambio , si la cantidad es mayor, el excedente sera simplemente no tomado en cuenta . Si se separan los especificadores con caracteres de distanciameinto no imprimibles como , espacio , \t , \n , etc , la función esperará a que el correspondiente sea ingresado por el teclado , una vez ubicado el proximo caracterer imprimible será enviado a la dirección apuntada por el próximo parámetro , descartando los separadores anteriores . Si en cambio se usan para separar dos especificadores de formato , caracteres imprimibles , como dos puntos , coma , etc , estos serán leidos y descartados. Una condición particular puede darse en el caso de los strings : se puede especificar los caracteres ó grupos de caracteres que se desea leer , si luego del % y encerrado entre corchetes [] se coloca un grupo de ellos , solo serán enviados a la dirección del parámetro , aquellos que coincidan con los mismos . Por ejemplo %[0123456789]s solo leerá los caracteres numéricos . Esto se puede expresar , en forma más compacta como %[0-9]s Si en cambio se desea EXCLUIR dichos caracteres debrá escribirse : %[^0-9]s , indicandose la exclusión mediante el simbolo ^ . El uso anterior al de esta función , de alguna otra que lea el teclado pude dejar el buffer del mismo cargado con caracteres que luego afectan a scanf como si nuevamente hubieran sido escritos , en estos casos se impone el uso previo a la llamada a ésta función de fflush() . Retorna un entero de igual valor al de campos leidos exitosamente.
• Ejemplo : scanf("%20s" \n "%[0-9A-F]s" , p , q) ; En éste caso se leerá un primer string de nó más de 20 caracteres, y se enviará a la dirección contenida por el puntero p , luego se esperará un ENTER y se enviarán a la dirección de q todos aquellos caracteres leidos que correspondan a los números ó a letras comprendidas entre la A y F.

De la misma manera que para printf(), hay funciones menos generales, dedicadas expresamente a la lectura de strings, como gets(), que veremos a continuación .

GETS()

• Header :
• Prototipo : char *gets( char *s )
• Portabilidad : Definida en ANSI C. No es compatible con Windows
• Comentario : Lee caracteres desde la entrada estandar , incluyendo los espacios hasta que encuentra un avance de linea (ENTER), este es reemplazado por un NULL, y el string resultante en cargado en la direccion indicada por s. Retorna s, ó un NULL en caso de error. Es responsabilidad del programador, que s tenga suficiente longitud como para albergar lo leído.

4. FUNCIONES DE CONVERSION ENTRE STRING Y VARIABLES NUMERICAS

Puede darse el caso que la información a ingresarse a un programa ejecutable , por el operador pueda ser en algunos caso un valor numérico y en otros un string de caracteres . Un problema típico enfrentamos en el ejemplo en que ingresabamos a nuestra base de datos un articulo , ya sea por su nombre ó por su número de código .
Más cómodo que escribir dos instancias del programa , una para cada una de las opciones , es dejar que el operador escriba lo que se le venga en ganas , leyendolo como un string , luego verificar si éste está compuesto exclusivamente por números ó posee algun caracter nó numérico , y actuar en consecuencia .
Para evaluar si un string cae dentro de una categoría dada , es decir si está compuesto exclusivamente por números , letras, mayúsculas , minúsculas , caracteres alfanuméricos , etc existen una serie de funciones , algunas de las cuales ya hemos usado, que describimos a continuación . Estas deben ser usadas con los strings , analizando caracter a caracter de los mismos, dentro de un FOR ó un WHILE:

for(i=0 ; palabra[i] != NULL ; i++) {

 if( isalnum(palabra[i] )

  .........................

 }

IS.....()

• Header :
• Prototipo :

             int isalnum( int  c )

             int isalpha( int  c )

             int isascii( int  c )

             int iscntrl( int  c )

             int isdigit( int  c )

             int islower( int  c )

             int isupper( int  c )

             int ispunct( int  c )

             int isspace( int  c )

             int isxdigit( int  c )

• Portabilidad : Definida en ANSI C
• Comentario : Retornarán un valor CIERTO (distinto de cero) si el caracter enviado como argumento cae dentro de la catewgoría fijada para la comparación y FALSO ó cero en caso contrario . Las categorias para cada función son las siguientes :

Una vez que sabemos que un string está compuesto por números , podemos convertirlo en una variable numérica , de cualquier tipo , para poder realizar con ella los cálculos que correspondan .

ATOI() , ATOL() , ATOF()

• Header :
• Prototipo :

            int    atoi( const char *s )

            long   atol( const char *s )

            double atof( const char *s )

• Portabilidad : Definida en ANSI C

• Comentario : Convierten el string apuntado por s a un número . atoi() retorna un entero , atol() un long y atof() un double . ( Algunos compiladores traen una función adicional , _atold() que retorna un long double ) . El string puede tener la siguiente configuración :

[espacios , blancos , tabulador , etc] [signo] xxx

donde xxx son caracteres entre 0 y 9 , para atoi() y atol() . Para atof() en cambio , se aceptan :

[espacios , etc] [signo] xxx [.] [ xxx]   ó

[espacios , etc] [signo] xxx [.] [ xxx] [ e ó E [signo] xxx ]

según se desee usar la convención de punto flotante ó cientifica.

Es posible tambien , aunque menos frecuente , realizar la operación inversa, es decir, convertir un número en un string.

ITOA() , ULTOA()

• Header :

• Prototipo:

               char  *itoa( int numero , char *s , int base )

               char *ultoa( unsigned long numero , char *s , int base )

• Portabilidad : Definida en ANSI C

• Comentario : Retornan un puntero a un string formado por caracteres que representan los dígitos del número enviado como argumento . Por base se entiende la de la numeración en la que se quiere expresar el string , 10 para decimal , 8 para octal , 16 para hexadecimal , etc . itoa() convertirá un entero , mientras ultoa() lo hará con un unsigned long.

5. DETERMINACION DE LA LONGITUD DE UN STRING

Hemos aplicado anteriormente esta función, damos aquí entonces , sólo una ampliación de sus caracteristicas.

STRLEN() , _FSTRLEN

• Header :
• Prototipo :

          size_t  strlen( const char *s )

          size_t far _fstrlen( const char far *s )

• Portabilidad : Definidas en ANSI C
• Comentario : Retornan un entero con la cantidad de caracteres del string . No toma en cuenta al terminador NULL . Por lo que la memoria real necesaria para albergar al string es 1+strlen(s) . _fstrlen() dá idéntico resultado , pero acepta como argumento un puntero " far " .
• Ejemplo :

           ..............

           char s[128] ;

           gets(s) ;

           p = (char *)malloc( sizeof( strlen(s) + 1 ) ;

6. COPIA Y DUPLICACION DE STRINGS

Vimos que el operador de asignación no está definido para strings , es decir que hacer p = q , donde p y q son dos arrays , no produce la copia de q en p y directamente la expresión no es compilada . Si en cambio p y q son dos punteros a caracteres , la expresión es compilada , pero no produce el efecto de copia , simplemente , cambia el valor de p , haciendo que apunte al MISMO string que q . Es decir que no se genera uno nuevo , por lo que todo lo operado sobre p afectará al original , apuntado por q .
Para generar entonces , una copia de un string en otro lugar de la memoria , se deben utilizar alguna de las funciones abajo descriptas . Hay que diferenciar la copia de la duplicacion : la primera copia un string sobre un lugar PREVIAMENTE reservado de memoria ( mediante malloc() , calloc() ó alguna otra función función de alocación ) , en cambio la duplicación GENERA el espacio para guardar al nuevo string así creado.

STRCPY()

• Header :
• Prototipo : char *strcpy( char *destino , const char *origen )
• Portabilidad : Definidas en ANSI C
• Comentario : Copia los caracteres del string "origen" , incluyendo el NULL , a partir de la dirección apuntada por "destino" . No verifica que haya suficiente memoria reservada para tal efecto , por lo que es responsabilidad del programador ubicar previamente suficiente memoria como para albergar a una copia de "origen" . Aunque es superfluo , su retorno es el puntero "destino" .

Existe tambien una función para realizar la copia PARCIAL . Por lo general las funciones que realizan acciones sobre una parte solamente , de los strings , llevan el mismo nombre de las que los afectan totalmente , pero con la adición de la letra "n".

STRNCPY()

• Header :
• Prototipo : char *strncpy( char *destino , const char *origen , size_t n_char )
• Portabilidad : Definidas en ANSI C
• Comentario : Copia n_char caracteres del string "origen" , NO incluyendo el NULL , si la cantidad de caracteres copiada es menor que strlen(origen) + 1 , en la dirección apuntada por "destino" . n_char es un número entero y deberá ser menor que la memoria reservada apuntada por destino .
• Ejemplo:

               #include 

               main()

               {

               char strvacio[11] ;

               char strorigen[] =  "0123456789" ;

               char strdestino[] = "ABCDEFGHIJ" ;

               ..................

               strncpy( strdestino , strorigen , 5 ) ;

               strncpy( strvacio , strorigen , 5 ) ;

               strvacio[5] = '\0' ;

               .........................

               }

Los strings quedarían , luego de la copia :

      strdestino[] == 0 , 1 , 2 , 3 , 4 , F , G , H , I , J , \0

      strvacio[]   == 0 , 1 , 2 , 3 , 4 , \0 , indefinidos

Note que en el caso de strdestino no hizo falta agregar el NULL , ya que éste se generó en la incialización del mismo , en cambio strvacio no fué inicializado , por lo que para terminar el string , luego de la copia , se deberá forzosamente agregar al final del mismo.

La función siguiente permite la duplicación de strings :

STRDUP()

• Header :
• Prototipo : char *strdup( const char *origen )
• Portabilidad : Definida en ANSI C
• Comentario : Duplica el contenido de "origen" en una zona de memoria por ella reservada y retorna un puntero a dicha zona .
• Ejemplo :

              #include 

              main()

              {

              char *p ;

              char q[] = "Duplicación de strings" ;

              p = strdup( q ) ;

              ..................

              }

Note que el retorno de la función debe ser siempre asignado a un dado puntero .

7. CONCATENACION DE STRINGS

Se puede, mediante la concatenación de dos ó más strings , crear otro , cuyo contenido es el agregado del de todos los anteriores .
La concatenación de varios strings puede anidarse , de la siguiente manera :

strcat( strcat(x , w) , z ) ;

en la cual al x se le agrega a continuación el w , y luego el z . Por supuesto x tiene que tener suficiente longitud como para albergarlos .

STRCAT()

• Header :
• Prototipo : char *strcat( char *destino , const char *origen )
• Portabilidad : Definida en ANSI C
• Comentario : Agrega el contenido de "origen" al final del string inicializado "destino" , retornando un puntero a este .
• Ejemplo :

              #include 

              char z[20] ;

              main()

              {

              char p[20] ;

              char q[] =   "123456789" ;

              char w[] =   "AB" ;

              char y[20] = "AB" ;

              strcat( y , q ) ;      /* Correcto , el contenido de y[] será:
                                         y[] == A,B,1,2,3,4,5,6,7,8,9,\0  */

              strcat( z , q ) ;      /* Correcto , por ser global z[] quedó 
                                         inicializado con 20 NULLS por lo que
                                         luego de la operación quedará:
                                         z[] == 1,2,3,4,5,6,7,8,9,\0

              strcat( p , q ) ;      /* Error ! p no ha sido inicializado por
                                         lo que la función no encuentra el NULL
                                         para empezar a agregar , por lo que
                                         barre la memoria hasta encontrar 
                                         alguno, y ahí escribe con resultados,
                                         generalmente catastróficos.

              strcat( w , q ) ;      /* Error ! w solo tiene 3 caracteres, 
                                         por lo el resultado final será:
                                         w[] == A,B,1  sin la terminación
                                         del NULL por lo que cualquier
                                         próxima operación que se haga
                                         utilizando este array, como string,
                                         fallará rotundamente .

               {

STRNCAT()

• Header :
• Prototipo : char *strncat( char *destino , const char *origen , size_t cant)
• Portabilidad : Definida en ANSI C
• Comentario : Similar en un todo a la anterior , pero solo concatena cant caracteres del string "origen" en "destino" .

8. COMPARACION DE STRINGS

No debe confundirse la comparación de strings , con la de punteros , es decir

if(p == q) {

............

sólo dará CIERTO cuando ambos apunten al MISMO string , siempre y cuando dichos punteros sean " near " ó " huge " . El caso que acá nos ocupa es más general , ya que involucra a dos ó más strings ubicados en distintos puntos de la memoria ( abarca el caso anterior , como situación particular).

STRCMP()

• Header :
• Prototipo : int strcmp( const char *s1 , const char *s2 )
• Portabilidad : Definida en ANSI C
• Comentario : Retorna un entero , cuyo valor depende del resultado de la comparación

              <  0 si s1 es menor que s2

              == 0 si s1 es igual a s2

              >  0 si s1 es mayor que s2

La comparación se realiza caracter a caracter , y devuelve el resultado de la realizada entre los primeros dos que sean distintos.
La misma se efectua tomando en cuenta el código ASCII de los caracteres así será por ejemplo '9' < 'A' , 'A' < 'Z y 'Z' < 'a' .

STRCMPI()

• Header :
• Prototipo : int strcmpi( const char *s1 , const char *s2 )
• Portabilidad : Solamente válida para el DOS
• Comentario : Retorna un entero , de una manera similar a la anterior pero no es sensible a la diferencia entre mayúsculas y minúsculas , es decir que en este caso 'a' == 'A' y 'Z' > 'a' .

STRNCMP() , STRNCMPI()

• Header :
• Prototipo : int strcmpi( const char *s1 , const char *s2 , size_t cant)
• Portabilidad : strncmpi() es solamente válida para el DOS strncmp() está definida en ANSI C
• Comentario : Retornan un entero , con caracteristicas similares a las de las funciones hermanas , descriptas arriba , pero solo comparan los primeros "cant" caracteres .

9. BUSQUEDA DENTRO DE UN STRING

Muchas veces dentro de un programa , se necesita ubicar dentro de un string , a un determinado caracter ó conjunto ordenado de ellos . Para simplificarnos la tarea existen una serie de funciones de Librería , que toman por su cuenta la resolución de este problema :

STRCHR() Y STRRCHR()

• Header :
• Prototipo :

                       char *strchr( const char *s1 , int c )

                       char *strrchr( const char *s1 , int c )

• Portabilidad : Definidas en ANSI C

• Comentario : Retornan un puntero , a la posición del caracter dentro del string , si es que lo encuentran , ó en su defecto NULL . strchr() barre el string desde el comienzo , por lo que marcará la primer aparición del caracter en él , en cambio strrchr() lo barre desde el final , es decir que buscará la última aparición del mismo . El terminador NULL es considerado como parte del string .

STRBRK()

• Header :
• Prototipo : char *strbrk( const char *s1 , const char *s2 )
• Portabilidad : Definidas en ANSI C
• Comentario : Similar a las anteriores , pero ubicando la primer aparición de cualquier caracter contenido en s2 , dentro de s1 .

STRSTR()

• Header :
• Prototipo : char *strstr( const char *s1 , const char *s2 )
• Portabilidad : Definidas en ANSI C
• Comentario : Busca dentro de s1 un substring igual a s2 , devolviendo un puntero al primer caracter del substring . cualquier caracter contenido en s2 , dentro de s1 .

STRTOK()

• Header :
• Prototipo : char *strtok( const char *s1 , const char *s2 )
• Portabilidad : Definidas en ANSI C
• Comentario : Busca dentro de s1 un substring igual a s2 , si lo encuentra MODIFICA a s1 reemplazando el substring por NULL, devolviendo la dirección de s1. Si se lo vuelve a invocar con NULL en lugar en el lugar del parámetro s1, continua buscando en el string original una nueva aparición de s2 . Cuando no encuentra el substring , retorna NULL. Sirve para descomponer un string en "palabras de una frase" cuando éstas estan separadas por un mismo caracter/es .

• Ejemplo :

              puts("escriba una frase , separando las palabras con espacios") ;

              gets(s) ;

              p = strtok(s , " ") ;

              while(p) {

                puts(p) ;

                p = strtok( NULL , " ") ;

               }

10. FUNCIONES DE MODIFICACION DE STRING

Resulta conveniente a veces uniformizar los string leidos de teclado, antes de usarlos, un caso típico es tratar de independizarse de la posibilidad de que el operador escriba, algunas veces con mayúscula y otras con minúscula.

STRLWR() Y STRUPR()

• Header :
• Prototipo :

                       char *strlwr( char *s1 )

                       char *strupr( char *s1 )

• Portabilidad : Definidas en ANSI C
• Comentario : Convierten respectivamente los caracteres comprendidos entre a y z a minúsculas ó mayúsculas , los restantes quedan como estaban .

© Derechos Reservados, Copyright, DATA-2013, 1998-2003.