Zeichenfolgenfunktionen string.h

Char * Stpcpy (Char * _Dest, const Char * Src); <br/> Wchar * _wcspcpy (WCHAR * Dest, const WCHAR * Src);

Kopieren Sie eine Zeichenfolge in andere.

_stpcpy kopiert das Zeichenfolge Src, Dest, stoppen nach Erreichen der null-Terminierung Charakter Src.

Stpcpy gibt einen Zeiger auf das Zeichen null-Terminierung für Dest.

Wenn Sie UNICODE definieren, _wcspcpy gibt einen Zeiger auf Wchar_t Zeichenfolge Null-Zeichen Dest.

 # include <string.h> # include <stdio.h> Int Main (Void) {Char String [10]};
   Char * s = "Abcdefghi";

   Stpcpy (String, s);
   ("Printf ("%s\n", String);
   return 0;
}

<br/> Char * Strcat (Char * _Dest, const Char * Src); <br/> Wchar_t * Wcscat (Wchar_t * Dest, const Wchar_t * Src); <br/> unsigned Char * _mbscat (unsigned Char * _Dest, const unsigned Char * Src);

Fügt eine Zeichenfolge in andere.

Strcat wird eine Kopie der Src am Ende des Dest. Die Länge der die resultierende Zeichenfolge ist Strlen (Dest) + Strlen (Src).

Strcat gibt einen Zeiger auf die Zeichenfolgen verkettet.

 # include <string.h> # include <stdio.h> Int Main (Void) {Char Ziel [25]};
   Char * leer = "", * c = "C++", * Borland = "Borland";

   Strcpy (Ziel, Borland);
   Strcat (Ziel, leere);
   Strcat (Ziel, C);

   ("Printf ("%s\n", Ziel);
   return 0;
}

Char * Strchr (const Char * s, Int c); / * C nur * / <br/> const Char * Strchr (const Char * s, Int c); / / C ++ nur <br/> Char * Strchr (Char * s, Int c); / / C ++ nur <br/> Wchar_t * Wcschr (const Wchar_t * s, Int c); <br/> unsigned Char * _mbschr (const unsigned Char * s, unsigned Int c); <br/> <br/> analysiert eine Zeichenfolge in Suchen des ersten Vorkommens eines Zeichens bestimmt. <br/> <br/> Strchr Analysen eine Zeichenfolge in die Richtung des Fortschritts, der ein bestimmtes Zeichen. Strchr sucht das erste Vorkommen des Zeichens c in der Zeichenkette s. Das null-Abschlusszeichen gilt als Teil der Kette. <br/> <br/> zum Beispiel: < Br / >< Br / > Strchr (RTS, 0) <br/> <br/> gibt einen Zeiger auf die Null-Zeichen für die Beendigung der Transaktion Kette verdächtige. <br/> <br/> <em> Strchr gibt einen Zeiger zum ersten Vorkommen des Zeichens c in s, wenn c nicht in s tritt, Strchr gibt zurück ein Null.

 # include <string.h> # include <stdio.h> Int Main (Void) {Char String [15]};
   Char * Ptr, C = 'R';

   strcpy(String,_"This_is_a_string");
   PTR = Strchr (String, C);
   Wenn printf("The_character_%c_is_at_position:_%d\n",_c,_ptr-string) (Ptr);
   andere printf("The_character_was_not_found\n");
   return 0;
}

Int Strcmp (const Char * s1, const Char * s2); <br/> Int Wcscmp (const Wchar_t * s1, const Wchar_t * s2); <br/> Int _mbscmp (const unsigned Char * s1, const unsigned Char * s2);

Vergleicht eine Zeichenfolge mit anderen.

Strcmp vergleicht den Inhalt von s1 mit s2, ab dem ersten Zeichen der jede Zeichenfolge und wird fortgesetzt, mit folgenden Zeichen bis die entsprechenden Zeichen unterscheiden oder an das Ende der Zeichenfolge.

Rückgabewert

