1. strlen (por longitud)
size_t strlen (const char * str)
El tipo de valor de retorno de la función es size_t, que es un número sin signo, y el valor de retorno de strlen es el número de caracteres antes de '\0' en la cadena.
Adivina la salida de este programa
if (strlen("abc") - strlen("abcdef"))
{
printf(">");
}
else
{
printf("<");
}si, si>
Debido a que el valor de retorno de strlen no tiene signo, -3 se convierte en un entero positivo grande.
2. strcpy (copiar)
char* strcpy (char * destino, const char * fuente)
Cuando se usa, la cadena de origen debe terminar con \0, y '\0' también se copiará
strcpy: "No me importa si puedes ponerlo o no, lo copiaré".
La dirección de destino debe ser lo suficientemente grande y modificable, de lo contrario, aunque se puede ingresar, el programa fallará
Implementación de simulación de strcpy
char* my_strcpy(char* dest,const char* source)
{
assert(dest && source);
char* ret = dest;
while (*dest++ = *source++);
return ret;
}3. strcat (añadir)
char * strcat ( char * destino , const char * origen)
La cadena de origen debe tener '\0' y la cadena de destino también debe tener '\0'
Después de agregar, el '\0' del espacio de destino desaparece y se agrega el '\0' de la cadena de origen
La dirección de destino debe ser grande y modificable
Implementación de simulación de strcat
char* my_strcat(char* dest,char* source)
{
assert(dest && source);
char* ret = dest;
while (*dest)
{
dest++;
}
while (*dest++ = *source++);
return ret;
}Cuatro.strcmp
int strcmp(const char* cadena1, const char * cadena2)
La función strcmp compara la longitud de la función que no es una cadena.
En su lugar, compare el tamaño de los caracteres en las posiciones correspondientes de la cadena. Si son iguales, compare el siguiente par de caracteres para saber si son diferentes o encontrará '\0'.
Devuelve 0 si es igual y devuelve un número mayor que cero si es mayor. Devuelve un número menor que cero si es menor que
Implementación de simulación de strcmp
int my_strcmp(const char* str, const char* qtr)
{
assert(str && qtr);
while (*str == *qtr)
{
if (*str == '\0')
return 0;
str++;
qtr++;
}
if (*str > *qtr)
return 1;
else
return -1;
}Cinco.strncpy
char * strncpy (char * dest, const char * source, size_t count)
La función es copiar los primeros caracteres de conteo de la cadena de origen a la cadena de destino
char a[] = "abcd";
char b[] = "qwer";
strncpy(a,b,1);Por ejemplo, la cadena modificada anterior es qbcd
Implementación de simulación de strncpy
#define _CRT_SECURE_NO_WARNINGS 1
#include<string.h>
#include<stdlib.h>
#include<stdio.h>
void my_strncat(char*dest,char*src,size_t n)
{
int t = strlen(dest);
int f = strlen(src);
for (int i = 0; i < n; i++)
{
*(dest + i) = *src;
src++;
}
}
int main()
{
int n;
scanf("%d", &n);
char src[50], dest[50];
strcpy(dest, "NICE");
strcpy(src, "SHOOT");
my_strncat(dest,src,n);
printf("%s", dest);
}Seis.strncat
char * strncat ( char * dest , const char * source ,size_t count)
La función es agregar los primeros caracteres de conteo de la cadena de origen al destino,
y agregará '\0' al final
char arr1[]="abcdef\0xx";
char arr2[]="qwer";
strncat(arr1,arr2,2);
Modificado a abcdefqw
Implementación de simulación de strncat
#define _CRT_SECURE_NO_WARNINGS 1
#include<stdio.h>
#include<string.h>
#include<assert.h>
void my_strncpy(char* str, char* qtr, int size)
{
assert(str && qtr);
int t = strlen(str);
for (int i = 0; i < size ; i++)
{
*(str + t + i) = *qtr;
qtr++;
}
*(str + t + size) = '\0';
}
int main()
{
char src[50], dest[50];
strcpy(src, "A nice");
strcpy(dest, " BOYYYYYYY");
int n = 0;
scanf("%d", &n);
my_strncpy(src, dest, n);
printf("%s", src);
}Siete.strncmp
int strncm (const char * str, const char * qtr, size_t num)
Especifica comparar los primeros números de caracteres, otros son iguales a strcmp
Ocho.strstr
const char * strstr ( const char * str1, const char * str2 );
char * strstr ( char * str1, const char * str2 );
Se utiliza para buscar subcadenas, devuelve la primera dirección encontrada
Nueve.strtok
char * strtok (char * str, const char * sep)
El parámetro sep es una cadena que consta de delimitadores.
str es una cadena que contiene cero o más delimitadores en sep.
strtok encontrará el primer delimitador en str, lo reemplazará con '\0' y devolverá un puntero a este delimitador
Si el primer parámetro es '\0'', busque otro separador hacia atrás desde la posición guardada en la ola anterior
Devuelve un puntero NULL si no hay más delimitadores en la cadena
char a[] = "[email protected]";
char sep[] = "@.";
printf("%s", strtok(a, sep));
printf("%s", strtok(NULL, sep));Si el resultado anterior es Anice
char a[] = "[email protected]";
const char sep[] = "@.";
char arr[30];
char* str = NULL;
strcpy(arr, a);
for (str = strtok(arr, sep); str != NULL; str = strtok(NULL, sep))
{
printf("%s", str);
}La salida anterior es Aniceboy
Diez.strerror
char * strerror (int errnum)
errno es una variable global que registra el último código de error. Cuando el programa acaba de iniciarse, errno se establece en 0. Durante la ejecución del programa, cualquier error en cualquier función puede modificar el valor de errno para que no sea cero. Valor para informar al usuario que ocurrió un tipo específico de error.
Eleven.memcpy
void * memcpy ( void * dest , const void * source ,size_t count)
El rol es copiar los primeros bytes de conteo de la cadena de origen al destino.
int a1[20] = {1,2,3,4,5,6,7,8};
int a2[5] = {0};
memcpy(a1,a2,20);
Después de la ejecución, los primeros cinco elementos de la matriz a1 se convierten en 0
Implementación simulada de memcpy:
Ya que la copia de memcpy se realiza byte a byte
La implementación se puede simular con el siguiente código
void* my_memcpy(void* dest, const void* source, size_t count)
{
assert(source && dest);
void* ret = dest;
while (count--)
{
*(char*)dest = *(char*)source;
source=(char*)source+1;
dest=(char*)dest+1;
}
return ret;
}Doce.memmove
void * memmove （void * dest ,const void * source ,size_t count）
Se pueden implementar copias de memoria superpuestas
Implementación simulada:
void* my_memmove(void* dest, const void* source, size_t count)
{
if (dest < source)
{
while(count--)
{
*(char*)dest = *(char*)source;
dest = (char*)dest + 1;
source = (char*)source + 1;
}
}
else
{
while (count--)
{
*((char*)dest + count )= *((char*)source + count);
}
}
}Trece.memcmp
void * memcpy ( void * str , const void * qtr , size_t count)
Compare los primeros bytes de conteo de str y qtr, tenga en cuenta que es una comparación byte por byte
Eso es interesante
Por favor vea el siguiente código
int a[5] = { 1,2,3,4,5 };
int b[5] = { 1,2,3,4,0x11223305};
memcmp(a,b,16);Obviamente, los primeros dieciséis bytes de la matriz son iguales y devuelven 0, pero ¿qué pasa con los primeros diecisiete?
Esto se debe a que 5 se almacena como 05 00 00 00
0x11223305 es 05 33 22 11
Catorce.memset
void * conjunto de memoria ( void * dest , int c ,size_t count)
La función es cambiar los primeros bytes de conteo al parámetro c
int a[]={0,0x22222222};
memset(a,1,8);Por ejemplo, la matriz anterior se convierte en 0x01010101, 0x0101010101