Introducción y realización simulada de funciones de cadena y funciones de memoria en lenguaje C

Language 2023-06-05 04:11:50 views: null

0. Prefacio

El procesamiento de caracteres y cadenas en lenguaje C es muy frecuente, pero el lenguaje C en sí mismo no tiene un tipo de cadena, y las cadenas generalmente se colocan en cadenas constantes o matrices de caracteres . Las constantes de cadena se aplican a las funciones de cadena que no las modifican.

1. Introducción y simulación de funciones de cadenas

  • El lenguaje C en sí tiene algunas funciones de biblioteca, por lo que si ve una función que otros no conocen, puede verificarla en este sitio web y recordar citar el archivo de encabezado correspondiente cuando use la función de biblioteca.

    [ Referencia - Referencia de C++ ]:

1.1 strl

Función para encontrar el número de cadenas

Por ejemplo

int main() 
{ 
    char arr1[] = "abcdef"; 
    int ret = strlen(arr1); 
    printf("%d\n", ret); 
    devolver 0; 
}

resultado de la operación

 

size_t strlen (const char * str);

  • La cadena tiene '\0' como marca final y la función strlen devuelve el número de caracteres que aparecen antes de '\0' en la cadena (sin incluir ).

  • size_t strlen (const char * str);

  • La cadena a la que apunta el parámetro debe terminar con '\0'.

  • Tenga en cuenta que el valor de retorno de la función es size_t, que no está firmado

  • simulelo usted mismo


// Implementar size_t a la manera de una calculadora my_strlen(const char* str) 
{ 
    int count = 0; 
    while (*str != '\0') 
    { 
        count++;// Cuenta el número de caracteres antes de '\0' 
        str++ ; 
    } 
    return count; 
} 
// implementar 
size_t recursivamente my_strlen(const char* str) 
{ 
    if (*str == '\0') 
        return 0; 
    else 
        return 1 + my_strlen2(str + 1); 
}

1.2 tiras

char* strcpy(char * destino, const char * fuente);

La función de copia de cadena puede darte dos cadenas, puedes poner una cadena en otro espacio

Por ejemplo

int main() 
{ 
​char
    arr1[] = "¡hola mundo!"; 
    char arr2[20] = { 0 }; 
    strcpy(arr2, arr1); 
    printf("%s\n", arr2); 
    devolver 0; 
}

resultado de la operación

 

  • La cadena de origen debe terminar con '\0' como carácter

  • Colocará una copia de '\0' de la cadena de origen en el espacio de destino

  • el espacio de destino debe ser mutable

  • El espacio en el espacio de destino debe ser lo suficientemente grande para caber en el espacio de destino

  • simulelo usted mismo

Implementación analógica de la función strcpy

#include <assert.h> 
char* my_strcpy(char* dest, const char* src) 
{ 
    assert(dest && src); 
​char
    * ret = dest; 
    while (*dest != *src) 
    { 
        *dest = *src ; // Asignar el caracter de src a dest 
        dest++; 
        src++; 
    } 
​return
    ret; 
}

De hecho, entendemos el juicio del ciclo while y podemos simplificar el código y asignar directamente el valor de src a dest en la parte de juicio del ciclo while.

Cuando el valor de src encuentra '\0' y lo asigna a dest, el ciclo while se detendrá y copiará todos los caracteres en src a dest

char* my_strcpy(char* dest, const char* src) 
{ 
    assert(dest && src); 
​char
    * ret = dest; 
    while (*destino++ = *src++) 
    { 
        ; 
    } 
​return
    ret; 
}

1.3 agrietado

char * strcat (char * destino, const char * fuente);

Función de agregar cadena, que puede agregar otra cadena en una cadena

Por ejemplo

int main() 
{ 
    char arr1[20] = "hola"; 
    char arr2[] = "¡mundo!"; 
    strcat(arr1, arr2); 
    printf("%s\n", arr1); 
​return
    0; 
}

resultado de la operación

  • 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.

  • ¿Se puede agregar la cadena a sí misma?

  • La respuesta es no, porque agregarse a sí mismo sobrescribirá '\0', '\0' es el signo del final de la cadena, y no puede detenerse si sobrescribe y agrega '\0'

Implementación analógica de strcat

char* my_strcat(char* dest, const char* src) 
{ 
    assert(dest && src); 
    char* ret = dest; 
    // encuentra target'\0' 
    while (*dest != '\0') 
    { 
        dest++; 
    } 
    // copiar al espacio de destino 
    while (*dest++ = *src++) 
    { 
        ; 
    } 
    
    return ret; 
}

1.4 strcmp

int strcmp (const char * str1, const char * str2);

Función de comparación de cadenas, si los caracteres en arr1 son mayores que los caracteres en arr2, devuelve el número> 0, si los caracteres en arr1 son más pequeños que los caracteres en arr2, devuelve el número <0,