wenn s1...	zurückgeben Wert ist...
weniger als s2	< 0
das gleiche wie s2	== 0
größer als s2	> 0

 # include <string.h> # include <stdio.h> Int Main (Void) {Char * buf1 = "aaa", * buf2 = "Bbb", * buf3 = "ccc";}
	Int Ptr;

	PTR = Strcmp (buf1, buf2);
	Wenn (Ptr > 0) printf("buffer_2_is_greater_than_buffer_1\n");
	andere printf("buffer_2_is_less_than_buffer_1\n");

   PTR = Strcmp (buf2, buf3);
   Wenn (Ptr > 0) printf("buffer_2_is_greater_than_buffer_3\n");
   andere printf("buffer_2_is_less_than_buffer_3\n");

   return 0;
}

Int Strcmpi (const Char * s1, const Char * s2); <br/> Int _wcscmpi (const Wchar_t * s1, const Wchar_t * s2);

Vergleicht eine Zeichenfolge in einen anderen, ohne Unterscheidung zwischen Groß- und Kleinbuchstaben.

Strcmpi macht einen Vergleich des Inhalts von s1 mit s2, ohne Unterscheidung zwischen Groß- und Kleinbuchstaben (z. B. Stricmp - als ein Makro implementiert).

Rückgabewert

wenn s1...	Strcmpi gibt einen Wert zurück, dass ist...
weniger als s2	< 0
das gleiche wie s2	== 0
größer als s2	> 0

 / * Strncmpi Beispiel * / # include <string.h> # include <stdio.h> Int Main (Void) {Char * buf1 = "BBB", * buf2 = "Bbb";}
   Int Ptr;

   PTR = Strcmpi (buf1, buf2);

   Wenn (Ptr > 0) printf("buffer_2_is_greater_than_buffer_1\n");

   Wenn (Ptr < 0) printf("buffer_2_is_less_than_buffer_1\n");

   Wenn (Ptr == 0) printf("buffer_2_equals_buffer_1\n");

   return 0;
}

Int Strcmp (const Char * s1, const Char * s2); <br/> Int Wcscmp (const Wchar_t * s1, const Wchar_t * s2); <br/> Int _mbscmp (const unsigned Char * s1, const unsigned Char * s2);

Vergleicht eine Zeichenfolge mit anderen.

Strcmp vergleicht den Inhalt von s1 mit s2, ab dem ersten Zeichen der jede Zeichenfolge und wird fortgesetzt, mit folgenden Zeichen bis die entsprechenden Zeichen unterscheiden oder an das Ende der Zeichenfolge.

Rückgabewert

wenn s1...	zurückgeben Wert ist...
weniger als s2	< 0
das gleiche wie s2	== 0
größer als s2	> 0

 # include <string.h> # include <stdio.h> Int Main (Void) {Char * buf1 = "aaa", * buf2 = "Bbb", * buf3 = "ccc";}
	Int Ptr;

	PTR = Strcmp (buf1, buf2);
	Wenn (Ptr > 0) printf("buffer_2_is_greater_than_buffer_1\n");
	andere printf("buffer_2_is_less_than_buffer_1\n");

   PTR = Strcmp (buf2, buf3);
   Wenn (Ptr > 0) printf("buffer_2_is_greater_than_buffer_3\n");
   andere printf("buffer_2_is_less_than_buffer_3\n");

   return 0;
}

Char * Strcpy (Char * Dest, const Char * Src); <br/> Wchar_t * Wcscpy (Wchar_t * Dest, const Wchar_t * Src); <br/> unsigned Char * _mbscpy (unsigned Char * _Dest, const unsigned Char * Src); <br/> <br/> Kopieren Sie eine Zeichenfolge in andere. <br/> <br/> Kopien string Src, Dest, stoppen nach dem Umzug der Null-Zeichen abgeschlossen. <br/> <br/> Strcpy gibt Dest.

 # include <stdio.h> # include <string.h> Int Main (Void) {Char String [10]};
   Char * s = "Abcdefghi";

   Strcpy (String, s);
   ("Printf ("%s\n", String);
   return 0;
}

Size_t Strlen (const Char * s); <br/> Size_t Wcslen (const Wchar_t * s); <br/> Size_t _mbslen (const unsigned Char * s); <br/> Size_t _mbstrlen (const Char * s) <br/> <br/> berechnen Sie die Länge der Zeichenfolge. <br/> <br/> Strlen zu berechnen Sie die Länge von s. <br/> <br/> Strlen gibt die Anzahl der Zeichen s, nicht mitgerechnet das Zeichen null-Terminierung.

 # include <stdio.h> # include <string.h> Int Main (Void) {Char * String = "Borland International";}

   ("Printf ("%d\n", Strlen (String));
   return 0;
}

