[C language foundation] 12 strings

1、 String and literal string

  Literal string ：

   A sequence of characters enclosed in a pair of double quotation marks ( Program text ), Is part of the source file , It only means literally . Such as “Hello”（ Occupy 6 Characters , Default include 0）, Different from string constants , The literal string is changeable .

  character string ：

   The literal string is compiled to generate a string , Located in the system memory 、 A sequence of characters ending in a null character .
  Such as char word[] = {'H', 'e', 'l', 'l', 'o', '!', '\0'}; （ Is a character array , It's also a string ）

A character array ：

   Such as char word[] = {'H', 'e', 'l', 'l', 'o', '!'}; （ Is a character array , But it's not a string ）

explain ：

• Spaces in literal strings （ Such as "Good morning!"） It's not an empty character , Blank ASCII Code is 32, Empty character ASCII Code is 0.

1.1 Escape sequence in literal string

Escape sequences can be used in literal strings , Such as \n etc. .
“Hello, \nWorld!”

• **/ Octal number escape sequence ：
  • stay 3 A number or non octal digit character ends . for example ："\1234" Contains two characters (\123 and 4),"\189" Contains three characters (\1,8 and 9).
• Hexadecimal number escape sequence ：
• End with the first non 16 Hexadecimal digit sign . The range is usually \x0~\xff Between .

See escape sequence in this chapter

1.2 Continuation string

The string is too long , Continue on the next line .

1.2.1 Using the characters '\'

The next line needs to be written in the top grid , otherwise Tab The symbol will be output .

	printf("Amateurs sit and wait for inspiration, \ the rest of us just get up and go to work. -Stephen King");

1.2.2 Split into multiple strings

The compiler automatically concatenates adjacent strings , No need to write in the top grid .
*820

	printf("Amateurs sit and wait for inspiration, "
	47"the rest of us just get up and go to work. -Stephen King");

1.3 String store

Strings are stored as character arrays . The compiler will allocate n + 1 Memory space to store a length of n String . Ends with a null character , Marks the end of the string . All bits of the empty character are 0, Escape sequence \0 Express .

explain ：

• In whole numbers 0 A string of characters at the end .
• Do not confuse empty characters with zero characters .\0 and '0' equivalent （ Integers ）, But with '0' Different （ character ）.
• 0 Flag string end , But it is not part of the string . String length is calculated without it .
• The string exists as an array , Access as an array or pointer ( Traverse ).
• Two adjacent strings will be automatically connected , Become a large string , No longer interval 0.
• Operators cannot be used to operate on strings
• string.h Provide a variety of string processing functions .
• char* Does not necessarily point to a string , It may point to a single character or an array of characters , When there is an integer at the end of the indicated character array 0 when , Is to point to the string .

1.4 String operation

Allow any available char * Use string where pointer .

1.4.1 Pointer to string

char *p;
p = "abc";   // Define a pointer , Point to abc. Not creating a string “abc”

1.4.2 Subscript the string

C Language allows subscripts to pointers , You can also subscript strings . The length is n String , Subscript range 0~n+1.

char ch1,ch2;
ch1 = "abc"[1];   // ch1 = b
ch2 = "abc"[3];   // ch2 = 0（ Null character ）

Application, for example, ：

// take 0~15 Convert the decimal number of to the corresponding 16 Hexadecimal characters 
char digit_to_hex_digit(int digit)
{
    
	return "0123456789ABCDEF"[digit];
}

1.4.3 Common mistakes

String constants cannot be changed , Otherwise, it will result in undefined behavior , Cause the program to crash .
for example ：

char *p = "abc";
*p = 'd';          // error 

The literal string can be changed ：

char a[] = "hello";
a[1] = 'a';                  // legal 
printf("a[] = %s\n", a);     // Output hallo

1.5 String and character constants

   A string containing a single character is different from a character constant .

• character string “a” Denote with a pointer , Point to the character immediately following the empty character "a" The memory unit of ;
• character 'a' By integer (ASCII code ) Express

