Sugerencia: Una vez escrito el artículo, la tabla de contenido se puede generar automáticamente. Para saber cómo generarlo, consulte el documento de ayuda a la derecha.
Directorio de artículos
Prefacio
El procesamiento de caracteres y cadenas en lenguaje C es muy frecuente, pero el lenguaje C en sí no tiene un tipo de cadena, y las cadenas generalmente se colocan en cadenas constantes o matrices de caracteres. Las constantes de cadena son adecuadas para aquellas funciones de cadena que no las modifican.
Uno, strlen
La función devuelve el número de caracteres que aparecen antes de '\ 0' en la cadena, y la cadena a la que apunta el parámetro debe terminar con '\ 0'. La siguiente es la implementación de la simulación:
#include<stdio.h>
#include<assert.h>
#include<string.h>
//模拟实现strlen
int my_strlen(const char *string){
assert(string != NULL);
int count = 0;
const char *p = string;
while (*p++ != '\0'){
count++;
}
return count;
}
void main(){
char *str = "abcdef";
printf("%d\n", my_strlen(str));
}
Dos, strcpy
Hay dos parámetros para asignar el valor del primero a la primera cadena. La cadena de origen debe terminar con '\ 0', y el '\ 0' en la cadena de origen se copiará en el espacio de destino. El espacio de destino debe ser lo suficientemente grande para garantizar que la cadena de origen se pueda almacenar. El modo se implementa de la siguiente manera:
#include<stdio.h>
#include<assert.h>
#include<string.h>
//模拟实现strcpy
char * my_strcpy(void *dest, const void *src)
{
assert(dest!=NULL && src!=NULL);
char *pdest = (char *)dest;
const char *psrc = (const char *)src;
while (*psrc != '\0'){
*pdest++ = *psrc++;
}
pdest= '\0';
return dest;
}
void main(){
char *str = "abcdse";
char arr[20] = {
0};
printf("%s\n", my_strcpy(arr, str));
}
Tres, strcmp
Función de comparación, para comparar el tamaño de las cadenas, esta función comienza a comparar el primer carácter de cada cadena. Si son iguales, continúa comparándose con lo siguiente hasta que los caracteres sean diferentes, o hasta que se
alcance el carácter nulo final. (Tenga en cuenta que aunque aquí se usa la comparación ASCII, los códigos ASCII de todos los caracteres no se suman y se cuentan como un todo. Al principio, creo que sí, pero strcmp compara los caracteres uno por uno. Una vez que se publica el resultado, terminará inmediatamente y volverá)
#include<stdio.h>
#include<assert.h>
#include<string.h>
//模拟实现strcmp
int my_strcmp(const char *string1, const char *string2)
{
assert(string1 != NULL && string2 != NULL);
const char *ps1 = string1;
const char *ps2 = string2;
while (*ps1 != '\0' && *ps2 != '\0')
{
if (*ps1 > *ps2)
return 1;
else if (*ps1 < *ps2)
return -1;
ps1++;
ps2++;
}
if (*ps1 != '\0')
return 1;
if (*ps2 != '\0')
return -1;
return 0;
}
void main()
{
char *str1 = "Hello";
char *str2 = "HelloAAA";
int ret = my_strcmp(str1, str2); //<0 ==0 >0
if (ret == 0)
printf("str1 == str2");
else if (ret < 0)
printf("str1 < str2");
else
printf("str1 > str2");
}
Cuatro, strcat
"Añade" el carácter de origen al destino, más un carácter nulo de terminación. La cadena de origen debe terminar con '\ 0', el espacio de destino debe ser modificable y el espacio debe ser lo suficientemente grande.
#include<stdio.h>
#include<assert.h>
#include<string.h>
//模拟实现strcat
char *my_strcat(void *dest, const void *src)
{
assert(dest != NULL &&src != NULL);
char *pdest = (char *)dest;
char *psrc = (const char *)src;
while (*pdest){
pdest++;
}
while ((*pdest++ = *psrc++));
return dest;
}
void main(){
char *str = "bcdef";
char ar[20] = {
'a'};
printf("%s\n", my_strcat(ar, str));
}
Cinco, strstr
Devuelve un puntero a la primera aparición de str2 en str1. Si str2 no es parte de str1, devuelve un puntero nulo.
#include<stdio.h>
#include<assert.h>
#include<string.h>
//模拟实现strstr
char *my_strstr(const char*src, const char*dest)
{
assert(dest != NULL &&src != NULL);
char *pdest = (const char *)dest;
char *psrc = (const char *)src;
char *s1 = (const char *)src;
if (*pdest == '\0')
return NULL;
while (*psrc){
psrc = s1;
while (*pdest && *psrc && (*pdest == *psrc)){
pdest++;
psrc++;
}
if (*pdest == '\0')
return s1;
s1++;
}
return NULL;
}
void main(){
char str[20] = "abcdef";
char ar[20] = "bc";
printf("%s\n", my_strstr(str, ar));
}
Seis, memmove
Similar a la función memcpy, la diferencia es que puede manejar la superposición del bloque de memoria de origen y el bloque de memoria de destino.
#include<stdio.h>
#include<assert.h>
#include<string.h>
//模拟实现memmove
void* my_memmove(void *dest, const void *src, size_t count)
{
assert(dest != NULL && src != NULL);
char *pdest = (char *)dest;
const char *psrc = (const char *)src;
if (psrc >= pdest || pdest >= psrc + count)
{
while (count-- > 0)
{
*pdest++ = *psrc++;
}
}
else
{
//存在内存重叠
psrc = psrc + count - 1;
pdest = pdest + count - 1;
while (count-- > 0)
{
*pdest-- = *psrc--;
}
}
return dest;
}
void main()
{
char str[20] = "abcdefghijk";
char st[20]="acsxd";
printf("str = %s\n", str);
memmove(st, str, 4);
//my_memmove(str + 2, str, 4);
printf("str = %s\n", st);
printf("str = %s\n", str);
}
Cuando se cancela la función que determina la superposición, es lo mismo que la función memcpy. Así que no revisaré la función memcpy aquí.
para resumir
Además de estas funciones, hay strncpy, strncat, strncmp y funciones similares. Además del origen y el destino, los parámetros de estas funciones son de longitud, por lo que es relativamente simple de simular e implementar, que consiste en cambiar las condiciones del bucle while El éxito está relacionado con esta longitud (cuenta–> 0).