Char * Strlwr (Char * s); <br/> Wchar_t * _wcslwr (Wchar_t * s); <br/> unsigned Char * _mbslwr (unsigned Char * s); <br/> <br/> wandelt die Buchstaben einer Zeichenfolge in Kleinbuchstaben. <br/> <br/> Strlwr konvertiert die Buchstaben auf den String s in Kleinbuchstaben mit lokalen Kategorie LC_CTYPE aktiviert. Für regionale Einstellungen, C führt die Konvertierung ist von Buchstaben (A bis Z) Kleinbuchstaben Großbuchstaben (a bis Z). <br/> <br/> Strlwr gibt zurück einen Zeiger auf die Zeichenfolge s.

 # include <stdio.h> # include <string.h> Int Main (Void) {Char * String = "Borland International";}

   printf("string_prior_to_strlwr:_%s\n",_String);
   StrLwr (String);
   printf("string_after_strlwr:_%s\n",_String);
   return 0;
}

Char * Strncat (Char * _Dest, const Char * Src, Size_t Maxlen); <br/> Wchar_t * Wcsncat (Wchar_t * Dest, const Wchar_t * Src, Size_t Maxlen); <br/> unsigned Char * _mbsncat (unsigned Char * Dest, const unsigned Char * Src, Size_t Maxlen); <br/> unsigned Char * _mbsnbcat (unsigned Char * __dest, const unsigned Char * __src, _SIZE_T __maxlen); <br/> <br/> hinzufügen einen Teil einer Zeichenfolge auf andere. <br/> <br/> Strncat angegebenen Zeichen Maxlen src am Ende des Dest kopiert, und fügt dann ein Null-Zeichen. Die maximale Länge für die resultierende Zeichenfolge ist Strlen (Dest) + Maxlen. <br/> <br/> für _mbsnbcat, wenn das zweite Byte des Charakters der 2 Byte 0 ist das erste Byte der dieses Zeichen wird als ungültig. <br/> <br/> diese vier Funktionen Verhalten identisch und unterscheiden sich nur in Bezug auf den Typ der Argumente und Typen zurückgegeben. <br/> <br/> Strncat gibt Dest.

 # include <string.h> # include <stdio.h> Int Main (Void) {Char Ziel [25]};
   Char * Quelle = "Staaten";

   Strcpy (Ziel, "United");
   strncat(Destination,_source,_7);
   ("Printf ("%s\n", Ziel);
   return 0;
}

Int Strncmp (const Char * s1, const Char * s2, Size_t Maxlen); <br/> Int Wcsncmp (const Wchar_t * s1, const Wchar_t * s2, Size_t Maxlen); <br/> Int _mbsncmp (const Char * s1 ohne Vorzeichen, ohne Vorzeichen const Char * s2, Size_t Maxlen); <br/> # define _mbccmp (__s1, __s2) _mbsncmp ((__s1), (_ s2), 1) <br/> <br/> einen Teil einer Zeichenfolge auf einen Teil der anderen vergleicht. <br/> <br/> Strncmp macht den gleichen Vergleich zu Strcmp, aber es überschreitet die Anzahl der Zeichen in Maxlen. Es beginnt mit dem ersten Zeichen der jede Zeichenfolge und mit folgenden Zeichen wird fortgesetzt, bis ein Unterschied ist oder war untersuchten Maxlen Zeichen. <br/> <br/> Strncmp gibt einen ganzzahligen Wert basierend auf dem Ergebnis des Vergleichs von s1 (oder ein Teil davon) s2 (oder ein Teil davon):

< 0	wenn s1 kleiner als s2
== 0	wenn s1 s2 entspricht
> 0	wenn s1 s2 größer ist

 # include <string.h> # include <stdio.h> Int Main (Void) {Char * buf1 = "Aaabbb", * buf2 = "Bbbccc", * buf3 = "ccc";}
   Int Ptr;

   PTR = strncmp(buf2,buf1,3);
   Wenn (Ptr > 0) printf("buffer_2_is_greater_than_buffer_1\n");
   andere printf("buffer_2_is_less_than_buffer_1\n");

   PTR = strncmp(buf2,buf3,3);
   Wenn (Ptr > 0) printf("buffer_2_is_greater_than_buffer_3\n");
   andere printf("buffer_2_is_less_than_buffer_3\n");

   (0) zurück;

}

