C-Sprache – Zeichenfunktionen und Zeichenfolgenfunktionen

Inhaltsverzeichnis der Serienartikel

---

---

Vorwort

Zweck: Erlernen der wichtigsten gängigen Zeichenfolgen und Zeichenfolgenfunktionen sowie des Simulationsprozesses einiger Funktionen.

1. Zeichenklassifizierungsfunktion

Es gibt eine Reihe von Funktionen in der C-Sprache, die auf die Zeichenklassifizierung spezialisiert sind, also darauf, zu welcher Art von Zeichen ein Zeichen gehört.
Die Verwendung dieser Funktionen erfordert eine Header-Datei namens ctype.h.

Die Verwendungsmethoden dieser Funktionen sind sehr ähnlich. Wir werden eine Funktion erklären, die anderen sind jedoch sehr ähnlich:

 	int islower ( int c );

islower kann bestimmen, ob c im Parameterteil Kleinbuchstaben ist.
Verwenden Sie den Rückgabewert, um anzugeben, ob es sich um ein Kleinbuchstabe handelt. Wenn es ein Kleinbuchstabe ist, wird eine Ganzzahl ungleich 0 zurückgegeben. Wenn es kein Kleinbuchstabe ist, wird 0 zurückgegeben .

Fall 1:
Schreiben Sie einen Code, um die Kleinbuchstaben in der Zeichenfolge in Großbuchstaben umzuwandeln und andere Zeichen unverändert zu lassen.

#include <stdio.h>
#include <ctype.h>
int main ()
{
    
    
 	int i = 0;
 	char str[] = "Test String.\n";
 	char c;
 while (str[i])
 {
    
    
 	c = str[i];
 	if (islower(c)) {
    
    
 		c -= 32;
 	}
  	putchar(c);
 	i++;
 }
 return 0;
}

Ausgabeergebnis:

Ändern Sie den gesamten Inhalt des Zeichenarrays in Großbuchstaben.

2. Zeichenkonvertierungsfunktion

Die C-Sprache bietet zwei Zeichenkonvertierungsfunktionen:

	int tolower ( int c ); //将参数传进去的⼤写字⺟转⼩写 
	int toupper ( int c ); //将参数传进去的⼩写字⺟转⼤写

Im obigen Code konvertieren wir Kleinbuchstaben in Großbuchstaben, was den Effekt von -32 darstellt. Mit der Konvertierungsfunktion können wir die Tolower-Funktion direkt verwenden
, um die Zahl zu berechnen.
Fall 2:

#include <stdio.h>
#include <ctype.h>
int main ()
{
    
    
 	int i = 0;
 	char str[] = "Test String.\n";
 	char c;
 	while (str[i]){
    
    
 		c = str[i];
 		if (islower(c)) 
 		c = toupper(c);
 		putchar(c);
 		i++;
 	}
 	return 0;
}

Dies unterscheidet sich von Fall 1, bei dem es sich um -32 handelt, den Großbuchstaben, der durch Subtrahieren des Werts von ASCLL erhalten wird. Fall 2 wird innerhalb der Funktion ausgeführt.

3. Verwendung und Simulationsimplementierung von strlen

Funktionsinhalt:

Berechnen Sie die Länge der Zeichenfolge und beenden Sie sie, wenn \0 gefunden wird.

size_t strlen ( const char * str );

1. Die Zeichenfolge verwendet „\0“ als Endmarkierung und die strlen-Funktion gibt die Anzahl der Zeichen zurück, die vor „\0“ in der Zeichenfolge erscheinen (ausgenommen „\0“).
2. Die Zeichenfolge, auf die der Parameter zeigt, muss mit „\0“ enden.
3. Beachten Sie, dass der Rückgabewert der Funktion size_t ist, der ohne Vorzeichen (fehleranfällig) ist.
4. Die Verwendung von strlen erfordert die Einbindung der Header-Datei <string.h>

Simulationsimplementierung von strlen:

Fall 1:

//计数器⽅式
int my_strlen(const char * str)
{
    
    
 	int count = 0;
 	assert(str);//断言一下，执行函数之前不为NULL指针。
 	while(*str){
    
    //str == \0,时停止。
 		count++;
 		str++;
 	}
 	return count;
}

Fall 2:
Implementiert das Zählen rekursiv, ohne temporäre Variablen zu erstellen.

//不能创建临时变量计数器
int my_strlen(const char * str)
{
    
    
 	assert(str);
 	if(*str == '\0'){
    
    
 		return 0;
 	}
 	else 
 		return 1+my_strlen(str+1);
}

analysieren:

Fall 3:
Zeiger-Zeiger-Methode: Im Array entspricht sie der Anzahl der Elemente zwischen Zeigern.

int my_strlen(char *s)
{
    
    
 	assert(str);
 	char *p = s;
 	while(*p != ‘\0’ )
 		p++;
 	return p-s;
}