Si el carácter en arr1 es igual al carácter en arr2 devuelve = 0.

Por ejemplo

int main() 
{ 
    char arr1[] = "abcd"; 
    char arr2[] = "abc"; 
    int ret = strcmp(arr1, arr2); 
    printf("%d\n", ret); 
    devolver 0; 
}

Resultados de la

 

 

regulación estándar

  • 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

  • La primera cadena es menor que la segunda cadena, devuelve un número menor que 0

Implementación analógica de strcmp

int my_strcmp(const char* str1, const char* str2) 
{ 
    afirme(str1 && str2); 
    while (*str1 == *str2) 
    { 
        if (*str1 == '\0') 
           devuelve 0; 
        str1++; 
        str2++; 
    } 
    
    si (*str1 > *str2) 
        devuelve 1; 
    de lo contrario, 
        devuelve -1; 
devuelve
    *str1 - *str2; 
}

1.5 fuerte

char * strncpy (char * destino, const char * fuente, size_t num);

Similar a la función de la función strcpy, n representa num, que puede especificar el número de cadenas copiadas

Por ejemplo

int main() 
{ 
​char
    arr1[] = "¡hola mundo!"; 
    char arr2[20] = { 0 }; 
    strncpy(arr2, arr1,5); 
    printf("%s\n", arr2); 
    devolver 0; 
}

Resultados de la

 

char * strncat (char * destino, const char * fuente, size_t num);

  • Copie num 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.

1.6 gato fuerte

char * strncat (char * destino, const char * fuente, size_t num);

Similar a la función de strcat, n también significa número, agregue números de caracteres al espacio de destino

Por ejemplo

int main() 
{ 
    char arr1[20] = "hola"; 
    char arr2[] = "¡mundo!"; 
    strncat(arr1, arr2,6); 
    printf("%s\n", arr1); 
​return
    0; 
}

Resultados de la

 

1.7 strncmp

int strncmp (const char * str1, const char * str2, size_t num);

Similar a la función de strcmp, puede especificar comparar números de caracteres

Por ejemplo

int main() 
{ 
    char arr1[] = "abcd"; 
    char arr2[] = "abce"; 
    int ret = strncmp(arr1, arr2,4); 
    printf("%d\n", ret); 
    devolver 0; 
}

Resultados de la

 

int strncmp (const char * str1, const char * str2, size_t num);

  • Compare hasta que otro carácter sea diferente o una cadena termine o se comparen todos los caracteres numéricos.

1.8 calle

  char * strstr (const char * str1, const char * str2 );

Una función para encontrar una subcadena, si hay una subcadena, se imprimirá la cadena completa

Por ejemplo

int main() 
{ 
    char arr1[] = "abcdefg"; 
    char arr2[] = "abc"; 
char
    * p = strstr(arr1, arr2); 
    if (*p == NULL) 
    { 
        printf("no encontrado \ n"); 
    } 
    más 
    { 
        printf("%s\n", p); 
    } 
​return
    0; 
}

Resultados de la

 

Implementación analógica de la función strstr

char* my_strstr(const char* str1, const char* str2) 
{ 
    assert(str1 && str2); 
    char* s1 = NULO; 
    char* s2 = NULO; 
    char* cp = str1; 
    while (*cp) 
    { 
        s1 = cp; 
        s2 = (carácter*)str2; 
        while (*s1 && *s2 && *s1 == *s2) 
        { 
            s1++; 
            s2++; 
        } 
        if (*s2 == '\0') 
        { 
            return cp; 
        } 
        cp++; 
    } 
    devuelve NULL; 
}

1.9 carrera

char * strtok (char * str, const char * delimitadores);

  • delimitadores es el delimitador, que divide la cadena larga en varias cadenas cortas según el delimitador

  • El parámetro de delimitadores contiene 0 o más delimitadores

  • 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 las cadenas divididas con la función strtok generalmente son contenido copiado temporalmente y se pueden modificar).

  • El primer parámetro de la función strtok no es NULL, la función encontrará la primera marca en str y la función strtok guardará su posición en la cadena.

  • El primer parámetro de la función strtok es NULL, la función comenzará en la posición guardada en la misma cadena y buscará el siguiente token.

  • Devuelve un puntero NULL si no hay más tokens en la cadena.

Divide una cadena larga en varias subcadenas según el delimitador

Por ejemplo

int main() 
{ 
    char arr[] = "192.168.222.33"; 
    char buf[30] = { 0 }; 
    strcpy(buf, arr); 
    const char* p = "."; 
    char* str = strtok(buf, p); 
    printf("%s\n", str); 
​str
    = strtok(NULL, p); 
    printf("%s\n", str); 
​str
    = strtok(NULL, p); 
    printf("%s\n", str); 
​str
    = strtok(NULL, p); 
    printf("%s\n", cadena); 
    devolver 0; 
}

Resultados de la

 

2.0 estrellas