Int Strncmpi (Const_char_ * _s1 _const_char_ * _s2, _size_t_n); <br/> Int Wcsncmpi (const Wchar_t * s1, const Wchar_t * s2, Size_t n); <br/> <br/> vergleicht einen Teil einer Zeichenfolge zu einem Teil eines anderen, ohne Unterscheidung zwischen Groß- und Kleinbuchstaben. <br/> <br/> Strncmpi vergleicht s1, s2für eine maximale Länge von n Byte beginnend mit dem ersten Zeichen der einzelnen Zeichenfolge, und fahren Sie mit den folgenden Zeichen bis die entsprechenden Zeichen abweichen oder bis zu n Zeichen diskutieren. Der Vergleich wird zwischen Groß- und Kleinschreibung unterschieden. (Strncmpi ist das gleiche wie Strnicmp - als ein Makro implementiert). Gibt einen Wert zurück (< 0, 0 oder > 0) auf das Ergebnis vergleichen s1 (oder einen Teil davon) s2 (oder Teile davon). <br/> <br/> wenn s1 is... Strncmpi gibt einen Wert, dass is zurück...<br/> <br/>

weniger als s2	< 0
== 0	dasselbe wie s2
größer als s2	> 0

 # include <string.h> # include <stdio.h> Int Main (Void) {Char * buf1 = "BBBccc", * buf2 = "Bbbccc";}
   Int Ptr;

   PTR = strncmpi(buf2,buf1,3);

   Wenn (Ptr > 0) printf("buffer_2_is_greater_than_buffer_1\n");

   Wenn (Ptr < 0) printf("buffer_2_is_less_than_buffer_1\n");

   Wenn (Ptr == 0) printf("buffer_2_equals_buffer_1\n");

   return 0;
}

Char * Strncpy (Char_ * _dest, _const_char_ * _src, _size_t_maxlen); <br/> Wchar_t * Wcsncpy (Wchar_t * Dest, const Wchar_t * Src, Size_t Maxlen); <br/> unsigned Char * _mbsncpy (unsigned Char * _Dest, const unsigned Char * Src, Size_t Maxlen); <br/> <br/> eine angegebene Anzahl von Bytes einer Zeichenfolge in eine andere kopieren, Abschneiden oder gefüllte als es möglicherweise notwendig. <br/> <br/> Strncpy kopiert bis zu Src Dest Maxlen ZeichenDest mit der Einfügung der Null Abschneiden. Die Kette des Schicksals, Dest, kann werden in nicht abgeschlossen Null ist die Länge des Orig Maxlen oder mehr. <br/> <br/> Strncpy gibt Dest.

 # include # enthalten Int Main (Void) {Char String [10]};
   Char * s = "Abcdefghi";

   strncpy(String,_Str1,_3);
   Zeichenfolge [3] = '\0';
   ("Printf ("%s\n", String);
   return 0;
}

Int Strnicmp (const Char * s1, const Char * s2, Size_t Maxlen); <br/> Int _wcsnicmp (const Wchar_t * s1, const Wchar_t * s2, Size_t Maxlen); <br/> Int ausgelöst (const Char * s1 ohne Vorzeichen, ohne Vorzeichen const Char * s2, Size_t Maxlen); <br/> <br/> vergleicht einen Teil einer Zeichenfolge zu einem Teil eines anderen, ohne Unterscheidung zwischen Groß- und Kleinbuchstaben. <br/> <br/> Strnicmp vergleicht s1, s2, für eine maximale Länge von Maxlen Byte beginnend mit dem ersten Zeichen jedes Zeichenfolge, und fahren Sie mit den folgenden Zeichen bis unterscheiden sich die entsprechenden Zeichen oder das Ende der Zeichenfolge erreicht ist. Der Vergleich unterscheidet nicht zwischen Groß- und Kleinbuchstaben. <br/> <br/> gibt einen Wert zurück (< 0, 0 oder > 0) je nach Ergebnis des Vergleichs von s1 (oder Teile davon) s2 (oder Teile davon). <br/> <br/>

