Zhou Ligong, "Programming and Data Structure": String Functions

This article is the basis of program design, this article is the first point of 1.8.2 string constant: string function.

> > > >

String function

Standard C provides an interface string.h for manipulating strings. Many of these functions have special uses. The most important function prototypes exported via string.h are detailed below.

Strlen() function

The strlen() function is used to count the length of a string. The function prototype is as follows:

Size_t strlen(const char *s);

//   Precondition: s is a null-terminated string

//   Postcondition: The return value is the number of characters in s (excluding null characters)

The following function can shorten the length of the string, which uses strlen(). which is:

1 void fit(char *string, unsigned int size)

2 {

3 if(strlen(string) > size)

4 strlen[size] = '\0';

5 }

Since the function is going to change the string, the function does not use the const qualifier when declaring the parameter string. Of course, you can also call strlen(s) to determine the length of the string s, or use the if statement to compare the equality of the two strings. which is:

If(str cmp(s1, s2) == 0) ...

Strcat() function

The strcat() function for splicing strings accepts two strings as arguments. The function prototype is as follows:

Char *strcat(char *s1, char const *s2);

//   Precondition: s2 is a null-terminated string, and there is enough space at the end of the s1 array to accommodate a copy of s2

//   Postcondition: s2 is connected to s1, and the return value is a pointer to the first character of the s1 array

This function appends the backup of the second string to the end of the first string. The first character of the s2 string will overwrite the null character at the end of the s1 string, and the spliced ​​new string will be the first character. The string returns, the second string does not change. The type of strcat() function is char * (that is, a pointer to char), and the strcat() function returns the first argument, that is, the address of the first string after splicing the second string.

Since the strcat() function cannot check whether the first array can hold the second string, if the space allocated to the first array is not large enough, then the extra characters will overflow when they overflow into the adjacent storage unit. Of course, You can also use strlen() to see the length of the first array. Note that you need to add 1 to the length of the spliced ​​string to store the empty character at the end. Or use strncat (), the third parameter of the function specifies the maximum number of characters added, the function prototype is as follows:

Char *strncat(char *s1, char const *s2, size_t n);

This function copies the n characters in the s2 string to the end of the s1 string, and the first character in the s2 string overwrites the null character at the end of the s1 string. The null character and the following characters in the s2 string are not copied, and a null character is added at the end of the copy character. The function returns s1.

Strcmp () function and strncmp () function

The strcmp() function compares the contents of the string, not the address of the string. The function prototype is as follows:

Int strcmp(char const *s1, char const *s2);

//   Precondition: s1 and s2 are null-terminated strings

//   Postcondition: return value is 0, indicating s1=s2;

//   The return value is less than 0, indicating that s1 is in lexicographic order before s2;

//   The return value is greater than 0, indicating that s1 is in lexicographic order after s2

If the s1 string is after the s2 string in the machine sort sequence, the function returns a positive number; if the two strings are equal, it returns 0; if the s1 string is in front of the s2 string in the machine sorting sequence, Then returns a negative number. The strcmp() function compares a string ("hello") to a character ('q'), so its argument should be a string. Since the type of char is actually an integer type, you can use relational operators to compare characters. What if the first few characters of the two strings are the same? Strcmp() will compare each character in turn until the first pair of different characters is found, and then return the corresponding value. For example, "apples" and "apple" have only the last pair of characters ("apples" s and "apple" null characters). Since the null characters are ranked first in ASCII, the character s must be behind it, so strcmp () returns a positive number.

In the last example, strcmp() compares all characters, not just letters. Rather than comparing the functions in alphabetical order, it is better to compare them by machine sorting sequence, that is, according to the value of characters (ASCII value). In ASCII, uppercase letters are in front of lowercase letters, so strcmp("Z" , "a") returns a negative value.

In most cases, the exact value returned by strcmp() is not important. Just care if the value is 0 or non-zero, that is, compare the two values ​​for equality, or sort the strings alphabetically. In this case, you need to know that the result of the comparison is positive. , negative or 0. Suppose word is a string stored in an array of char types, and ch is a variable of type char. which is:

If(strcmp(word, "hello") == 0) puts("bye")

