contenido
1. Encuentra la función de longitud de cadena
2. Funciones de cadena con longitud ilimitada
3. Funciones de cadena de longitud limitada
5. Función de operación de memoria
1. Encuentra la función de longitud de cadena
1.1 estrellas
size_t strlen (const char * str);
Se utiliza para encontrar la longitud de la cadena.
La cadena termina con '\0' y la función strlen devuelve el número de caracteres que aparecen antes de '\0' en la cadena (excluyendo
'\0').
La cadena a la que apunta el parámetro debe terminar con '\0'.
El valor de retorno de la función es size_t, que es el número de cadenas y es un entero sin signo.
Ejemplo de uso:
#include<stdio.h>
#include<string.h>
int main()
{
char str[] = "duachebdbvla";
int sz = sizeof(str);
printf("%d", sz);
return 0;
}Implementación simulada de strlen :
int my_strlen(const char* str)
{
assert(str);
int i = 0;
while (*str++)
{
i++;
}
return i;
}
2. Funciones de cadena con longitud ilimitada
2.1 tiras
char* strcpy(char * destino, const char * fuente);
Se utiliza para copiar cadenas.
La cadena de origen debe terminar con '\0'.
Copiará '\0' en la cadena de origen al espacio de destino.
El espacio de destino debe ser lo suficientemente grande para contener la cadena de origen.
El espacio de destino debe ser mutable.
Ejemplo de uso:
#include<stdio.h>
#include<string.h>
int main()
{
char str1[20] = "duachebdbv";
char str2[20] = "0";
strcpy(str2, str1);
printf(str2);
return 0;
}Implementación simulada de strcpy:
char* my_strcpy(char*des,const char*src)
{
char* tmp = des;
assert(des && src);
while (*des++ = *src++;)
{
;
}
return tmp;
}2.2 strcmp
int strcmp (const char * str1, const char * str2);
Se utiliza para comparar el tamaño de las cadenas.
Si la primera cadena es mayor que la segunda cadena, devuelve un número mayor que 0. Si la
primera cadena es igual a la segunda cadena, devuelve 0. Si
la primera cadena es menor que la segunda cadena, devuelve un número menor que 0. número
Ejemplo de uso:
#include<stdio.h>
#include<string.h>
int main()
{
char str1[20] = "asdfghj";
char str2[20] = "awsdefghjjjk";
int ret=strcmp(str1, str2);
if (ret > 0)
{
printf("str1>str2");
}
else if (ret == 0)
{
printf("str1=str2");
}
else
{
printf("str1<str2");
}
return 0;
}Nota: Debido a que strcmp no compara la longitud de la cadena, sino que compara el valor del código ascii de los caracteres correspondientes al mismo subíndice, si los caracteres son iguales, compare el siguiente hasta que los dos sean diferentes. Este código se debe a que str1[0] y str2[0] son ambos a, así que compare el siguiente carácter, str1[1] es 's', str2[1] es 'w', y el valor del código ascii de s es menor que el valor ascii de w , por lo que se devuelve un número entero menor que 0.
Implementación simulada:
int my_strcmp(const char* str1, const char* str2)
{
assert(*str1 && *str2);
while (*str1 || *str2)
{
if (*str1 == *str2)
{
str1++;
str2++;
}
else
{
return *str1 - *str2;
}
}
return 0;
}
2.3 cadena
char * strcat (char * destino, const char * fuente);
Copia una cadena al final de otra cadena.
La cadena de origen debe terminar con '\0'.
El espacio de destino debe ser lo suficientemente grande para albergar el contenido de la cadena de origen.
El espacio de destino debe ser modificable.
Ejemplo de uso:
#include<stdio.h>
#include<string.h>
int main()
{
char str1[20] = "kajhcjeef";
char str2[40] = "jdsafbkw";
strcat(str2, str1);
printf(str2);
return 0;
}
Implementación simulada:
char* my_strcat(char* des, const char* scr)
{
char* tmp = des;
assert(des && scr);
while (*des)
{
des++;
}
while (*des++=*scr++)
{
;
}
return tmp;
}La implementación de las tres funciones anteriores, strcoy, strcmp y strcat, no es más que detenerse cuando '\0' o comparar el tamaño de dos caracteres, que no tiene nada que ver con la longitud de la cadena, por lo que podemos pensar que estas tres funciones son ilimitadas en longitud. Los siguientes strncoy, strncmp, strncat están relacionados con la longitud.
3. Funciones de cadena de longitud limitada
3.1 fuerte
char * strncpy (char * destino, const char * fuente, size_t num);
Copia números de caracteres de la cadena de origen al espacio de destino.
Si la longitud de la cadena de origen es inferior a num, después de copiar la cadena de origen, agregue 0 al final de la cadena de destino hasta num.
Ejemplo de uso:
#include<stdio.h>
#include<string.h>
int main()
{
char str1[20] = "kajhcjeef";
char str2[40] = "jdsafbkw";
strncpy(str2, str1,3);
printf(str2);
return 0;
}
Implementación simulada:
char* my_strncpy(char* des, const char* scr, int num)
{
char* ret = des;
assert(des && scr);
while (num--&&*scr&&*des)
{
*des++ = *scr++;
}
return ret;
}3.2 strncmp
int strncmp (const char * str1, const char * str2, size_t num);
Se utiliza para comparar el tamaño de los primeros caracteres numéricos de dos cadenas.
La comparación se detiene cuando dos caracteres son diferentes, o cuando termina una cadena, o cuando el número de caracteres de comparación es num. Cuando la cadena compuesta por el primer número de caracteres de str1 es mayor que la cadena compuesta por el primer número de caracteres de str2, devuelve un entero mayor que 0, devuelve 0 cuando es igual y devuelve un entero menor que 0 cuando es menos que.
Ejemplo de uso:
#include<string.h>
#include<stdio.h>
int main()
{
char str1[20] = "jajhcjeef";
char str2[40] = "jasafbkwn";
int ret=strncmp(str1, str2, 3);
printf("%d", ret);
return 0;
}
Implementación simulada:
int my_strncmp(const char* str1, const char* str2, int num)
{
assert(str1 && str2);
while (num--&&(*str1||*str2))
{
if (*str1 != *str2)
{
return *str1- *str2;
}
else
{
str1++;
str2++;
}
}
return 0;
}
3.3 gato fuerte
char * strncat (char * destino, const char * fuente, size_t num);
Se utiliza para añadir cadenas.
Copia los primeros números de caracteres de la cadena de origen al final de la cadena de destino (comenzando con '\0').
Ejemplo de uso:
#include<stdio.h>
#include<string.h>
int main()
{
char str1[20] = "jajhcjeef";
char str2[40] = "ja";
strncat(str2, str1, 6);
printf(str2);
return 0;
}
Implementación simulada:
#include<stdio.h>
#include<assert.h>
char* my_strncat(char* des, const char* scr, int num)
{
char* ret = des;
assert(des && scr);
while (*des)
{
des++;
}
while (num && ((*des++ = *scr++) != '\0'))
{
num--;
}
if (num == 0)
*des = '\0';
return ret;
}4. Búsqueda de cadenas
4.1 calle
char * strstr (const char *str1, const char * str2);
Encuentre la cadena str2 en la cadena str1, si la encuentra, devuelva la dirección inicial de la misma cadena de fragmento en la cadena str1 que la cadena str2.
Ejemplo de uso:
#include<stdio.h>
#include<string.h>
int main()
{
char str1[20] = "jajhcjeef";
char str2[40] = "cj";
char* tmp = strstr(str1, str2);
printf("%s",tmp);
return 0;
}
Implementación simulada:
#include<stdio.h>
//#include<string.h>
#include<assert.h>
char* my_strstr(const char* str, const char* substr)
{
const char* s1 = str;
const char* s2 = substr;
const char* cur = str;
assert(str && substr);
if (*substr == '\0')
{
return (char*)str;
}
while (*cur)
{
s1 = cur;
s2 = substr;
while (*s1 && *s2 && *s1 == *s2)
{
s1++;
s2++;
}
if (*s2 == '\0')
return (char*)cur;
cur++;
}
return NULL;
}4.2 carrera
char * strtok ( char * str, const char * sep );
Se utiliza para dividir una cadena de acuerdo con un delimitador especificado por el usuario.
El primer argumento especifica una cadena que contiene cero o más tokens separados por uno o más delimitadores en la cadena sep
. El segundo parámetro sep es una cadena que define el conjunto de caracteres utilizados como separadores .
La función strtok encuentra el siguiente token en str, lo termina con \0 y devuelve un puntero a este token . (Nota:
la función strtok cambiará la cadena que se está manipulando, por lo que la cadena segmentada por la función strtok generalmente es el contenido de una copia temporal
y se puede modificar).
El primer parámetro de la función strtok no es NULL, la función encontrará the str El primer token en la función strtok guardará su
posición en la cadena.
El primer argumento de la función strtok es NULL, y la función comenzará en la posición guardada en la misma cadena y buscará el siguiente
token.
Si no hay más tokens en la cadena, se devuelve un puntero NULL.
Ejemplo de uso:
#include<stdio.h>
#include<string.h>
int main()
{
char str1[50] = "zhouling#123.b@uo";
const char sep[10] = "#.@";
char arr[50];
char* ch = NULL;
strcpy(arr, str1);
for (ch = strtok(arr, sep);ch != NULL; ch = strtok(NULL, sep))
{
printf("%s\n", ch);
}
return 0;
}
5. Función de operación de memoria
5.1 memcpy
void *memcpy( void * dest , const void * src , size_t count );
La función memcpy copia números bytes de datos hacia atrás desde la ubicación de origen a la ubicación de memoria de destino.
Esta función no se detiene cuando encuentra '\0'. Esta función es algo similar a strcmp, pero esta función puede copiar números enteros u otros tipos de datos.
Si hay alguna superposición entre el origen y el destino, el resultado de la copia es indefinido.
Utilice el ejemplo 1:
#include<stdio.h>
int main()
{
char str1[] = "zhouling";
char str2[] = "mlanvkml";
int arr1[4] = { 1,2,3,4 };
int arr2[4] = { 5,6,7,8 };
int i = 0;
char*str = memcpy(str2, str1, sizeof(str1[0]) * 2 );
int* arr = memcpy(arr1, arr2, sizeof(arr1[0]) * 2);
for (i = 0; i < 4; i++)
{
printf("%d ", arr[i]);
}
printf("\n");
printf("%s", str);
return 0;
}
Utilice el ejemplo 2:
#include<stdio.h>
#include<string.h>
struct PeoPle
{
char name[20];
int age;
}People1,People2;
int main()
{
char myname[] = "zhouling";
People1.age = 18;
memcpy(People1.name, myname, sizeof(myname)+1);
memcpy(&People2, &People1, sizeof(People1));
printf("People2:%s %d", People2.name, People2.age);
return 0;
}
Implementación simulada:
void* my_memcpy(void* dst, const void* src, size_t count)
{
void* ret = dst;
assert(dst&&src);
while (count--)
{
*(char*)dst = *(char*)src;
dst = (char*)dst + 1;
src = (char*)src + 1;
}
return ret;
}5.2 movimiento de memoria
void * memmove ( void * destino, const void * origen, size_t num );
La función es básicamente la misma que memcpy, pero la diferencia con memcpy es que el bloque de memoria de origen y el bloque de memoria de destino procesados por la función memmove pueden superponerse.
Si el espacio de origen y el espacio de destino se superponen, es mejor usar la función memmove para solucionarlo.
Ejemplo de uso:
#include <stdio.h>
#include <string.h>
int main()
{
char str[] = "I don't love you and you like.......me";
memmove(str + 25, str + 2,11);
puts(str);
return 0;
}
Implementación simulada:
void * my_memmove(void* des, const void* scr, int num)
{
void* ret = des;
assert(des && scr);
while (num--)
{
if (des < scr)
{
*((char*)des)++ = *((char*)scr)++;
}
else
{
*((char*)(des)+num) = *((char*)(scr)+num);
}
}
return ret;
}5.3 memcpy
int memcmp( const void * buf1 , const void * buf2 , size_t count );
Compara el número de bytes a partir de los punteros ptr1 y ptr2 , si el primero es mayor que el segundo, se devuelve un número entero mayor que 0, de lo contrario, se devuelve un número entero menor que 0 y 0 si son iguales.
Ejemplo de uso:
#include <stdio.h>
#include <string.h>
int main()
{
char buffer1[] = "zhouzhou";
char buffer2[] = "zhdhZhou";
int n;
n = memcmp(buffer1, buffer2, 2);
if (n > 0) printf("'%s' is greater than '%s'.\n", buffer1, buffer2);
else if (n < 0) printf("'%s' is less than '%s'.\n", buffer1, buffer2);
else printf("'%s' is the same as '%s'.\n", buffer1, buffer2);
return 0;
}
Implementación simulada:
int my_memcmp(const void* buf1, const void* buf2, size_t count)
{
void* tmp1 = buf1;
void* tmp2 = buf2;
assert(buf1 && buf2);
while (count--)
{
if (*((char*)tmp1) != *((char*)tmp2))
{
return *((char*)tmp1) - *((char*)tmp2);
}
((char*)tmp1)++;
((char*)tmp2)++;
}
}Muy bien, ese es el final del intercambio de notas de estudio de hoy, por favor dale me gusta si lo ves aquí