wenn s1...	StrniCmp gibt einen Wert zurück, dass ist...
weniger als s2	< 0
das gleiche wie s2	== 0
größer als s2	> 0

 # include <string.h> # include <stdio.h> Int Main (Void) {Char * buf1 = "BBBccc", * buf2 = "Bbbccc";}
   Int Ptr;

   PTR = strnicmp(buf2,_buf1,_3);

   Wenn (Ptr > 0) printf("buffer_2_is_greater_than_buffer_1\n");

   Wenn (Ptr < 0) printf("buffer_2_is_less_than_buffer_1\n");

   Wenn (Ptr == 0) printf("buffer_2_equals_buffer_1\n");

   return 0;
}

Char * Strnset (Char * s, Int ch, Size_t n); <br/> Wchar_t * _wcsnset (Wchar_t * s, Wchar_t ch, Size_t n); <br/> unsigned Char * _mbsnset (unsigned Char * s, Int ohne Vorzeichen ch, Size_t n); <br/> <br/> stellt eine bestimmte n Anzahl von Zeichen ch einer Kette. <br/> <br/> Strnset kopieren Sie die Zeichen ch in die ersten n Bytes von der Zeichenfolge s. <br/> <br/> Wenn n > Strlen (s)Ersetzen Sie dann, Strlen (s) b. Stationen als n Zeichen, oder ein Null-Zeichen gefunden. <br/> <br/> jede dieser Funktionen zurück, s.

 # include <stdio.h> # include <string.h> Int Main (Void) {Char * String = "Abcdefghijklmnopqrstuvwxyz";}
   Char Brief = 'X';

   printf("string_before_strnset:_%s\n",_String);
   strnset(String,_letter,_13);
   printf("string_after_strnset:_%s\n",_String);

   return 0;
}

Char * Strpbrk (Const_char_ * _s1 _const_char_ * _s2); / * C nur * / <br/> const Char * Strpbrk (const Char * s1, const Char * s2); / / C ++ nur <br/> Char * Strpbrk (Char * s1, const Char * s2); / / C ++ nur <br/> Wchar_t * Wcspbrk (const Wchar_t * s1, const Wchar_t * s2); <br/> unsigned Char * _mbspbrk (const unsigned Char * s1, const unsigned Char * S2); <br/> <br/> analysiert eine Zeichenfolge auf der Suche nach der erste Auftritt von jedem CaráZeichen eines bestimmten Satz. <br/> <br/> Strpbrk analysiert eine Zeichenfolge s1 nach dem ersten Vorkommen eines beliebigen Zeichens in s2. <br/> <br/> <em> Strpbrk gibt einen Zeiger auf das erste Vorkommen eines der Zeichen in s2. Wenn s1 s2 nicht kein Zufall ist, Strpbrk gibt ein Null.

 # include # enthalten Int Main (Void) {Char * string1 = "Abcdefghijklmnopqrstuvwxyz";}
   Char * string2 = "Onm";
   Char * Ptr;

   PTR = Strpbrk (string1, string2);

   Wenn printf("strpbrk_found_first_character:_%c\n",_*ptr) (Ptr);
   andere printf("strpbrk_didn't_find_character_in_set\n");

   return 0;
}

Char * Strrchr (const Char * s, Int c); / * C nur * / <br/> const Char * Strrchr (const Char * s, Int c); / / C ++ nur <br/> Char * Strrchr (Char * s, Int c); / / C ++ nur <br/> Wchar_t * Wcsrchr (const Wchar_t * s, Wchar_t c); <br/> unsigned Char * _mbsrchr (const unsigned Char * s, unsigned Int c); <br/> <br/> analysiert eine Zeichenfolge auf der Suche nach den letzten Vorkommens eines Zeichens bestimmt. <br/> <br/>Strrchr analysiert eine Zeichenfolge in die entgegengesetzte Richtung, auf der Suche nach ein bestimmtes Zeichen. Strrchr findet das letzte Vorkommen des Zeichens c in der Zeichenkette s. Das null-Abschlusszeichen wird als Teil des Netzwerks. <br/> <br/> Strrchr gibt einen Zeiger auf das letzte Vorkommen des Zeichens c, wenn c nicht in s tritt zurück, Strrchr gibt ein Null.

 # include <string.h> # include <stdio.h> Int Main (Void) {Char String [15]};
   Char * Ptr, C = 'R';

   strcpy(String,_"This_is_a_string");
   PTR = Strrchr (String, C);
   Wenn printf("The_character_%c_is_at_position:_%d\n",_c,_ptr-string) (Ptr);
   andere printf("The_character_was_not_found\n");
   return 0;
}