4. Verwendung und Simulationsimplementierung von strcpy

Inhalt der Funktionsbibliothek:

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

Gibt die Adresse des ersten Elements zurück

1. Die Quellzeichenfolge muss mit „\0“ enden.
2. „\0“ in der Quellzeichenfolge wird in den Zielbereich kopiert.
3. Der Zielraum muss groß genug sein, um sicherzustellen, dass die Quellzeichenfolge gespeichert werden kann.
4. Der Zielraum muss veränderbar sein.

Zum Beispiel:
Konstante Strings können nicht geändert werden, daher sind String-Funktionen grundsätzlich für String-Arrays gedacht.

Fall 1:

Kopieren Sie die Zeichenfolge „holle“ an den Anfang von str1 + 4

#include<stdio.h>
#include<string.h>
int main()
{
    
    
	char str1[] = {
    
     "123456789" };
	//也可以char str2[] = "hello";
	//strcpy(str + 4, str2);//把字符串”holle“复制到str1 + 4开始的位置。
	strcpy(str1 + 4, "hello");
	puts(str1);
	return 0;
}

Ausgabeergebnis:

Hier wird auch \0 ausgegeben. Wenn \0 angetroffen wird, endet der Druck.

Simulationsimplementierung von strcpy:

Implementierungscode:

char *my_strcpy(char *dest, const char*src){
    
     
	char *ret = dest;//记录开始位置
	assert(dest != NULL);
	assert(src != NULL); 
	while((*dest++ = *src++)){
    
    //当src == '\0'时，赋值且停下。
		;
	}
	return ret;
}

4. 1 Verwendung der strncpy-Funktion

Begrenzen Sie das Kopieren der Zeichenfolgenlänge

1. Kopieren Sie num Zeichen aus der Quellzeichenfolge in den Zielbereich.
2. Wenn die Länge der Quellzeichenfolge kleiner als num ist, hängen Sie nach dem Kopieren der Quellzeichenfolge 0 an das Ende des Ziels an, bis zu num.

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

Der obige Code für Fall strcpy Fall 1: Wenn Siedie ersten n Zeichen von Zeichenfolge 2 nach str1 kopieren möchten, können Sie strncpy verwenden . Code 2:

#include<stdio.h>
#include<string.h>
int main()
{
    
    
	char str1[] = {
    
     "123456789" };
	char str2[] = "hello";
	//strcpy(str + 4, str2);
	strncpy(str1 + 4, str2, 4);
	puts(str1);
	return 0;
}

Ausgabeergebnis:

Hier kommt es vor, dass \0 nicht nach str1 kopiert wird. Natürlich gibt es noch einen anderen Fall: Was passiert, wenn die Länge von str2 überschritten wird?
Fall 3:

#include<stdio.h>
#include<string.h>
int main()
{
    
    
	char str1[] = {
    
     "123456789" };
	char str2[] = "hello";
	//strcpy(str + 4, str2);
	strncpy(str1, str2, 7);
	puts(str1);
	return 0;
}

Debug:

Alles darüber hinaus wird zu \0.

5. Verwendung und Simulationsimplementierung von strcat

Funktion: Verknüpfen Sie zwei Zeichenfolgen und geben Sie die Adresse des ersten Elements zurück

Beachten:

1. Die Quellzeichenfolge muss mit „\0“ enden.
   2. Es muss auch \0 in der Zielzeichenfolge vorhanden sein, sonst gibt es keine Möglichkeit zu wissen, wo mit dem Anhängen begonnen werden soll.
   3. Der Zielraum muss groß genug sein, um den Inhalt der Quellzeichenfolge aufzunehmen.
   4. Der Zielraum muss veränderbar sein.
   5. Beim Verknüpfen wird \0 von String 1 durch String 2 überschrieben.
   Link-String 2 kann eine String-Konstante sein.

Code 1:

#include<stdio.h>
#include<string.h>
int main()
{
    
    
	char str1[20] = {
    
     "hello," };
	strcat(str1, "how are you!");
	puts(str1);
	return 0;
}

Ausgabeergebnis:

5.1 Simulieren Sie die Strcat-Funktion:

char *my_strcat(char *dest, const char*src){
    
    
	char *ret = dest;//记录首元素地址
 	assert(dest != NULL);
 	assert(src != NULL);
 	while(*dest){
    
    //dest ！= \0,就++。
 		dest++;
 	}
 	while((*dest++ = *src++)){
    
    //把\0覆盖，把字符串2链接到字符串1
 		;
 	}
 return ret;
}

5.2 Verwendung der strncat-Funktion

Link zur Zeichenfolgenlänge begrenzen

Funktionsinhalt:

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