Función de información de devolución de código de error, esta función puede devolver un mensaje de error siempre que le proporcione un código de error

Por ejemplo

int main() 
{ 
    char* str = strerror(0); 
    printf("%s\n", str); 
​str
    = strerror(1); 
    printf("%s\n", str); 
​str
    = strerror(2); 
    printf("%s\n", str); 
​str
    = strerror(3); 
    printf("%s\n", str); 
​str
    = strerror(4); 
    printf("%s\n", cadena); 
    devolver 0; 
}

Resultados de la

 

2.1 memcpy

void * memcpy ( void * destino, const void * origen, size_t num );

  • La función memcpy copia números de bytes de datos hacia atrás desde el origen hasta el destino.

  • Esta función no se detiene cuando encuentra '\0'

  • Si hay alguna superposición entre el origen y el destino, el resultado de la copia no se puede conocer

La función de copia de memoria tiene dos espacios y puede colocar el contenido de un espacio en otro.

Por ejemplo

int main() 
{ 
    int arr1[] = { 1,2,3,4,5,6,7,8 }; 
    int arr2[10] = { 0 }; 
    memcpy(arr2, arr1,32); 
    int i = 0; 
    int sz = tamaño de (arr1) / tamaño de (arr1 [0]); 
    for (i = 0; i < sz; i++) 
    { 
        printf("%d ", arr2[i]); 
    } 
​retorna
    0; 
}

Resultados de la

 

Aquí coloque el contenido de la matriz arr1 en la matriz arr2

Implementación analógica de la función memcpy

void* my_memcpy(void* dest, const void* src, size_t num) 
{ 
    assert(dest && src); 
    void* ret = dest; 
while
    (num--) 
    { 
        *(char*)dest = *(char*) src;// Transferir a la fuerza dest (char*) y luego eliminar la referencia, de manera similar, src también es 
        dest = (char*)dest + 1;//Retroceder la posición original de dest 
        src = (char*)src + 1 ;/ / Regresar a la posición original de src 
    } 
    return ret; 
}

2.2 movimiento de memoria

void * memmove ( void * destino, const void * origen, size_t num );

  • La diferencia entre memcpy y memmove es que la función memmove maneja que el bloque de memoria de origen y el bloque de memoria de espacio de destino pueden superponerse

  • Si el bloque de memoria de origen y el bloque de memoria de espacio de destino se superponen, debe usar la función memmove

Por ejemplo

int main() 
{ 
    int arr1[] = { 1,2,3,4,5,6,7,8,9,10 }; 
    movimiento de memoria(arr1, arr1+2, 12); 
    int i = 0; 
    int sz = tamaño de (arr1) / tamaño de (arr1 [0]); 
    for (i = 0; i < sz; i++) 
    { 
        printf("%d ", arr1[i]); 
    } 
    devuelve 0; 
}

Coloque el contenido de arr1 hacia atrás 12 bytes en arr1, es decir, cubra 1, 2, 3 con 4, 5, 6, y luego el contenido detrás permanece sin cambios

Resultados de la

 

Implementación de simulación de la función memmove

void* my_memmove(void* dest, const void* src, size_t num) 
{ 
    assert(dest && src); 
    vacío* ret = destino; 
    if (dest < src) 
    { 
        while (num--) 
        { 
            // 前往后
            *(char*)dest = *(char*)src; 
            destino = (char*)destino + 1; 
            src = (char*)src + 1; 
        } 
    } 
    else 
    { 
        // 后往前
        while (num--) 
        { 
            *((char*)dest + num) = *((char*)src + num); 
        } 
    } 
    retorno ret; 
}

Esto se divide en dos casos: cuando dest<src, copia de adelante hacia atrás, y cuando dest>src, copia de atrás hacia adelante. La comparación aquí es la posición, que se puede ver en el dibujo.

destino<origen

 

destino>origen

 

2.3 memcmp

int memcmp (const void * ptr1, const void * ptr2, size_t num);

  • Compara números de bytes a partir de los punteros ptr1 y ptr2

  • El valor de retorno es el siguiente

 

Ejemplo de uso

int main() 
{ 
    int arr1[] = { 1,2,3,4,6 }; 
    int arr2[] = { 1,2,3,4,5 }; 
    int ret = memcmp(arr1, arr2, 17); 
    printf("%d\n", ret); 
​}

Resultados de la

 

Aquí no llevaremos a todos a simular la implementación, y aquellos que estén interesados ​​​​pueden estudiarlo por sí mismos.

Supongo que te gusta

Origin blog.csdn.net/weixin_64214213/article/details/130833139
Recomendado
Clasificación
Diario
Más
2024-05-16(22)
2024-05-15(5)
2024-05-14(10)
2024-05-13(7)
2024-05-12(22)
2024-05-11(31)
2024-05-10(32)
2024-05-09(31)
2024-05-08(18)
2024-05-07(35)

Code World

© 2018 codetd.com