Char * Strrev (Char * s); <br/> Wchar_t * _wcsrev (Wchar_t * s); <br/> unsigned Char * _mbsrev (unsigned Char * s); <br/> <br/> investiert eine Kette. <br/> <br/> Strrev werden alle Zeichen in einer Zeichenfolge zum Umkehren der Reihenfolge, mit Ausnahme der Null-Zeichen-Beendigung. (Z. B. könnten string\0 in ändern gnirts\0). <br/> <br/> Strrev gibt einen Zeiger auf die Zeichenfolge umgekehrt.

 # include <string.h> # include <stdio.h> Int Main (Void) {Char * vorwärts = "String";}

   printf("Before_strrev():_%s\n",_forward);
   Strrev (vorwärts);
   printf("After_strrev():_%s\n",_forward);
   return 0;
}

Char * Strset (Char * s, Int ch); <br/> Wchar_t * _wcsset (Wchar_t * s, Wchar_t ch); <br/> unsigned Char * _mbsset (unsigned Char * s, Int ohne Vorzeichen ch); <br/> <br/> setzt alle Zeichen in einer Zeichenfolge in ein Zeichen bestimmt. <br/> <br/> Strset legt fest, dass alle Zeichen in der Zeichenkette s Charakter ch. Bleibt, wenn das null-Terminierungszeichen befindet. <br/> <br/> Strset gibt s.

 # include <stdio.h> # include <string.h> Int Main (Void) {char-Zeichenfolge [10] = "123456789";}
   Char Symbol = 'c';

   printf("Before_strset():_%s\n",_String);
   Strset (String, Symbol);
   printf("After_strset():_%s\n",_String);
   return 0;
}

Char * strpos (const Char * s1, const Char * s2); / * C nur * / <br/> const Char * strpos (const Char * s1, const Char * s2); / / C ++ nur <br/> Char * strpos (const Char * s1, const Char * s2); / / C ++ nur <br/> Wchar_t * Wcsstr (const Wchar_t * s1, const Wchar_t * s2); <br/> unsigned Char * _mbsstr (const unsigned Char * s1, const unsigned Char * S2);

Analysiert eine Zeichenfolge in das Vorkommen einer Teilzeichenfolge Suche gegeben.

strpos erforscht, s1 bis zum ersten Vorkommen der Teilzeichenfolge s2.

strpos gibt einen Zeiger auf das Element der s1, s2, wo beginnt (s1 s2 Punkte). Wenn s2 nicht in s1 tritt, strpos gibt zurück ein Null.

 # include <stdio.h> # include <string.h> Int Main (Void) {Char * s = "Borland International", * t = "Nation", * Ptr;}

   PTR = strpos (s, t);
   printf("The_substring_is:_%s\n",_Ptr);
   return 0;
}

<br/> Char * Strupr (Char * s); <br/> Wchar_t * _wcsupr (Wchar_t * s); <br/> unsigned Char * _mbsupr (unsigned Char * s);

Konvertiert eine Zeichenfolge in Großbuchstaben Kleinbuchstaben.

Strupr wandelt Kleinbuchstaben in der Zeichenkette s großgeschrieben laut LC_CTYPE Gebietsschema Kategorie vorhanden ist. Konvertierung ist der Kleinbuchstaben (a - Z) Großbuchstaben (A bis Z). Andere Zeichen unverändert.

StrUpr gibt s.

 # include <stdio.h> # include <string.h> Int Main (Void) {Char * String = "Abcdefghijklmnopqrstuvwxyz", * Ptr;}

   / * Konvertiert Zeichenfolge in Großbuchstaben Zeichen * / Ptr = Strupr (Zeichenkette);
   ("Printf ("%s\n", Ptr);
   return 0;
}