Fügen Sie die ersten num Zeichen der Zeichenfolge, auf die die Quelle zeigt, an das Ende der Zeichenfolge, auf die das Ziel zeigt, und hängen Sie dann ein \0-Zeichen an
Zeichen
Wenn die Länge der Zeichenfolge, auf die die Quelle zeigt, kleiner als num ist, wird nur der Inhalt bis zu
\0 in der Zeichenfolge an das Ende der Zeichenfolge angehängt, auf die das Ziel< zeigt /span>

Wenn die Länge der Zeichenfolge kleiner als num ist, wird nur der Inhalt bis \0 in der Zeichenfolge an das Ende der Zeichenfolge angehängt. Um das zu verstehen, schauen wir uns den Code an:

Fall 1:

Verketten Sie die ersten 4 Zeichen von Zeichenfolge 2 mit Zeichenfolge 1

#include<stdio.h>
#include<string.h>
int main()
{
    
    
	char arr1[20] = "helle\0xxxxxx";
	char arr2[] = "world";
	strncat(arr1, arr2, 4);
	return 0;
}

Debuggen Sie es:

Hier wird \0 im Voraus hinzugefügt, wodurch die Zeichenfolge 1 im Voraus endet.

6. Verwendung und Simulationsimplementierung von strcmp

Funktion: Vergleichen Sie die Größen zweier Zeichenfolgen
Größenvergleichsmethode: Vergleichen Sie den ASCLL-Wert jedes Zeichens von links nach rechts. Solange das vorherige Zeichen größer ist, ist die Zeichenfolge größer größer.

• Standardregelung:

Wenn die erste Zeichenfolge größer als die zweite Zeichenfolge ist, wird eine Zahl größer als 0 zurückgegeben
Wenn die erste Zeichenfolge gleich der zweiten Zeichenfolge ist, dann 0< /span>
Wenn die erste Zeichenfolge kleiner als die zweite Zeichenfolge ist, wird eine Zahl kleiner als 0 zurückgegeben

Fall 1:

#include<stdio.h>
#include<string.h>
int main()
{
    
    
	char str1[] = "zheng";
	char str2[] = "zhao";
	int ret = strcmp(str1, str2);
	if (ret > 0) {
    
    
		puts("大于");
	}
	else if (ret == 0){
    
    
		puts("等于");
	}
	else {
    
    
		puts("小于");
	}
	return 0;
}

Ausgabeergebnisanalyse:

6.1 Simulationsimplementierung der strcmp-Funktion:

int my_strcmp (const char * str1, const char * str2)
{
    
    
 	int ret = 0 ;
 	assert(src != NULL);
 	assert(dest != NULL);
 	while(*str1 == *str2){
    
    //比较sacll的值
 		if(*str1 == '\0')//如果*str1 和 str2等于\0,字符串相等。
 			return 0;
 		str1++;
 		str2++;
 }
 return *str1-*str2;//如果有字符不相等的比较ASCLL的值，返回。
}

Dies ist die Simulationsimplementierung der strcmp-Funktion.

7.Verwendung der strncmp-Funktion

Beschränken Sie den Vergleich der Zeichenfolgenlänge

Funktionsinhalt:

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

** Vergleichen Sie die ersten num-Zeichen von str1 und str2. Wenn sie gleich sind, fahren Sie mit dem Vergleich fort, bis zu num-Zeichen. Wenn Unterschiede im Voraus gefunden werden, beenden Sie früh. ** Largest Die Zeichenfolge ist größer als der andere. Wenn num Zeichen gleich sind, wird 0 zurückgegeben, wenn sie gleich sind.
Fall 1:

int main()
{
    
    
	char str1[] = "zheng";
	char str2[] = "zhao";
	int ret = strncmp(str1, str2, 3);
	if (ret > 0) {
    
    
		puts("大于");
	}
	else if (ret == 0){
    
    
		puts("等于");
	}
	else {
    
    
		puts("小于");
	}
	return 0;
}

Was passiert, wenn die Grenzlänge auf 2 geändert wird?
Ausgabeergebnis:

Gleich, da die ersten beiden Zeichen gleich sind.

8. Nutzung und Simulationsimplementierung von strstr

Funktion: Finden Sie String 2 aus String 1

Funktionsinhalt:

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

Gibt die Adresse zurück

Die Funktion gibt die Position des ersten Vorkommens von String str2 in String str1 zurück.
Die Vergleichsübereinstimmung der Zeichenfolge enthält nicht das Zeichen \0 und verwendet \0 als Endmarkierung.

Fall 1:

#include <stdio.h>
#include <string.h>
int main ()
{
    
    
 	char str[] ="This is a simple string";
 	char * pch;
 	pch = strstr (str,"simple");
 	//strncpy (pch,"sample",6);
 	printf("%s\n", pch);
 return 0;
}

Ausgabeergebnis:

Was bedeutet das? Beachten Sie, dass die Funktion strstr die Adresse derselben Zeichenfolge in str aufzeichnet. Sie können auch den Kommentarinhalt des Codes entfernen und der Link ist vollständig.
Ausgabeergebnis nach dem Entfernen von Kommentaren:

8.1 Implementierung der Strstr-Simulation:

char * my_strstr (const char * str1, const char * str2)
{
    
    
 	char *cp = (char *) str1;//记录首元素地址
 	char *s1, *s2;
 	if ( !*str2 )//空指针取反为真
 		return((char *)str1);
 	while (*cp）{
    
    
 		s1 = cp;
 		s2 = (char *) str2;
 		while ( *s1 && *s2 && !(*s1-*s2) )//s1,s2不等于\0,且*s1和*s2相同
 			s1++, s2++;
 		if (!*s2)//s2等于\0时
 			return(cp);//返回找到字符串1找到相同字符串2的起始地址。
 		cp++;//如果找不到cp++
 	}
 	return(NULL);
}
int main()
{
    
    
	char arr1[] = "abbbcdf";
	char arr2[] = "bbc";
	char* ret = my_strstr(arr1, arr2);
	if (ret != NULL) {
    
    
		printf("%s\n", ret);
	}
	else {
    
    
		printf("找不到\n");
	}
	return 0;
}

Die Analyse ist wie in der Abbildung dargestellt:

Wichtiger Punkt: Sie können char*pr verwenden, um die Rücksprungadresse zu erhalten. Wenn sie nicht gefunden wird, wird ein Nullzeiger zurückgegeben Daher ist es am besten, nach dem Urteil auszudrucken.

9. Verwendung der Strtok-Funktion

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

• Der sep-Parameter zeigt auf eine Zeichenfolge und definiert den Satz von Zeichen, die als Trennzeichen verwendet werden.
• Der erste Parameter gibt eine Zeichenfolge an, die 0 oder mehr durch eins oder mehrere getrennte Token enthält Trennzeichen in der sep-Zeichenfolge.
• Die Funktion strtok findet das nächste Tag in str, beendet es mit \0 und gibt einen Zeiger auf dieses Tag zurück. (Hinweis:
Die Funktion strtok ändert die manipulierte Zeichenfolge, sodass die Zeichenfolgenaufteilung mit der Funktion strtok im Allgemeinen eine temporäre Kopie ist und geändert werden kann.)Codeanzeige: • Wenn der String keine weiteren Token enthält, wird ein NULL-Zeiger zurückgegeben. • Der erste Parameter der strtok-Funktion ist NULL und die Funktion sucht nach der nächsten Markierung, beginnend an der gespeicherten Position in derselben Zeichenfolge.
• Der erste Parameter der Strtok-Funktion ist nicht NULL, die Funktion findet die erste Markierung in str und die Strtok-Funktion speichert ihre Position in der Zeichenfolge.

#include <stdio.h>
#include <string.h>
int main()
{
    
    
	char arr[] = "192.168.6.111";
	char* sep = ".";
	char* str = NULL;
	for (str = strtok(arr, sep); str != NULL; str = strtok(NULL, sep)){
    
    
		printf("%s\n", str);
	}
	return 0;
}

analysieren:

Die erste Suche: strtok kann sep später nicht finden. Das heißt, wenn das in sep gespeicherte Sonderzeichen nicht gefunden werden kann, wird NULL zurückgegeben. Wenn es gefunden wird, wird die Adresse des ersten Zeichens zurückgegeben Schneiden Sie die Zeichenfolge aus und fügen Sie das Zeichen 1 ein. Es wird durch \0 ersetzt, genau wie sep, um Sonderzeichen zu speichern.
Die zweite NULL-Analyse: Wenn die Eingabe sehr chaotisch ist, weiß ich nicht, wo die Adresse ist Das erste Zeichen, das zum zweiten Mal gefunden wurde, ist, aber die Funktion merkt sich. Komm schon, übergebe einfach die NULL-Funktion zum zweiten Mal, um die Startposition zum zweiten Mal zu finden. Wenn Sie also zum zweiten Mal Parameter übergeben, müssen Sie nur NULL und sep (die Sonderzeichen, nach denen gesucht werden soll) übergeben.

Das heißt: Die Funktion strtok ist etwas Besonderes. Wenn sie \0 zum ersten Mal findet, zeichnet sie die nächste Startposition auf. Es ist nicht erforderlich, sie zu übergeben. Die Funktion kennt sie, solange sie NULL ist Wird übergeben, kann die Funktion zweimal aufgerufen werden. Die Funktion selbst erfasst die Startposition und sucht nach sep (dem zu suchenden Sonderzeichen) zum Ausschneiden.

Okay, das war's für das heutige Teilen. Jetzt, da Sie es gesehen haben, geben Sie ihm ein „Gefällt mir“, vielen Dank.