2、 String variable

 Any one-dimensional array that ends with a null character can store strings .

 The best way to determine the length of a string is to search for empty characters .

Define a store 80 Character string ：

#define STR_LEN 80 // Does not define 81 To emphasize the maximum length of the string 
...
char str[STR_LEN + 1];   // Reserve the position of empty characters 

• String length ： Depends on the empty character position （ Empty characters follow the end of the string , Not necessarily at the end of the character array ） length ：0~STR_LEN
• Character array length ： Defined array length , The length is STR_LEN + 1.

2.1 Initialize string variables

char word[] = "Hello";      // Automatically calculate and allocate the length , Variable length 
char date[8] = "June 16";   //7+1,  Spaces are not empty characters 
char date1[8] = {
    'J','u','n','e',' ','1','6','\0'};   // Same as the previous one 
char date2[10] = "June 16"; // Initializer is not full 

Storage Demo ：

• When the string array is not filled , The compiler will automatically fill up with empty characters , Consistent with array initializer （ repair 0）.
• C Language allow initializer ( Not included \0) Same as array length , But it is not recognized as a string .

char date3[7] = "June 16";  // Empty character bits are not reserved 

The above just defines a character array , It's not a string .

2.2 Character array and character pointer

char date[] = "June 14";
char *date = "June 14";

Of the above two statements date Can be used as a string , But not interchangeable .

The difference ：

• When declared as an array , The string content can be modified ; When declared as a pointer , read-only , Do not modify the , The reason is that a pointer to a literal string is declared "June 14" The pointer to , The literal string cannot be modified , This is different from the pointer of the variable .
• When declared as an array ,date It's an array name ; When declared as a pointer ,date It's a variable. ( Pointer to the variable ), Can point to other strings .

give an example ：
example 1：char* s = "Hello, world!";

• s Point to string constant . read-only , The content cannot be modified , Equate to const char* s. This string is stored in the code segment of the program .

example 2：char word[] = "Hello world!";

• Array of strings , The content can be modified . Stored in data segments

Want to construct a string —— Using arrays ( Modifiable )
Want to process a string —— Use the pointer ( read-only , Do not modify the )

• char *str = "Hello"; —— The pointer str The pointing content is Hello Array of characters
• char word[] = "Hello"; —— Define character array , The contents of the array are Hello
• char line[10] = "Hello"; —— Define the length as 10 Array of characters line, Internal storage 6 Characters （ Containing the logo 0）.

3、 Reading and writing of strings

3.1 Write string

3.1.1 Use printf function

Use conversion instructions %s.%.ps Show the previous p Characters ,%ms In the length of m The string is displayed in the column of , Right alignment , String length exceeds m when , It won't cut , It's a complete display .printf Function writes strings one by one , Until a null character is encountered .

give an example ：

char str[] = "Well done!";
printf("%s\n", str);                // Full display 
printf("%12s\n", str);              // stay 12 The cells show , Right alignment 
printf("%5s\n", str);               // stay 5 The cells show , Right alignment 
printf("%.7s\n", str);              // Before display 7 position 
printf("%12.4s\n", str);            // stay 12 Before the display in the grid 4 position , Right alignment 
printf("%-12.4s\n", str);           // stay 12 Before the display in the grid 4 position , Align left 

Output results ：

Be careful ：

• The string output format provides the first address to store the string array , therefore printf The expression after the format string of the function is str Instead of *str . This is different from the output of a single element , Is the special feature of string output .

3.1.2 Use puts function

char str[] = "Well done!";
puts(str);             //puts The output will wrap automatically 

Output results ：

3.1.3 Single character output ——putchar function

The function prototype ：int putchar(int c);

• The parameter of the function is int type , Instead of char type ;
• Output a character （C In language char Occupy 1 Bytes ）;
• The return value is also int type , Indicates the number of characters written ,EOF(-1) Indicates write failure .

3.2 Read string

3.2.1 use scanf function

   Use conversion instructions %s To read the string , There is no need to take the address character &, The string array name itself is treated as a pointer .
  scanf When the function reads characters , Looking for the starting position of the string will skip white space characters , After starting reading, it will stop when encountering data of non read type , When storing a string, an empty character will be automatically added at the end .