If(ch == 'q' ) puts("bye")

However, do not use ch or 'q' as an argument to strcmp().

Strcmp() compares the characters in two strings until a different character is found, which may continue until the end of the string. Strcmp() can compare different characters when comparing two strings, or compare only the number of characters specified by the third parameter. Its function prototype is as follows:

Int strncmp(char const *s1, char const *s2, size_t n);

Strcpy() function

The strcpy() function has two properties. First, the return value of strcpy() is char *. The function returns the value of the first argument, which is the address of a character. Second, the first argument does not have to point to the beginning of the array. This property can be used to copy a portion of the array. Note that strcpy() also copies the null characters in the source string.

If both pts1 and pts2 are pointers to strings, then the following statement copies the address of the string, not the string itself. which is:

Pts2 = pts1;

If you want to copy the entire string, you can use the strcpy() function. Its function prototype is as follows:

Char *strcpy(char *s1, char const *s2);

//   Precondition: s2 is a null-terminated string, and the s1 array has enough space to hold a copy of s2

//   Postcondition: s2 is copied to s1, and the return value is a pointer to the first character of the s1 array

This function copies the string pointed to by s2 (including null characters) to the position pointed to by s1, and returns s1. That is, strcpy() accepts 2 string pointers as arguments, and can declare the second pointer to the source string as a pointer, an array name, or a string constant, and the first pointer to the copy of the source string should point to a data. Objects, such as arrays, and objects must have enough space to store a copy of the string, usually the copied string is called the target string. Note that the declaration array will allocate space for storing data, while the declaration pointer only allocates space for storing one address.

Strncpy() function

Both strcpy() and strcat() have the same problem. They can't check if the target space can hold a copy of the source string. Therefore, it is safer to copy the string using strncpy(). The third parameter of the function indicates the maximum copyable. The number of characters. Its function prototype is as follows:

Char *strncpy(char *s1, char const *s2, size_t n);

This function copies the string pointed to by s2 to the position pointed to by s1. The copied character does not exceed n, and its return value is s1. This function does not copy the characters after the null character. If the number of characters in the source string is less than n, the target string ends with the copied null character. If the source string has n or more than n characters, the null characters are not copied, so there is not necessarily a null character in the copied copy. Based on this, the n setting is generally 1 less than the target array size, and then the last element of the array is set to a null character.

The purpose of this is to ensure that a string is stored. If the target space can hold a copy of the source string, the empty character copied from the source string is the end of the copy; if the target space cannot hold the copy, the copy will be The last element is set to a null character.

Although the C language allows strings to be treated as a character array or a pointer to a character, it would make more sense to understand the string from a more abstract perspective. If you want to access a single character in a string, you need to pay attention to its representation. If you treat the string as a whole, you can ignore the details of its performance and write a program that is easier to understand. such as:

Typedef char *striing;

The goal is to emphasize that a string is a completely different type of concept. Although strings are exactly the same as char * types, the information they pass is different. If a variable is defined as a char * type, its underlying representation is a pointer; if a variable is defined as a string, the string is treated as a whole. In this way, when declaring a function's formal parameters, whether they are arrays, pointers, or abstract data types, they are interchangeable. The declaration methods are as follows:

Int strlen(string cStr);

Int strlen(char cStr[]);

Int strlen(char *cStr);

Although the string.h interface provided by the standard C provides a series of string manipulation functions, it allows the string to be treated as a whole when the function is called, but these functions also require us to understand the underlying representation, that is, the function will allocate memory. The task is left to the user, especially to detect buffer overflow conditions. When using this interface, the user is responsible for the storage of each string. This type of distribution not only increases the burden on the programmer, but also indirectly increases the number of errors in the encoding.

Overflow problem

Using the gets() function to read a string from standard input can easily cause a buffer overflow, as is the misuse of strcpy() and strcat(). Because using some functions may cause an attacker to access memory with a formatted string attack, or even inject code, the C11 version adds the strcat_s() and strcpy_s() functions, which return an error if a buffer overflow occurs. Printf(), fprintf(), and snprintf() all accept formatted strings as arguments. An easy way to avoid such attacks is to not pass user-supplied formatted strings to these functions.