C language advanced part III. string functions and memory operation functions

Catalog

String function ：

strlen

strcpy

strcat

strcmp

strstr

strtok

strerror

Memory manipulation function ：

memcpy

memmove

memcmp

---

String function ：

Find the string length

strlen

The prototype of this function is   size_t strlen ( const char * str );

Realization ：

size_t strlen ( const char * str)
{
        const char *eos = str;

        while( *eos++ ) ;

        return( eos - str - 1 );
}

The function implementation is to find the first one starting from the character pointer ‘\0’ until , So use the change function to find the length of the string , The string should be in the form of ‘\0’ ending , Otherwise, the length obtained is unpredictable . Because the return value is size_t That is, unsigned shaping , So use strlen(str1)-strlen(str2)>0 It is not necessarily effective to compare str1 and str2 The length of , Because the difference will not be negative .

Unlimited length string function

strcpy

char* strcpy(char * destination, const char * source );

Realization ：

char* strcpy(char* const destination,char const*source)
{
    char* des = destination;
    while ((*destination++ = *source++) != '\0') { }
    return des;
}

String copy function , take source The starting string is copied to destination Include ‘\0’, The function implementation is found from the source string ‘\0’, Stop after copying , Therefore, the source string must be in '\0' end .

The target space has to be large enough , To ensure that the source string can be stored , Otherwise, you will illegally access memory .

The target space must be changeable （ Not constant string, etc ）.

strcat

Prototype ：char * strcat ( char * destination, const char * source );

String append function , Realization ：

char *  strcat (char * dst,const char * src)
{
        char * cp = dst;

        while( *cp )
                cp++;                   /* find end of dst */

        while((*cp++ = *src++) != '\0') ;       /* Copy src to end of dst */

        return( dst );                  /* return dst */

}

Find the destination string first ‘\0’ And then from ‘\0’ Start appending to the source string ‘\0’ Also copy the past , so The target space must be large enough , It can hold the contents of the source string . The target space must be modifiable . The source string must be in '\0' end .

strcmp

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

Compare the characters of two strings in turn ASCII Code value , The return value is specified as follows ：

The standard stipulates ：

The first string is larger than the second string , Return greater than 0 The number of

The first string is equal to the second string , Then return to 0

The first string is less than the second string , Then return less than 0 The number of

Realization ：

int  strcmp (const char * src, const char * dst)
{
        int ret = 0 ;

        while((ret = *(unsigned char *)src - *(unsigned char *)dst) == 0 && *dst)
                {
                ++src, ++dst;
                }

        return ((-ret) < 0) - (ret < 0); // (if positive) - (if negative) generates 
                                                              //branchless code
// Limit the return value to 0,1,-1
}

Introduction to string functions with limited length

strncpy

char * strncpy ( char * destination, const char * source, size_t num );

strncat

char * strncat ( char * destination, const char * source, size_t num );

strncmp

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

Similar to the above string function with limited length , But there is one more parameter num ： The number of characters , You can specify the number of characters for the operation .

String search

strstr

A function that finds a substring in a parent string , Will return the character pointer of the first substring found .

Function implementation ：（ The original method finds the substring , Than KMP,sunday And other algorithms are inefficient ）

 From a string str1 Find string in str2

char *  strstr (const char * str1,const char * str2)
{
        char *cp = (char *) str1;
        char *s1, *s2;

        if ( !*str2 )  Substring str2 It's empty , Return parent string 
            return((char *)str1);

        while (*cp)
        {
                s1 = cp; String pointer 
                s2 = (char *) str2; Substring pointer 

                while ( *s2 && !(*s1-*s2) )
                        s1++, s2++;

                if (!*s2) If the substring pointer points to ‘\0’, Find success , Return the corresponding parent string position 
                        return(cp);

                cp++;
        }

        return(NULL);

}

String cutting function

strtok

Prototype ：

For example, two strings ：

char string[] = "A string\tof ,,tokens\nand some  more tokens";
char seps[]   = " ,\t\n";

Usage method

 printf( "%s\n\nTokens:\n", string );
   /* Establish string and get the first token: */
   token = strtok( string, seps );
   while( token != NULL )
   {
      /* While there are tokens in "string" */
      printf( " %s\n", token );
      /* Get next token: */
      token = strtok( NULL, seps );// Pass in NULL, The function will start from last '\0' Start cutting at the back 
   }

  After each cutting with this function, this function will return the address before cutting , And modify the original string cutting character to '\0', The next cut will be from ‘\0’ Start , In this way, you will get

 A
 string
 of
 tokens
 and
 some
 more
 tokens

Error message report

strerror

Pass in the error code errno, This function returns the first address of the error message string , Used to print error messages

Memory manipulation function ：

memcpy

Memory copy function , Definition ：

void * memcpy ( void * destination, const void * source, size_t num );

Parameters num Is the number of bytes copied , The function implementation is copied byte by byte .

Simulation Implementation

function memcpy from source The position of begins to be copied back num Bytes of data to destination Memory location for .

This function is encountering '\0' It doesn't stop .

If source and destination There is any overlap , The results of replication are undefined （ Use memmove function ）

memmove

And memcpy similar , But it's more powerful , Can achieve destination and source Overlapping copies , Because function implementations are copied from overlapping areas .

Simulation Implementation

memcmp

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

Compare two memory areas byte by byte , similar strcmp The function compares the corresponding data ASCII Code value .

Realization ：

int memcmp(char* buf1,char *buf2,unsigned count)
{
    if (!count)
        return(0);
    while (--count && *buf1 == *buf2)
    {
        buf1++;
        buf2++;
    }
    return(*buf1 - *buf2);
}