• To ensure that the defined string array is not filled with read data , You can use %ns To limit the number of characters read .

char string[8];
scanf("%s", string);—— Array name as pointer , There is no address character &,scanf Read in a word ( To space 、tab Or enter ) A maximum of... Is allowed 7 Characters ( The end needs to be empty 0 The location of )
scanf("%7s", string); —— Read at most 7 Characters ,

3.2.2 use gets function

scanf And gets Difference of function ：

• gets The function does not skip white space characters before starting to read the string （scanf Will skip ）;
• gets Will continue to read , Stop until you encounter a newline （scanf The function stops when it encounters any white space character ）
• gets Line breaks will not be stored （scanf Will store , And replace ）

give an example ：

char sentence[LEN + 1];
printf("Enter a sentence: ");

scanf("%s", sentence);     // Input "To C, or not to C: that is the question."
//gets(sentence);

printf("%s\n", sentence);

Output results ：

• Use scanf function ：
     Stop when white space characters are encountered , The rest is left to be read at the next call .
  

• Use gets function ：
     Stop when you encounter a newline .
  

3.2.3 Read the string character by character ——getchar function

The function prototype ：int getchar(void);

• The parameter is empty. ;
• The return value is int type , return EOF(-1) End of input ：
  • Windows The system is input Ctrl + Z When to return to EOF
  • Unix System is Ctrl + D return EOF
• Read in a character from standard input ;

Read one by one —— read_line function

The question to consider ：

• Before starting to store strings , Whether to skip white space characters ;
• When to stop reading ： A newline 、 Any white space characters, etc , Whether to store the last such characters ？
• What if the string exceeds the length of the array ： Ignore or wait for the next call to read ？

give an example ：

//  Read characters one by one to str[] in , Limit the number of reads to n

int read_line(char str[], int n)
{
    
	int ch, i = 0;
	
	while( (ch = getchar() != '\n') )    // Condition to stop reading 
		if( i<n ) str[i++] = ch;         // Limit the number of stored characters 
	str[i] = '\0';                       // Store empty characters at the end 
	
	return i;                            // return str Number of characters in 
}

3.2.4 Common mistakes

error 1： The pointer variable modifies the data it points to without initializing

char* string;
scanf("%s", string);        // I plan to store the input data in string Point to memory area 
string[0] = 'a';            // Going to the  *string  Of  0  Sign write character a

The above code does not initialize the pointer ,char* Does not necessarily point to a string , Data in unknown areas may be modified , It's a very serious mistake .

error 2：

• char buffer[100] = “”;
  An empty string ,buffer[0] == ‘\0’
• char buffer[] = “”;
  The length of this string is 1.

4、 Access characters in a string

   Strings are stored as arrays , You can use array subscripts to access , It is more convenient to use pointers to access .

• String as a function formal parameter , You don't have to ask for string length , By looking for empty characters ('\0') It can be used as the end condition of traversal .

4.1 Use array subscripts to access

int count_spaces(const char s[])    // take s Declared as an array ,const Protect the stored string from being modified 
{
    
	int i, count = 0;
	for(i = 0; s[] != '\0'; i++)
		if(s[] == ' ') count++;
	return count;
}

4.2 Use pointers to access

