C encadena (informática)Sólo una matriz de caracteres. La longitud de la cadena viene determinada por el carácter nulo de terminación:'\0'. Así que con una cadena de contenido, digamos, el"abc"Hay cuatro grandes palabras:'a'(matemáticas) género'b'(matemáticas) género'c'y la terminación de null ('\0').
El valor del carácter nulo de terminación es cero.
vocabulario
En C, las constantes de cadena (literales) se rodean de comillas dobles ("), por ejemplo, "¡Hola mundo!", y se compilan como matrices del valor char especificado con un código extra de carácter de terminación nulo (valor 0) para marcar el final El tipo de la constante de cadena es char []. .
barra diagonal inversa de escape
Los literales de cadena no pueden contener saltos de línea incrustados ni otros caracteres de control directamente en el código fuente, ni otros caracteres de la cadena que tengan un significado especial.
Para incluir este tipo de caracteres en una cadena, puede utilizar el carácter de escape barra invertida, como se muestra a continuación:
| fugarse | significado oculto |
|---|---|
| \\ | barra invertida literal |
| \" | cita doble |
| \" | cotización única |
| \ n | Saltos de línea |
| \ r | backhaul |
| \b | retroceso |
| \ t | pestaña horizontal |
| \F | Forma de alimentación |
| \ A | Alarma (timbre) |
| Regla v | pestaña vertical |
| \? | Signos de interrogación (para escapar de triángulos) |
| \ nnn | Tiene un valor octalnnn'scarácter |
| \ x hh | Caracteres con valores hexadecimaleshh |
cadena ancha
C admite cadenas anchas, definidas como matrices de tipo wchar_t con valores de 16 bits (como mínimo). Se escriben con L delante de la cadena como wchar_t * p = L "¡Hola mundo!";
Esta característica permite utilizar cadenas cuando se necesitan más de 256 puntos de caracteres diferentes posibles (aunque también se pueden utilizar cadenas de caracteres de longitud variable). Se terminan con el valor cero wchar_t. Las funciones no soportan estas cadenas. En su lugar, tienen su propia función, declarada en .
codificación de caracteres
El estándar C no especifica qué codificación de caracteres es representada por char y wchar_t, excepto para los valores 0x00 y 0x0000, que especifican el final de la cadena en lugar de un carácter. Es el código de entrada y salida el que se ve directamente afectado por la codificación de caracteres. El resto del código no debería verse muy afectado. Si la cadena se puede escribir en código fuente, el editor también debería ser capaz de manejar la codificación.
Existen tres tipos principales de códigos:
- Un byte por carácter. Normalmente basado en ASCII. Limitado a 255 caracteres distintos más un carácter de terminación cero.
- Cadenas de caracteres de longitud variable, que permiten muchos más de 255 caracteres diferentes. Estas cadenas se escriben como matrices ordinarias basadas en caracteres. Estas codificaciones suelen basarse en ASCII, por ejemplo UTF-8 o Shift JIS.
- Cadenas anchas. Son matrices de valores wchar_t.UTF-16 es la codificación más común de este tipo, que también es de longitud variable, lo que significa que un carácter puede ser dos wchar_t.
(utilizado como expresión nominal)<string.h>cabeza estándar
Como a los programadores les resultaba difícil trabajar con las cadenas en bruto, añadieron una nueva cadena a la directiva<string.h>código de la biblioteca. No representa un esfuerzo de diseño colaborativo, sino un aumento de las contribuciones realizadas por los autores individuales a lo largo de los años.
En primer lugar, existen tres tipos de funciones en la biblioteca de cadenas:
- tal
memmanipula una secuencia de caracteres arbitrarios sin tener en cuenta los caracteres nulos; la función - tal
strmanipula una secuencia de caracteres terminada en null. - tal
strnmanipula una secuencia de caracteres no vacíos.
Funciones de cadena más comunes
Las nueve funciones más utilizadas de la biblioteca de cadenas son:
strcat- Unir dos cadenasstrchr- Operación de barrido de cadenasstrcmp- Comparación de dos cadenasstrcpy- Copiar una cadenastrlen- Obtener longitud de cadenastrncat- Concatenar una cadena con otra cadenastrncmp- Comparación de partes de dos cadenasstrncpy- Copiar parte de una cadenastrchr- Operación de barrido de cadenas
(utilizado como expresión nominal)strcatfunción (matem.)
char *strcat(char * restringir s1, const char * restringir s2);;
Algunas personas recomiendan el uso de strncat() tal vez strlcat() Sustituye a strcat para evitar desbordamientos de búfer.
deberíastrcat()La función debe transferir los datos proporcionados por els2(incluido el byte nulo final) se añade una copia de la cadena apuntada al final de la cadena apuntadas1. Bytes inicialess2Sobrescribir el byte nulo al finals1. Si la copia se realiza entre objetos superpuestos, el comportamiento es indefinido. Esta función devuelves1.
Esta función se utiliza para añadir una cadena al final de otra cadena. La primera cadena (s1) debe tener el espacio necesario para almacenar dos cadenas.
Ejemplo:
1TP5Incluido <stdio.h>
1TP5Incluido <string.h>
...
estático const char * colours [] = { "Rojo", "Naranja", "Amarillo", "Verde ", "Azul", "Morado" }; }
estático const char * anchos [] = { "Fino", "Medio", "Grueso", "Negrita " };
...
char plumaTexto [ 20 ]; ...
...
int colorPen = 3, 2 ; ...
strcpy (penText , colours [ penColor ]); ... strcat (penText , width [ penThickness ]); ...
strcpy (textoPen, colores [ colorPen ]); strcat (textoPen, anchura [ grosorPen ]); ...
printf ("Mi bolígrafo es %s \ n ", penText). / *Print 'Mi bolígrafo es GreenThick'* /
antes de llamar astrcat()el objetivo debe contener actualmente una cadena de terminación vacía, o el primer carácter debe inicializarse con un carácter nulo (p. ej.penText[0] = '\0';).
Las siguientes son aplicaciones de dominio públicostrcat::
1TP5Incluido <string.h>
/ * strcat * /
char * (strcat )(char *) restrinja s1. const char * restrinja s2 )
{
char * s = s1 ;
/ * Mueve s para que apunte al final de s1. * /
mientras que ¡(* s ! = '\ 0' )
s ++ ;
/ * Copiar el contenido de s2 en el espacio al final de s1. * /
strcpy (s, s2 );
volver (o regresar) s1 ;
}
(utilizado como expresión nominal)strchrfunción (matem.)
char *strchr(const char *s, int c).
deberíastrchr()La función debe encontrar la primera aparición de la cadena apuntada por la variablec(Convertido a char (informática))s. El byte nulo final se considera parte de la cadena. La función devuelve la posición del carácter encontrado, o un puntero nulo si no se encuentra el carácter.
Esta función se utiliza para encontrar determinados caracteres en una cadena.
En algún momento de la historia, esta característica recibió el nombre deíndice. Esto.strchrEl nombre es ambiguo, pero se ajusta al patrón general de denominación.
Las siguientes son aplicaciones de dominio públicostrchr::
1TP5Incluido <string.h>
/ * strchr * /
char * (strchr ) (const char * s , int c )
{
char ch = c ;
/ * Buscar roles. Cuando este bucle termina, el
s apuntará al final de la cadena o
Buscamos
(utilizado como expresión nominal)Personajes.* / mientras que ¡(* s ! ¡= '\ 0' && * s ! = ch )
s ++ ;)
volver (o regresar) (* s == ch) ? (char * ) s : NULL ;
}
(utilizado como expresión nominal)strcmpfunción (matem.)
int strcmp(const char *s1, const char *s2);
La forma básica de comparación de cadenas se realiza mediante la función strcmp(). Toma dos cadenas como argumentos y devuelve un valor menor que cero si la primera es léxicamente menor que la segunda, un valor mayor que cero si la primera es léxicamente mayor que la segunda, y cero si las dos cadenas son iguales. La comparación se realiza comparando los valores codificados (ascii) de los caracteres carácter por carácter.
Ahora bien, este tipo simple de comparación de cadenas suele considerarse inaceptable a la hora de ordenar listas de cadenas. Existen algoritmos más avanzados que pueden producir listas ordenadas por diccionario. También pueden resolver problemas como strcmp(), dado que la cadena "Alpha2" es mayor que "Alpha12". (En el ejemplo anterior, "Alpha2" es mayor que "Alpha12" porque '2' va después de '1' en el conjunto de caracteres. ' en el conjunto de caracteres). Lo que estamos diciendo es que nostrcmp()Utilícelo solo en cualquier anuncio para la ordenación general de cadenas o códigos especializados.
deberíastrcmp()La función debe comparar las cadenas que apuntan as1que apunta as2. El signo de un valor de retorno distinto de cero vendrá determinado porunsigned charSe determina el signo de la diferencia entre los valores de los distintos primeros pares de bytes (ambos interpretados como tipos) en las cadenas comparadas. Una vez completado el proceso, elstrcmp()Si las cadenas señaladoras son respectivamentes1mayor, igual o menor que la cadena apuntada devolverá un entero mayor, igual o menor que 0s2.
Dado que la comparación de punteros no es realmente útil por sí misma, a menos que se comparen punteros en la misma matriz, esta función compara léxicamente las cadenas apuntadas por los dos punteros.
Esta función es útil en comparaciones como
if (strcmp(s, "lo que sea") == 0) / *hacer algo* /
;
Orden de acabado utilizadostrcmp()Equivalente al juego de caracteres nativo de la máquina. La única garantía sobre el orden es que los números del '0' al '9' están en orden consecutivo.
Las siguientes son aplicaciones de dominio públicostrcmp::
1TP5Incluido <string.h>
/ * strcmp * /
int (strcmp ) (const char * s1. const char * s2 )
{
unsigned char uc1 , uc2 ;
/ * Mover s1 y s2 a la
En cada cadena
el primer carácter distintivo delo si mismo
entonces mueve el final de la cadena.* / mientras que ¡(* s1 ! = '\ 0' && * s1 == * s2 ) {
s1 ++ ;
s2 ++ ;
}
/ * Comparar caracteres como unsigned char y
Devuelve la diferencia. * /
uc1 = (* (unsigned char * ) s1 ); uc2 = (* (unsigned char * ) s2 ); uc2 = (* (unsigned char * ) s2 )
uc2 = (* (unsigned char * ) s2);; uc2 = (* (unsigned char * ) s2)
devolver ((uc1 uc2 ))
}
(utilizado como expresión nominal)strcpyfunción (matem.)
char *strcpy(char *restringir s1, const char *restringir s2);
Algunas personas recomiendan utilizar siempre strncpy() en lugar de strcpy para evitar desbordamientos de búfer.
deberíastrcpy()La función debe establecer la cadena C apuntada por la variables2(incluido el byte nulo final) se copia en la matriz a la que apunta la variables1. Si la copia se realiza entre objetos superpuestos, el comportamiento es indefinido. Esta función devuelves1. No se utiliza ningún valor para indicar un error: si el parámetrostrcpy()es correcta y el búfer de destino es lo suficientemente grande, la función nunca fallará.
Ejemplo:
1TP5Incluido <stdio.h>
1TP5Incluido <string.h>
/ * ... * /
estático const char * penType = "redondo" ;
/ * ... * /
char plumaTexto [ 20 ];
/ * ... * /
strcpy (penText , penType );;
Punto: Es importante asegurarse de que el búfer de destino (s1) puede contener todos los caracteres de la matriz de origen, incluidos los bytes nulos finales. En caso contrario.strcpy()sobrescribirá la memoria al final del búfer, dando lugar a un desbordamiento del búfer, que puede provocar el fallo de un programa o ser utilizado por piratas informáticos para comprometer la seguridad del ordenador.
Las siguientes son aplicaciones de dominio públicostrcpy::
1TP5Incluido <string.h>
/ * strcpy * /
char * (strcpy )(char *) restrinja s1. const char * restrinja s2 )
{
char * dst = s1 ;
const char * src = s2 ;
/ * Copia en bucle. * /
mientras que ¡((* dst ++ = * src ++ ) ! ! = '\ 0' )
! = '\ 0' ) / * El cuerpo de este bucle se deja vacío. * /
/ * Devuelve la cadena de destino. * /
volver (o regresar) s1 ;
}
(utilizado como expresión nominal)strlenfunción (matem.)
size_t strlen(const char *s);
deberíastrlen()debe calcular el valor desEl número de puntos, excluyendo el byte nulo de terminación. Devuelve el número de bytes de la cadena. No se utiliza ningún valor para indicar un error.
Las siguientes son aplicaciones de dominio públicostrlen::
1TP5Incluido <string.h>
/ * strlen * /
size_t (strlen ) (const char * s )
{
const char * p = s ;
/ * Datos en bucle s. * /
mientras que ¡(* p ! = '\ 0' )
p ++ ;
devolver (size_t )(p - s );
}
(utilizado como expresión nominal)strncatfunción (matem.)
char *strncat(char *restrict s1, const char *restrict s2, size_t n);
deberíastrncat()La función debenAñade como máximo bytes (el byte nulo y los bytes subsiguientes no se añaden) desde el final de la matriz que apunta a la direccións2al final de la cadenas1. Bytes inicialess2Sobrescribir el byte nulo al finals1. El byte nulo final siempre se añade al resultado. Si la copia se realiza entre objetos superpuestos, el comportamiento es indefinido. Esta función devuelves1.
Las siguientes son aplicaciones de dominio públicostrncat::
1TP5Incluido <string.h>
/ * strncat * /
char * (strncat ) (char *) restrinja s1. const char * restrinja s2 , size_t n )
{
char * s = s1 ;
/ * Bucle de los datos en s1. * /
mientras que ¡(* s ! = '\ 0' )
s ++ ;
/ * s ahora apunta al carácter nulo final de s1 ahora
en caso de que
Encontrado en s2Caracteres vacíos.Entonces de s2 haga una copia deA n bytes para s parada.
No es seguro usar strncpy aquí porque copia completamente n
caracteres, rellenados con relleno NULL si es necesario. * /
mientras que ¡(n.) = 0 && (* s = * s2 ++ ) ! ¡= 0 && (* s = * s2 ++ ) ! = '\ 0') {
s ++ ;= '\ 0') { n - ;
s ++ ;= '\ 0') { n - ;s ++ ;= '0'
}
si ¡(* s ! = '\ 0')
* s = '\ 0' ;)
volver (o regresar) s1 ;
}
(utilizado como expresión nominal)strncmpfunción (matem.)
int strncmp(const char *s1, const char *s2, size_t n);
deberíastrncmp()La función no debe comparar más denPuntos de matriz a byte (siguiendo un byte nulo byte no compara)s1a la matriz apuntandos2. El signo de un valor de retorno distinto de cero viene determinado por el signo de la variableunsigned charSe determina el signo de la diferencia entre los valores de los diferentes primeros pares de bytes (ambos interpretados como tipos) en las cadenas que se están comparando. Para obtener información sobrestrcmpPara una descripción del valor de retorno, véase.
Esta función es útil en las comparaciones porquestrcmpLa función es.
Las siguientes son aplicaciones de dominio públicostrncmp::
1TP5Incluido <string.h>
/ * strncmp * /
int (strncmp ) (const char * s1. const char * s2 , size_t n )
{
unsigned char uc1 , uc2 ;
/ * ¿Incomparable? Devuelve cero. * /
si (n == 0)
volver (o regresar) 0 ;
/ * Bucle, comparar bytes. * /
mientras que (n - > 0 && * s1 == * s2) {
/ * Devuelve cero si nos hemos quedado sin bytes o golpeamos null.
Porque ya sabemos que * s1 == * s2.* /
si (n == 0 || * s1 == '\ 0')
volver (o regresar) 0 ;
s1 ++ ;
s2 ++ ;
}
uc1 = (* (unsigned char * ) s1 ); ; uc2 = (* (unsigned char * ) s2 ); ; uc2 = (* (unsigned char * ) s2 )
uc2 = (* (unsigned char * ) s2 ); }
volver (o regresar) ((uc1 uc2)).
}
(utilizado como expresión nominal)strncpyfunción (matem.)
char *strncpy(char *restrict s1, const char *restrict s2, size_t n);
deberíastrncpy()La función debe comenzar connEl array apuntado no se copia más que bytes (sin copiar los bytes posteriores al byte nulo) al array apuntado por el métodos2matricess1. Si la copia se realiza entre objetos superpuestos, el comportamiento es indefinido. Si el array apuntado pors2Es más corto quende bytes, el byte nulo se añadirá a la copia de la matriz a la que apunta el parámetros1HastanEscribir hasta que se escriban todos los bytes. La función debe devolver s1; no se conserva ningún valor de retorno para indicar un error.
función puedeno (actuará, sucederá, etc.)Devuelve una cadena terminada en cero si els2Cadena más larga quenbytes, ocurre esto.
Las siguientes son versiones de dominio públicostrncpy::
1TP5Incluido <string.h>
/ * strncpy * /
char * (strncpy )(char *) restrinja s1. const char * restrinja s2 , size_t n )
{
char * dst = s1 ;
const char * src = s2 ;
/ * Copiar un byte a la vez. * /
mientras que (n > 0) {
n - ;
si ((* dst ++ = * src++ ) == '\ 0') {
/* Si llegamos aquí, estamos dentro
s2
Se ha encontrado un carácter nulo al final dePor lo tanto, utilice memset en el s1
byte nulo al final de.* / memset (dst , '\ 0' , n );
smash;
}
}
volver (o regresar) S1 ;
}
(utilizado como expresión nominal)strrchrfunción (matem.)
char *strrchr(const char *s, int c).
deberíastrrchrFunciones similares astrchrla diferencia es questrrchrDevuelve un puntero a lalo último enincidenciacinteriorsno el primero.
deberíastrrchr()La función debe encontrar la última ocurrencia en la cadena apuntada dec(Convertido a char (informática))s. El byte nulo final se considera parte de la cadena. Su valor de retorno es similar astrchrValor de retorno.
En algún momento de la historia, esta característica recibió el nombre deíndice. Esto.strrchrEl nombre es ambiguo, pero se ajusta al patrón general de denominación.
Las siguientes son aplicaciones de dominio públicostrrchr::
1TP5Incluido <string.h>
/ * strrchr * /
char * (strrchr ) (const char * s , int c )
{
const char * last = NULL ;
/ * Si el carácter que buscamos es nulo terminal, el
Sólo tenemos que buscar ese carácter porque
cadena
Sólo hay uno.Personajes.* / si (c == '\ 0')
volver (o regresar) strchr (s, c).
/ * Bucle para encontrar la última coincidencia antes de golpear NULL. * /
al mismo tiempo ¡((s = strchr (s , c )) ! ! = NULL ) {
last = s ;s ++ ;s ++ ;s
last = s ; s ++ ;
}
devolver (char *) last ;
}
Funciones de cadena menos habituales
Las funciones menos utilizadas son:
memchr- Buscar un byte en la memoriamemcmp- Comparación de bytes en memoriamemcpy- Copia de bytes en memoriamemmove- Copia de bytes en memoria utilizando regiones solapadasmemset- Configuración de bytes en memoriastrcoll- Comparación de bytes según el orden de cotejo propio del contexto lingüísticostrcspn- Obtener la longitud de la subcadena complementariastrerror- Obtención de mensajes de errorstrpbrk- Escanear una cadena de cadenasstrspn- Obtener la longitud de la subcadenastrstr- Encuentra una subcadena.strtok- Dividir cadenas en fichasstrxfrm- cadena transformada
función de replicación
(utilizado como expresión nominal)memcpyfunción (matem.)
void *memcpy(void * restrict s1, const void * restrict s2, size_t n);
deberíamemcpy()La función debe establecer elnLos bytes del objeto que apuntan als2objetoss1. Si la copia se realiza entre objetos superpuestos, el comportamiento es indefinido. Esta función devuelves1.
Como la función no tiene que preocuparse de solapamientos, puede hacer la copia más sencilla.
Las siguientes son aplicaciones de dominio públicomemcpy::
1TP5Incluido <string.h>
/ * memcpy * /
void * (memcpy ) (void *) restrinja s1. const vacío * restrinja s2 , size_t n )
{
char * dst = s1 ;
const char * src = s2 ;
/ * Bucle y copia. * /
mientras que ¡(n - ! = 0 )
* dst ++ = * src ++ ;- - - - - - - - - -
volver (o regresar) s1 ;
}
(utilizado como expresión nominal)memmovefunción (matem.)
void *memmove(void *s1, const void *s2, size_t n);
deberíamemmove()La función debe establecer elnLos bytes del objeto que apuntan als2objetoss1. La replicación se produce como sinSeñalar a partir de bytes de objetos2Primera copia en una matriz temporalnBytes apuntados por objetos no solapadoss1responder cantandos2y luegonLos bytes de la matriz temporal se copian en el objeto que apunta al objetos1. Esta función devuelve el valors1.
Una forma sencilla de realizar esta operación sin utilizar matrices temporales es comprobar si existen condiciones que impidan la copia ascendente y, si se encuentran, realizar una copia descendente.
La siguiente es una implementación de dominio público, pero no totalmente portable, de la aplicaciónmemmove::
1TP5Incluido <string.h>
/ * memmove * /
void * (memmove ) (void * s1. const void * s2 , size_t n )
{
/ *Nota: estos no tienen que apuntar a caracteres sin signo * /
char * p1 = s1 ;
const char * p2 = s2 ;
/ *Prueba de solapamiento para evitar duplicación ascendente* /
si (p2 < p1 && p1 < p2 + n) {
/ * Haz una copia descendente * /
p2 + = n ;
p1 + = n ;
mientras que ¡(n - ! = 0 )
* - p1 = * - p2 ;)
} si no
mientras que ¡(n - ! = 0 )
* p1 ++ = * p2 ++ ;
volver (o regresar) s1 ;
}
función de comparación
(utilizado como expresión nominal)memcmpfunción (matem.)
int memcmp(const void *s1, const void *s2, size_t n);
deberíamemcmp()La función fijará el objeto apuntado por el primernBytes (cada uno interpretado comounsigned char) con el objeto señalados1primeronbytes se comparans2. El signo de un valor de retorno distinto de cero vendrá determinado porunsigned charSe determina el signo de la diferencia entre los valores de los distintos primeros pares de bytes (ambos interpretados como tipos) en los objetos comparados.
Las siguientes son aplicaciones de dominio públicomemcmp::
1TP5Incluido <string.h>
/ * memcmp * /
int (memcmp) (const void * s1. const void * s2 , size_t n )
{
const unsigned char * us1 = (const unsigned char * ) s1 ;
const unsigned char * us2 = (const unsigned char * ) s2 ;
(indica relación causal) ¡(n - ! = 0) {
en caso de que (* ¡US1! = * US2)
(en) retorno (* US1 < * US2)? - 1 : + 1 ;
us1 ++ ;
us2 ++ ;
}
devolver 0 ;
}
(utilizado como expresión nominal)strcollresponder cantandostrxfrmfuncionalidad
int strcoll(const char *s1, const char *s2).
size_t strxfrm(char *s1, const char *s2, size_t n);
El estándar ANSI C especifica dos funciones de comparación específicas del lenguaje.
(utilizado como expresión nominal)strcollcompara las cadenas que apuntan as1a una cadena que apunta as2ambos interpretados como adecuados paraLC_COLLATELa categoría de la región actual. El valor de retorno es similar astrcmp.
deberíastrxfrmconvierte la cadena apuntada por la variables2y coloca la cadena resultante en el array apuntados1. La conversión es la siguiente: sistrcmpse aplica a dos cadenas convertidas, devuelve un valor mayor, igual o menor que cero, correspondiente al valor destrcollEl resultado de una función aplicada a las mismas dos cadenas originales. Sólo lanLos caracteres se colocan en la matriz de resultados apuntada pors1incluido el carácter nulo final. SinCero.s1Entonces se permite un puntero nulo. El comportamiento es indefinido si se copia entre objetos superpuestos. Esta función devuelve la longitud de la cadena convertida.
Estas funciones se utilizan raramente y son importantes para el código, por lo que no hay código en esta sección.
función de búsqueda
(utilizado como expresión nominal)memchrfunción (matem.)
void *memchr(const void *s, int c, size_t n);
deberíamemchr()La función debe encontrar la primera ocurrencia en el byte inicial del objeto apuntado (cada uno interpretado como a)c(Convertido a unsigned char). Si no se encuentra, se devuelve un puntero nulo. nunsigned charscmemchr
Las siguientes son aplicaciones de dominio públicomemchr::
1TP5Incluido <string.h>
/ * memchr * /
void * (memchr) (const void * s , int c , size_t n )
{
const unsigned char * src = s ;
unsigned char uc = c ;
mientras que ¡(n - ! = 0) {
si (* src == uc)
devolver (void *) src ;
SRC++ ;
}
devolver NULL ;
}
(utilizado como expresión nominal)strcspn(matemáticas) génerostrpbrkresponder cantandostrspnfuncionalidad
size_t strcspn(const char *s1, const char *s2);
char *strpbrk(const char *s1, const char *s2);;
size_t strspn(const char *s1, const char *s2);
deberíastrcspncalcula la longitud del segmento inicial más grande de la cadena apuntada por la cadenas1atribuible únicamente afalloComposición de caracteres de la cadena apuntadas2.
deberíastrpbrkpara localizar la cadena apuntadas1La primera coincidencia en la cadena apuntada por cualquier carácter de la cadenas2devuelve un puntero al carácter o un puntero nulo no encontrado.
deberíastrspncalcula la longitud del segmento inicial más grande de la cadena apuntada por el segmentos1Consiste enteramente en caracteres de la cadena apuntadas2.
Todas estas funciones son similares excepto por las pruebas y los valores de retorno.
Las siguientes son de dominio públicostrcspn(matemáticas) génerostrpbrkdemasiadostrspn::
1TP5Incluido <string.h>
/ * strcspn * /
size_t (strcspn ) (const char * s1. const char * s2 )
{
const char * sc1 ;
para ¡(sc1 = s1 ; * sc1 ! = '\ 0' ; sc1 ++ )
si ¡(strchr (s2 , * sc1 )! = NULL )
devolver (sc1 - s1).
volver (o regresar) sc1 - s1 ; / *Terminación de la coincidencia nula* /
}
1TP5Incluido <string.h>
/ * strpbrk * /
char * (strpbrk ) (const char * s1. const char * s2 )
{
const char * sc1 ;
para ¡(sc1 = s1 ; * sc1 ! = '\ 0' ; sc1 ++ )
si ¡(strchr (s2 , * sc1 )! = NULL )
devolver (char *) sc1 ;
volver (o regresar) NULO ; / *Terminación de la coincidencia nula* /
}
1TP5Incluido <string.h>
/ * strspn * /
size_t (strspn ) (const char * s1. const char * s2 )
{
const char * sc1 ;
para ¡(sc1 = s1 ; * sc1 ! = '\ 0' ; sc1 ++ )
si (strchr (s2, * sc1) == NULL)
devolver (sc1 - s1).
volver (o regresar) sc1 - s1 ; / *Terminación de la falta de coincidencia nula* /
}
(utilizado como expresión nominal)strstrfunción (matem.)
char *strstr(const char *haystack, const char *needle);;
deberíastrstr()La función debe estar en la cadena apuntada porpajarpara encontrar la primera coincidencia en la cadena apuntada por la secuencia de bytes (excluyendo el byte nulo de terminación) del parámetroaguja.pajarSi no se encuentra ninguna coincidencia, la función devuelve un puntero a la cadena coincidente o un puntero nulo. Si la cadenaagujaes la cadena vacía, la función devuelve la cadenapajar.
Las siguientes son aplicaciones de dominio públicostrstr::
1TP5Incluido <string.h>
/ * strstr * /
char * (strstr ) (const char * pajar. const char * aguja )
{
size_t needlelen ;
/ * * Compruebe la casilla de la aguja cero. * /
si (* aguja == '\ 0')
devolver (char *) pajar ;
needlelen = strlen's (aguja) ;
para ¡(; (pajar = strchr (pajar, * aguja )) ! ! = NULL ; pajar ++ )
si (memcmp (haystack, needle, needlelen) == 0)
devolver (char *) pajar.
volver (o regresar) NULL ;
}
(utilizado como expresión nominal)strtokfunción (matem.)
char *strtok(char *restrict s1, const char *restrict delimiters);;
Una serie de llamadasstrtok()Cadena de puntoss1Descompuesto en una serie de tokens, cada uno separado por un byte en la cadena de apuntadodelimitadores. La primera llamada de la secuencias1como primer argumento, seguida de una llamada que utiliza el puntero nulo como primer argumento. La cadena delimitadora apuntada pordelimitadoresPuede ser diferente de una llamada.
La primera llamada de la secuencia busca la cadena a la que apunta el parámetros1El primer byte no contenido en la cadena delimitadora actualdelimitadores. Si no se encuentra dicho byte, no hay ningún token en la cadena a la que apunta el parámetros1además destrtok()Debe devolverse un puntero nulo. Si se encuentra tal byte, es el principio del primer token.
strtok()A partir de ahí, la función busca un byte (o varios bytes consecutivos) contenido en la cadena delimitadora actual. Si no se encuentra tal byte, el token actual se expande hasta el final de la cadena apuntada pors1las búsquedas posteriores de tokens devolverán un puntero nulo. Si se encuentra un byte de este tipo, será sobrescrito por el byte nulo, que termina el token actual. La direcciónstrtok()La función guarda un puntero al byte siguiente a partir del cual comenzará la siguiente búsqueda de tokens.
Cada llamada posterior, utilizando el puntero nulo como valor del primer argumento, busca a partir del puntero guardado y se ejecuta como en el caso anterior.
deberíastrtok()Las funciones no necesitan ser reentrantes. Las funciones que no necesitan ser reentrantes no necesitan ser thread-safe.
debido astrtok()Las funciones deben guardar el estado entre llamadas, y no se pueden utilizar dos etiquetadores al mismo tiempo, por lo que Single Unix Standard define una función similar, la funciónstrtok_r()No necesita guardar estado. Se prototipa así:
char *strtok_r(char *s, const char *delimitadores, char **últimos);
deberíastrtok_r()función (matem.)sTrata una cadena que termina en null como una secuencia de cero o más tokens de texto separados por un espacio de uno o más caracteres en la cadena delimitadoradelimitadores. Este parámetro apunta de forma persistente a un puntero proporcionado por el usuario al archivostrtok_r()Continúa buscando la información almacenada necesaria para la misma cadena.
En la primera convocatoriastrtok_r()(matemáticas) génerosapunta a una cadena terminada en null.delimitadoresUna cadena delimitada que termina con un carácter nulo, yduraIgnora el valor señalado. La direcciónstrtok_r()devolverá un puntero al primer carácter del primer token del archivosEscribe el carácter nulo inmediatamente después del token devuelto, y actualiza quéduraPuntero al punto.
En llamadas posteriores, elses un puntero nulo yduradebe permanecer inalterado desde la llamada anterior, de modo que las llamadas posteriores se desplacen por la cadenas, devuelve tokens consecutivos hasta que no se retiene ningún token. Cadena separadoradelimitadorespuede ser diferente de la llamada. Si no hay tokensse devuelve el puntero NULL.
los siguientes códigos de dominio público.strtokincluirstrtok_rEl primero codifica un caso especial del segundo:
1TP5Incluido <string.h>
/ * strtok_r * /
char * (strtok_r ) (char * s . const char * delimitadores , char ** hormas )
{ char * sbegin , * send ;)
char * sbegin , * send ;
sbegin = s ? s : * hormas ; char ** hormas ) { char * sbegin , * send ; sbegin = s ?
sbegin + = strspn (sbegin, delimitadores); }
si (* sbegin == '\ 0') {
*lasts = "" ;
volver (o regresar) NULL ;
}
send = sbegin + strcspn (sbegin , delimiters ); }
si (* ¡enviar! = '\ 0')
* send ++ = '\ 0' ;)
* continue = send.
volver (o regresar) sbegin ;
}
/ * strtok * /
char * (strtok )(char *) restrinja s1. const char * restricción (separador)
{
estático char * ssave = "" ;
devolver strtok_r (s1 , delimitadores , &ssave );
}
Funciones varias
Estas características no encajan en ninguna de las categorías anteriores.
(utilizado como expresión nominal)memsetfunción (matem.)
void *memset(void *s, int c, size_t n);
deberíamemset()conversión de funcionescdebido aunsigned chary luego almacena los caracteres en elnEl primer byte de memoria apuntados.
Las siguientes son aplicaciones de dominio públicomemset::
1TP5Incluido <string.h>
/ * memset * /
void * (memset )(void * s , int c , size_t n )
unsigned char * us = s ;)
unsigned char * us = s ; unsigned char uc = c ; unsigned char
unsigned char uc = c ;
mientras que ¡(n - ! = 0 )
* us ++ = uc ;)
volver (o regresar) Trompeta.
}
(utilizado como expresión nominal)strerrorfunción (matem.)
char *strerror(int códigoerror);;
Esta función devuelve un mensaje de error específico de la localización correspondiente al argumento. Dependiendo de las circunstancias, esta función puede ser fácil de implementar, pero este autor no lo hará porque es diferente.
La versión 3 del sistema Unix tiene una variantestrerror_rExiste este prototipo:
int strerror_r(int errcode, char *buf, size_t buflen);
Esta función almacena el mensajebufEl tamaño de su longitudbuflen.
ejemplo típico
Para determinar el número de caracteres de una cadena, utilice lo siguientestrlen()función:
1TP5Incluido <stdio.h>
1TP5Incluido <string.h>
...
int longitud , longitud2 ;
char * pavo ;
estático char * flor = "begonia" ;
estático char * piedra preciosa = "rubí" ;
longitud = strlen (flor) ;
printf ("longitud=%d \ n ", longitud). //print 'longitud= 7' longitud
2 = strlen (gema);
pavo = malloc( longitud + longitud2 + 1 );
si （strcpy (pavo, piedra preciosa) {
strcpy (pavo, piedra preciosa); strcat (pavo, flor); strcpy (pavo, piedra preciosa); strcat (pavo, flor)
strcat (pavo, flor); strcpy (pavo, gema); strcat (pavo, flor)
printf ("%s \ n ", Turquía). //
freewareImprimir 'Ruby Begonia (pavo)
}
Tenga en cuenta que la cantidad de memoria asignada para "pavo" es la suma de uno más la longitud de la cadena a concatenar. Se utiliza para terminar los caracteres nulos y no cuenta para la longitud de la cadena.
ejercicio
- Las funciones de cadena utilizan muchas estructuras de bucle. Hay alguna forma de deshacer los bucles?
- ¿Qué funciones podría echar en falta la biblioteca en estos momentos?
Supongo que quieres leer:Programación en C. C. Intermedio 7. Instrucción Adicional
