Fonctions de chaîne string.h
char * stpcpy (char * dest, const char * src); <br/> wchar * _wcspcpy (WCHAR * dest, const WCHAR * src);
Copier une chaîne vers les autres.
_stpcpy copie la src de chaîne à dest, s'arrêtant après avoir atteint la src de caractère nulle résiliation.
stpcpy retourne un pointeur vers le caractère null résiliation dest.
Si vous définissez UNICODE, _wcspcpy renvoie un pointeur vers l'achèvement de la wchar_t chaîne caractère null dest.
# include <string.h> # include <stdio.h> int main (void) {string char [10]} ;
char * s = « abcdefghi » ;
stpcpy (string, s) ;
("printf ("%s\n", string) ;
retour 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);
Ajoute une chaîne à l'autre.
strcat
ajoute une copie de la src à la fin du dest. La longueur de la chaîne résultante est strlen (dest) + strlen (src).
strcat retourne un pointeur vers les chaînes concaténées.
# include <string.h> # include <stdio.h> int main (void) {destination char [25]} ;
char * blanc = "", * c = « C++ », * Borland = « Borland » ;
strcpy (destination, Borland) ;
strcat (destination, vide) ;
strcat (destination, c) ;
("printf (« %s\n », de destination) ;
retour 0 ;
} char * strchr (const char * s, int c); / * C seulement * / <br/> const char * strchr (const char * s, int c); / / C ++ seulement <br/> char * strchr (char * s, int c); / / C ++ seulement <br/> wchar_t * wcschr (const wchar_t * s, int c); <br/> unsigned char * _mbschr (const unsigned char * s, c unsigned int); <br/> <br/> analyse une chaîne à la recherche de la première occurrence d'un caractère déterminé. <br/> <br/> analyses strchr une chaîne en direction de progrès, à la recherche d'un caractère particulier. strchr trouve la première occurence de la c caractère dans une chaîne s. Le terminateur null est considéré comme faisant partie de la chaîne. <br/> <br/> par exemple: < br / >< br / > strchr (RTS, 0) <br/> <br/> retourne un pointeur vers le caractère nul pour l'interruption de la chaîne des transactions suspectes. <br/> <br/> <em> strchr retourne un pointeur à la première occurrence de la c caractère en s, si c ne fonctionne pas en s, strchr renvoie une valeur null.
# include <string.h> # include <stdio.h> int main (void) {string char [15]} ;
char * ptr, c = « r » ;
strcpy(String,_"This_is_a_string") ;
PTR = strchr (string, c) ;
Si printf("The_character_%c_is_at_position:_%d\n",_c,_ptr-string) (ptr) ;
autre printf("The_character_was_not_found\n") ;
retour 0 ;
}
int strcmp (const char * s1, const char * s2); <br/> wcscmp int (const wchar_t * s1, const wchar_t * s2); <br/> _mbscmp int (const unsigned char * s1, const unsigned char * s2);
Compare une chaîne avec d'autres.
strcmp compare le contenu de s1 avec s2, à partir du premier caractère de chaque chaîne et continue avec les caractères suivants jusqu'à ce que les caractères correspondants diffèrent ou pour atteindre la fin de la chaîne.
Valeur de retour.
| si s1... | Retour valeur is... |
| moins de s2 | < 0 |
| les mêmes S2 | == 0 |
| plus de s2 | > 0 |
# include <string.h> # include <stdio.h> int main (void) {char * buf1 = « aaa », * buf2 = « bbb », * buf3 = « ccc »;}
int ptr ;
PTR = strcmp (buf1, buf2) ;
Si printf("buffer_2_is_greater_than_buffer_1\n") (ptr > 0) ;
autre printf("buffer_2_is_less_than_buffer_1\n") ;
PTR = strcmp (buf2, buf3) ;
Si printf("buffer_2_is_greater_than_buffer_3\n") (ptr > 0) ;
autre printf("buffer_2_is_less_than_buffer_3\n") ;
retour 0 ;
} int strcmpi (const char * s1, const char * s2); <br/> _wcscmpi int (const wchar_t * s1, const wchar_t * s2);
Compare une chaîne à l'autre, sans distinction entre majuscules et minuscules.
strcmpi fait une comparaison du contenu du s1 avec s2, sans distinction entre les majuscules et les minuscules (comme stricmp - implémentée comme une macro).
Valeur de retour.
| si s1... | strcmpi retourne une valeur que diriez.. |
| moins de s2 | < 0 |
| les mêmes S2 | == 0 |
| plus de s2 | > 0 |
/ * strncmpi exemple * / # include <string.h> # include <stdio.h> int main (void) {char * buf1 = « BBB », * buf2 = « bbb »;}
int ptr ;
PTR = strcmpi (buf1, buf2) ;
Si printf("buffer_2_is_greater_than_buffer_1\n") (ptr > 0) ;
Si printf("buffer_2_is_less_than_buffer_1\n") (ptr < 0) ;
Si (ptr == 0) printf("buffer_2_equals_buffer_1\n") ;
retour 0 ;
} int strcmp (const char * s1, const char * s2); <br/> wcscmp int (const wchar_t * s1, const wchar_t * s2); <br/> _mbscmp int (const unsigned char * s1, const unsigned char * s2);
Compare une chaîne avec d'autres.
strcmp compare le contenu de s1 avec s2, à partir du premier caractère de chaque chaîne et continue avec les caractères suivants jusqu'à ce que les caractères correspondants diffèrent ou pour atteindre la fin de la chaîne.
Valeur de retour.
| si s1... | Retour valeur is... |
| moins de s2 | < 0 |
| les mêmes S2 | == 0 |
| plus de s2 | > 0 |
# include <string.h> # include <stdio.h> int main (void) {char * buf1 = « aaa », * buf2 = « bbb », * buf3 = « ccc »;}
int ptr ;
PTR = strcmp (buf1, buf2) ;
Si printf("buffer_2_is_greater_than_buffer_1\n") (ptr > 0) ;
autre printf("buffer_2_is_less_than_buffer_1\n") ;
PTR = strcmp (buf2, buf3) ;
Si printf("buffer_2_is_greater_than_buffer_3\n") (ptr > 0) ;
autre printf("buffer_2_is_less_than_buffer_3\n") ;
retour 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/> copier une chaîne vers les autres. <br/> <br/> copies string src à dest, s'arrêtant après avoir déménagé le caractère nul achèvement. <br/> <br/> strcpy renvoie dest.
# include <stdio.h> # include <string.h> int main (void) {string char [10]} ;
char * s = « abcdefghi » ;
strcpy (string, s) ;
("printf ("%s\n", string) ;
retour 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/> calculer la longueur d'une chaîne. <br/> <br/> strlen pour calculer la longueur de s. <br/> <br/> strlen renvoie le nombre de caractères s, sans compter le caractère nulle résiliation.
# include <stdio.h> # include <string.h> int main (void) {char * string = « Borland International »;}
("printf ("%d\n", strlen (string)) ;
retour 0 ;
} char * strlwr (char * s); <br/> wchar_t * _wcslwr (wchar_t * s); <br/> unsigned char * _mbslwr (unsigned char * s); <br/> <br/> convertit les lettres d'une chaîne en minuscules. <br/> <br/> strlwr convertit les lettres a misé sur la chaîne s en minuscules avec local catégorie LC_CTYPE. Pour les paramètres régionaux, C effectue la conversion est des majuscules lettres (A à Z) en lettres minuscules (a à z). <br/> <br/> strlwr retourne un pointeur vers l'art de la chaîne
# 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) ;
retour 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/> ajouter une partie d'une chaîne à l'autre. <br/> <br/> strncat copie maxlen de caractères spécifiée de la src à la fin du dest, puis ajoute un caractère null. La longueur maximale de la chaîne résultante est strlen (dest) + maxlen. <br/> <br/> pour _mbsnbcat, si le second octet du caractère de 2 octets est zéro, le premier octet de ce personnage est considéré comme invalide. <br/> <br/> ces quatre fonctions se comportent de manière identique et diffèrent uniquement pour le type d'arguments et de types retournée. <br/> <br/> strncat renvoie dest.
# include <string.h> # include <stdio.h> int main (void) {destination char [25]} ;
char * source = « États » ;
strcpy (destination, "United") ;
strncat(destination,_source,_7) ;
("printf (« %s\n », de destination) ;
retour 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 unsigned, unsigned const char * s2, size_t maxlen); <br/> # define _mbccmp (__s1, __s2) _mbsncmp ((__s1), (_ s2), 1) <br/> <br/> compare une partie d'une chaîne à une partie de l'autre. <br/> <br/> strncmp rend la comparaison même à strcmp, mais elle dépasse le nombre de caractères indiqués dans maxlen. Elle commence avec le premier caractère de chaque chaîne et se poursuit avec les caractères suivants jusqu'à ce qu'une différence est ou a été examiné maxlen caractères. <br/> <br/> strncmp renvoie une valeur de nombre entier basée sur le résultat de la comparaison de s1 (ou en partie) à s2 (ou partie de celle-ci):
| < 0 | si s1 est inférieure à s2 |
| == 0 | si s1 est égal à s2 |
| > 0 | si s1 est supérieure à s2 |
# include <string.h> # include <stdio.h> int main (void) {char * buf1 = "aaabbb", * buf2 = "bbbccc", * buf3 = "ccc";}
int ptr ;
PTR = strncmp(buf2,buf1,3) ;
Si printf("buffer_2_is_greater_than_buffer_1\n") (ptr > 0) ;
autre printf("buffer_2_is_less_than_buffer_1\n") ;
PTR = strncmp(buf2,buf3,3) ;
Si printf("buffer_2_is_greater_than_buffer_3\n") (ptr > 0) ;
autre printf("buffer_2_is_less_than_buffer_3\n") ;
retour (0) ;
} int strncmpi (const_char_ * _s1, _const_char_ * _s2, _size_t_n); <br/> wcsncmpi int (const wchar_t * s1, const wchar_t * s2, size_t n); <br/> <br/> compare une partie d'une chaîne à une partie d'une autre personne, sans distinction entre majuscules et minuscules. <br/> <br/> strncmpi compare s1 à s2pour une longueur maximale de n octets, à commencer par le premier caractère de chaque chaîne et continuent avec les caractères suivants, jusqu'à ce que les caractères correspondants diffèrent ou jusqu'à discute n caractères. La comparaison fait une distinction entre les majuscules et les minuscules. (Strncmpi est le même que strnicmp - implémentée comme une macro). Renvoie une valeur (< 0, 0, ou > 0) fondée sur le résultat de la comparaison s1 (ou partie de celle-ci) à s2 (ou partie de ceux-ci). <br/> <br/> si s1 is... strncmpi retourne une valeur is...<br/> <br/>
| moins que s2 | < 0 |
| identique à s2 | == 0 |
| supérieure à s2 | > 0 |
# include <string.h> # include <stdio.h> int main (void) {char * buf1 = "BBBccc", * buf2 = "bbbccc";}
int ptr ;
PTR = strncmpi(buf2,buf1,3) ;
Si printf("buffer_2_is_greater_than_buffer_1\n") (ptr > 0) ;
Si printf("buffer_2_is_less_than_buffer_1\n") (ptr < 0) ;
Si (ptr == 0) printf("buffer_2_equals_buffer_1\n") ;
retour 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/> copier un nombre spécifié d'octets d'une chaîne dans une autre, la troncation ou peluche comme il peut être nécessaire. <br/> <br/> strncpy copie jusqu'à src dest maxlen caractèrestroncature dest avec l'insertion d'une valeur null. La chaîne du destin, dest, ne peut être terminée dans la valeur null si la longueur d'orig est maxlen ou plus. <br/> <br/> strncpy renvoie dest.
# include # inclure int main (void) {string char [10]} ;
char * s = « abcdefghi » ;
strncpy(String,_str1,_3) ;
String [3] = « \0 » ;
("printf ("%s\n", string) ;
retour 0 ;
} int strnicmp (const char * s1, const char * s2, size_t maxlen); <br/> _wcsnicmp int (const wchar_t * s1, const wchar_t * s2, size_t maxlen); <br/> int _mbsnicmp (const char * s1 unsigned, unsigned const char * s2, size_t maxlen); <br/> <br/> compare une partie d'une chaîne à une partie d'une autre personne, sans distinction entre majuscules et minuscules. <br/> <br/> strnicmp compare s1 à s2, pour une longueur maximale de maxlen octets, commençant par le premier caractère de chaque chaîne et continuer avec les caractères suivants, jusqu'à ce que les caractères correspondants diffèrent ou jusqu'à la fin de la chaîne. La comparaison ne fait aucune distinction entre majuscules et minuscules. <br/> <br/> retourne une valeur (< 0, 0, ou > 0) selon le résultat de la comparaison de s1 (ou partie de celle-ci) à s2 (ou partie de ceux-ci). <br/> <br/>
| si s1... | strnicmp retourne une valeur que diriez.. |
| moins de s2 | < 0 |
| les mêmes S2 | == 0 |
| plus de s2 | > 0 |
# include <string.h> # include <stdio.h> int main (void) {char * buf1 = « BBBccc », * buf2 = « bbbccc »;}
int ptr ;
PTR = strnicmp(buf2,_buf1,_3) ;
Si printf("buffer_2_is_greater_than_buffer_1\n") (ptr > 0) ;
Si printf("buffer_2_is_less_than_buffer_1\n") (ptr < 0) ;
Si (ptr == 0) printf("buffer_2_equals_buffer_1\n") ;
retour 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, ch unsigned int, n size_t); <br/> <br/> établit un certain nombre n de ch de caractères d'une chaîne. <br/> <br/> strnset copier le caractère ch dans les n premiers octets de l'art de la chaîne <br/> <br/> si n > strlen (s)Ensuite, strlen (s) remplacer b. S'arrête lorsque établi n caractères, ou un caractère null trouve. <br/> <br/> chacune de ces fonctions renvoient s.
# include <stdio.h> # include <string.h> int main (void) {char * string = « abcdefghijklmnopqrstuvwxyz »;}
lettre de char = « x » ;
printf("string_before_strnset:_%s\n",_String) ;
strnset(String,_letter,_13) ;
printf("string_after_strnset:_%s\n",_String) ;
retour 0 ;
} char * strpbrk (const_char_ * _s1, _const_char_ * _s2); / * C seulement * / <br/> const char * strpbrk (const char * s1, const char * s2); / / C ++ seulement <br/> char * strpbrk (char * s1, const char * s2); / / C ++ seulement <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/> analyse une chaîne à la recherche de la première apparition de toute carácaractère d'un ensemble donné. <br/> <br/> strpbrk analyse une chaîne, s1 pour la première occurrence d'un caractère de s2. <br/> <br/> <em> strpbrk retourne un pointeur vers la première occurrence de l'un des personnages de s2. Si s1 s2 n'est pas pas une coïncidence, strpbrk renvoie une valeur null.
# include # inclure int main (void) {char * chaine1 = « abcdefghijklmnopqrstuvwxyz »;}
char * chaine2 = « onm » ;
char * ptr ;
PTR = strpbrk (Chaîne1, chaîne2) ;
Si printf("strpbrk_found_first_character:_%c\n",_*ptr) (ptr) ;
autre printf("strpbrk_didn't_find_character_in_set\n") ;
retour 0 ;
} char * strrchr (const char * s, int c); / * C seulement * / <br/> const char * strrchr (const char * s, int c); / / C ++ seulement <br/> char * strrchr (char * s, int c); / / C ++ seulement <br/> wchar_t * wcsrchr (const wchar_t * s, wchar_t c); <br/> unsigned char * _mbsrchr (const unsigned char * s, c unsigned int); <br/> <br/> analyse une chaîne à la recherche de la dernière occurrence d'un caractère déterminé. <br/> <br/>strrchr analyse une chaîne dans la direction opposée, à la recherche d'un caractère particulier. strrchr trouve la dernière occurrence de la c caractère dans une chaîne s. Le terminateur null est considéré comme faisant partie du réseau. <br/> <br/> strrchr retourne un pointeur vers la dernière occurrence de la c caractère si c ne fonctionne pas en s, strrchr renvoie une valeur null.
# include <string.h> # include <stdio.h> int main (void) {string char [15]} ;
char * ptr, c = « r » ;
strcpy(String,_"This_is_a_string") ;
PTR = strrchr (string, c) ;
Si printf("The_character_%c_is_at_position:_%d\n",_c,_ptr-string) (ptr) ;
autre printf("The_character_was_not_found\n") ;
retour 0 ;
} char * strrev (char * s); <br/> wchar_t * _wcsrev (wchar_t * s); <br/> unsigned char * _mbsrev (unsigned char * s); <br/> <br/> investit un chaîne. <br/> <br/> strrev change tous les caractères dans une chaîne d'inverser l'ordre, sauf la cessation de caractère null. (Par exemple, pourrait changer string\0 à gnirts\0). <br/> <br/> strrev retourne un pointeur vers la chaîne a infirmé.
# include <string.h> # include <stdio.h> int main (void) {char * avant = « chaîne »;}
printf("Before_strrev():_%s\n",_forward) ;
strrev (forward) ;
printf("After_strrev():_%s\n",_forward) ;
retour 0 ;
} char * strset (char * s, int ch); <br/> wchar_t * _wcsset (wchar_t * s, wchar_t ch); <br/> unsigned char * _mbsset (unsigned char * s, ch unsigned int); <br/> <br/> définit tous les caractères dans une chaîne d'un caractère déterminé. <br/> <br/> strset établit que tous les caractères dans la chaîne s à caractère ch. Est à gauche lorsque le caractère null de fin se trouve. <br/> <br/> strset retourne s.
# include <stdio.h> # include <string.h> int main (void) {char chaîne [10] = « 123456789 »;}
symbole de char = « c » ;
printf("Before_strset():_%s\n",_String) ;
strset (string, symbole) ;
printf("After_strset():_%s\n",_String) ;
retour 0 ;
} char * strpos() (const char * s1, const char * s2); / * C seulement * / <br/> const char * strpos() (const char * s1, const char * s2); / / C ++ seulement <br/> char * strpos() (const char * s1, const char * s2); / / C ++ seulement <br/> wchar_t * wcsstr (const wchar_t * s1, const wchar_t * s2); <br/> unsigned char * _mbsstr (const unsigned char * s1, const unsigned char * S2);
Analyse une chaîne en l'occurrence d'une recherche de sous-chaîne donnée.
strpos() explore s1 à la première occurrence de la sous-chaîne s2.
strpos() retourne un pointeur vers l'élément de s1, s2, où commence (s1 s2 points). Si s2 ne fonctionne pas dans s1, strpos() retourne une valeur 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) ;
retour 0 ;
} <br/> char * stupr (char * s); <br/> wchar_t * _wcsupr (wchar_t * s); <br/> unsigned char * _mbsupr (unsigned char * s);
Convertit les minuscules une chaîne en majuscules.
stupr convertis en lettres minuscules dans la chaîne s capitalisé conformément à la LC_CTYPE locale catégorie présente. conversion est de lettres minuscules (a - z) en lettres majuscules (de a à Z). D'autres personnages inchangée.
stupr retourne s.
# include <stdio.h> # include <string.h> int main (void) {char * string = « abcdefghijklmnopqrstuvwxyz », * ptr;}
/ * convertit une chaîne de caractères majuscules * / ptr = stupr (string) ;
("printf ("%s\n", ptr) ;
retour 0 ;
} 