int count_spaces(const char *s)    // take s Declare as a pointer ,const Protect the string pointed to from being modified 
{
    
	int i, count = 0;
	for( ; *s != '\0'; s++)        //s Modified as a pointer copy , but *s still const type 
		if(*s == ' ') count++;
	return count;

• s Can be defined as an array , It can also be defined as a pointer , There is no difference in function between the two , The compiler will treat array type formal parameters as pointers .

5、 String Library <string.h>

   Operator cannot operate on string , Use string operation function . Treat strings as arrays .

char str1[11], str2[11];
str = "abc";      // String assignment , Illegal operation 
str2 = str1;      // The string is copied directly , Illegal operation 

char str3[11] = "abc";   // Legal operation , Initialization is not assignment 

if(str1 == str2) ...     // Legal operation , But the comparison is the address , It's not a string 

5.0 The resources

Usage instructions of each library function
Library function source code download

5.1 strcpy function （ Copy ）

5.1.1 strcpy function

(1) The function prototype

•    char *strcpy(char *s1, const char *s2);
• C99：char *strcpy(char *restrict s1, const char *restrict s2);
  • keyword restrict Ensure that the storage positions of two strings cannot overlap , Improve system efficiency and security .

(2) function

hold s2 The string pointed to is copied to str1 The string pointed to , And return the copied pointer s1 .

(3) explain

• Function return type is pointer type , The return value is s1 （ Pointer to the copied target object ）;
• s2 yes const type , Play a protective role ;
• The function encounters an empty character of the copied string (\0) To terminate . Empty characters will also be copied .

(4) Function recurrence

char *mycpy(char *destination, const char *source){
    
	char ret = destination;                // Backup destination address 
	
	while( *source != '\0' )
		*destination++ = *source++;        // Copy one by one 
	
	*destination = '\0';
	
	return destination;
}

(4) Call example

str = "abcd";            // Incorrect usage 

strcpy(str1, "abcd");     // legal , to str2 assignment 
strcpy(str2, str1);       // legal , take str1 Copied to the str2

strcpy( str2, strcpy(str1, "abcd") );   // legal , take str1 and str2 Are assigned as "abcd"

(5) matters needing attention

Need assurance str1 ( Copy target object ) The length of is not less than str2 ( Copied object ) The length of . Otherwise, the function will cross str1 The defined array boundary continues to be copied , Until a null character is encountered .

char str1[3];
strcpy(str1, "abc");     // error ,str1 The maximum length that can be accommodated is 2 String 

5.1.2 strncpy function

(1) The function prototype

char *strncpy(char *s2, const char *s1, size_t n );
C99： char *strncpy(char *restrict s2, const char *restrict s1, size_t n );

n = sizeof(s2)

(2) The functionality

Limit the number of characters copied , Guarantee str2 Can accommodate copied characters , Not beyond str2 The boundary of the .

(3) Be careful

This function does not copy str1 The last empty character

(4) Optimized code

strncpy( str2, str1, sizeof(str2)-1 );     // Reserve the last digit 
str2[ sizeof(str2)-1 ] = '\0';             // Ensure the last ( The first n-1 position ) Store empty characters 

5.2 strlen function （ Find the length ）

(1) The function prototype

size_t strlen( const char *s );

(2) function

return s The length of the string pointed to .

(3) explain

• The return type is size_t type ( typedef,C Unsigned integers in languages ), Returns the length of the string ;
• The string length count does not contain empty characters ;
• Different from several other functions , This function does not return a pointer , It's an integer value .

(4) Call example

int len;

len  = strlen("abc");                 //len = 3
len = strlen(" ");                    //len = 1

strcpy(str1, "abc");
len = strlen(str1);                    //len = 3,  The length of the array is not measured , It's the length of the string 
len = strlen( strcpy(str2, "abcd") );  //len = 4

5.3 strcat function （ Splicing ）

5.3.1 strcat function

strcat —— string catenation（ String connection ）

(1) The function prototype

   char *strcat(char *str1, const char *str2);
C99：char *strcat(char* restrict s1, const char* restrict s2);

(2) function

Put the string str2 Point to , Joining together to str1 At the end of , And return the stitched pointer str1 .

(3) explain

• To be added ...

(4) Function recurrence

int* mycat(char* s1, const char* s2)
{
    
	int i = 0;
	while( s2[i] != '\0' ){
    
		s1[strlen[s1] + i] = s2[i];
	}
	s1[strlem[s1]+i] = '\0';
	return s1;
}

(5) Call example

strcpy(str1, "abc");    //str1 assignment 
strcpy(str2, "xyz");    //str2 assignment 
strcat(str1, "def");    // After splicing  str1 == abcdef
strcat(str1, str2);     // After splicing  str1 == abcdefxyz

(5) Be careful

And strcpy identical , Need assurance str1 The length of can accommodate the spliced string .

char str1[6] = "abc";
strcat(str1, "def");     // Program error ,str1 It can only accommodate at most 5 Characters 

5.3.2 strncat function

(1) The function prototype

   char *strncat(char *s1, const char *s2,size_t n );
C99： char *strncat(char *restrict s1, const char *restrict s2,size_t n );

n = sizeof(s1) - strlen(s1) - 1

(2) function

Put the string str2 Point to , Joining together to str1 At the end of , And return the stitched pointer str1 .

(3) explain

• The first 3 The first parameter is calculation str1 Remaining usable length of , And reserve empty character position .( sizeof Calculation str1 Total length ,strlen Calculation str1 Length of stored string ,-1 Reserve empty character position );
• The execution speed will be higher than strcat More slowly , But it's safer .

5.4 strcmp function （ Compare ）

5.4.1 strcmp function

(1) The function prototype

int strcmp( const char *s1, const char *s2 );
C99： int strcmp( const char *restrict s1, const char *restrict s2 );

(2) function

Function comparison s1 and s2 The content of the string pointed to , And return according to the comparison result —— Less than 、 be equal to and Greater than 0 Value .

(3) explain

• Criteria of judgment ： According to the numeric code of the character (ASCII code )

• Judgment process ： Start with the first character and compare the characters in the corresponding position one by one ASCII code .

• ASCII Common properties of codes ：

  • A ~ Z、a ~ z、0 ~ 9 The numerical code of is continuous ;
  • Numbers < Capital < Lowercase letters . Numbers (48 ~ 57)、 Capital (65 ~ 90)、 Lowercase letters (97 ~ 122);
  • Space character ' ' ( ASCII = 32 ) Less than all printed characters ;
  • Null character '\0'( ASCII = 0 ) .

Comparison results	Return value	give an example
s1 < s2	<0	“abc” < “bcd” “abc” < “abcd”
s1 == s2	0	“abc” == “abc”
s1 > s2	>0	“abc” > “ab” “abc” > “aba”

(4) Function recurrence

int mycmp(const char* s1, const char* s2){
    
	while( *s1==*s2 && *s1 != '\0' ){
    
		s1++;
		s2++;
	}
	return *s1 - *s2;     // Return difference 
}

(5) Be careful

• Depending on the compiler , The return value does not have to be -1 、0 、1. for example strcmp("Abc", "abc") The return value of may also be -32 ,A And a Of ASCII The code just differs 32.
• Arrays cannot be compared directly , The result of array comparison is always False. for example ：

char s1[] = "abc";
char s2[] = "abc";
printf(" expression  s1==s2  The value of is  %d\n", s1==s2);

The output of the program is ： expression s1==s2 The value of is 0
because s1 and s2 Is a pointer , The comparison is the address , Instead of the array contents it points to .

5.4.2 strncmp function

(1) The function prototype

C99： int strcmp(const char *s1, const char *s2, size_t n);

(2) function

Compare the first... In the string n Characters

5.5 String search

5.5.1 strchr function （ Single character forward search ）

(1) The function prototype

char *strchr(const char *s, int c);

(2) function

From a string left Start , Search one by one to find the first character ‘c’ The location of ( The pointer ). If it is not found, a null pointer is returned NULL.

(3) Call example

• Find the number of characters 1 A place

char s[] = "hello";
char *p = strchr(s, 'l');     // p = &s[2]

printf("%s\n", p);            // Output llo

• Find the number of characters 2 A place

char s[] = "hello";
char *p = strchr(s, 'l');
p = strchr( p+1, 'l' );       // Skip the first l, p = &s[3]

• Copy the second half of the string starting from the target character to other strings

char s[] = "hello";
char *p = strchr(s, 'l');
char *t = (char*)malloc( strlen(p)+1 );
strcpy(t, p);
printf("%s\n", t);            // Output llo
free(t);

• Copy from the first half of the string of the target character to another string

char s[] = "hello";
char *p = strchr(s, 'l');
char c = *p;                  //p Data backup at location 
*p = '\0';                    // take s stay p Fill in empty characters at the position of , take s truncation 
char *t = (char*)malloc( strlen(s)+1 );
strcpy(t, s);
*p = c;                       // Restore string s
printf("%s\n", t);            // Output he
free(t);

(4) strrchr function （ Single character reverse retrieval ）

From a string On the right side Start , Search one by one to find the first character ‘c’ The location of ( The pointer ). If it is not found, a null pointer is returned NULL.

5.5.2 strstr function （ String retrieval ）

(1) The function prototype

char *strstr(const char *s1, const char *s2);

(2) function

In string s1 Search string in s2 The location of , return s1 Point to s2 The first pointer , Case sensitive . If it is not found, a null pointer is returned NULL.

(3) strcasestr function

String retrieval functions that ignore case .

5.6 Comprehensive examples

5.5.1 Show the schedule of a month by date

【C Add 】【 character string 】 Show the schedule of a month by date

6、 Array of strings

6.1 Regular string array

Same as general two-dimensional array , Indicate the number of columns , Ignore the number of lines .

char planet[][8] = {
     "Mercury", "Venus", "Earth", "Mars", 
				 	 "Jupiter", "Saturn", "Uranus", "Naptune" };

shortcoming ： Because the length of each line of string is different , Not many lines will not be filled , Waste of space , This is especially true for large arrays .

6.2 Irregular string array

Method ： Create a special one-dimensional array , Array elements do not store strings directly , Instead, store pointers to strings .

char *planet[] = {
     "Mercury", "Venus", "Earth", "Mars", 
				   "Jupiter", "Saturn", "Uranus", "Naptune" };

planets Each element in the pointer to a string ending in a null character .

Search for a specific string ：

for(i=0; i<9; i++)
	if( planet[i][0] == 'M' )            // Search for M Starting string 
		printf("%s\n", planet[i]);       // See the instructions below 

explain ：
   final printf Function , Use planet[i], Instead of *planet[i] Because the output is a string , Strings are stored as arrays , What you need to provide is the first address of the string array , See this chapter for details 3.1.1 section .*planet[0] It stores a single character ‘f’ , Cannot output in string format .

6.3 Command line arguments

(1) Concept

In order to enable the operating system to use the command line to access program information , Must be main A function is defined as a function with two parameters , Respectively argc and argv.

int main( int argc, char *argv[] ){
    
	...
}

argc —— Parameter count , Number of stored command line parameters .
argv —— Parameter vector , An array of pointers to command line arguments . Command line parameters are stored as strings , So it is char* type .

argv[0] Point to program name ,argv[1] ~ argv[argc-1] Point to the remaining command line arguments ,argv[argc] Is a null pointer , The null pointer does not point anywhere .

stay UNIX In the system , The user enters the command line ls -l remind.c

Show command line parameters line by line ：

// Method 1:
int i;
for(i=1; i<argc; i++){
    
	printf("%s\n", argv[i]);
}

// Method 2:
char **p;
for(p=&argv[1]; *p != NULL; p++ )
	printf("%s\n", *p);

(2) Comprehensive application ： Check whether there is the name of the planet in the input command line

User input ： planet Jupiter venus Earth fred
Program output ： Is there a planet name on the command line , If there is a description of the planet serial number .

By command line rules , On the command line planet For the program name .

int main(int argc, char* argv[])
{
    
	char *planet[] = {
     "Mercury", "Venus", "Earth", "Mars", 
					   "Jupiter", "Saturn", "Uranus", "Naptune" };
	int i, j;
	
	for(i=1; i<argc; i++){
                  // Check the command line 
		for(j=0; j<8; j++){
                 // Check string 
			if(argv[i] == planet[j]){
    
				printf("%s is planet %d\n", argv[i], j+1);
				break;                  // Check successful , Out of the inner circle , Check the next command line parameter 
			}
			if(j == 8)
				printf("%s id not a planet.\n", argv[i]);
		}
	}
	
	return 0;
}