strtok funkcijas. C valodas funkciju apraksts. Dažu funkciju apraksts darbam ar virknēm

4 atbildes

Divas lietas, kas jāzina par strtok. Kā minēts, tas "saglabā iekšējo stāvokli". Turklāt viņš izjauca līniju, kuru barojat. Būtībā tas ierakstīs "\0", kur atradīs jūsu norādīto marķieri un atgriezīs rādītāju uz rindas sākumu. Iekšēji tas saglabā pēdējā marķiera atrašanās vietu; un nākamreiz, kad to piezvanīsit, tas sāksies no turienes.

Svarīgas sekas ir tādas, ka nevar izmantot strtok virknē, piemēram, const char* "hello world"; jo, mainot const char* virknes saturu, jūs saņemsit piekļuves pārkāpumu.

Strtok "labā lieta" ir tāda, ka tas faktiski nekopē virknes, tāpēc jums nav jāpārvalda papildu atmiņas piešķiršana utt. Bet, ja jūs nesaprotat iepriekš minēto, jums būs grūtības to izmantot.

Piemērs. Ja jums ir "this, is, virkne", secīgi strtok izsaukumi ģenerēs šādus rādītājus (^ vērtība ir atgriešanas vērtība). Ņemiet vērā, ka vietā, kur tiek atrasti marķieri, tiek pievienots "\0"; tas nozīmē, ka sākotnējā rinda ir mainīta:

T h i s , i s , a , s t r i n g \0 this,is,a, virkne t h i s \0 i s , a , s t r i n g \0 this ^ t h i s \0 i s \0 r i s \0 r i s \0 a \ 0 s t r i n g \0 a ^ t h i s \0 i s \0 a \0 s t r i n g \0 virkne ^

Cerams, ka tam ir jēga.

Funkcija strtok () saglabā datus starp zvaniem. Tas izmanto šos datus, kad tos izsaucat ar NULL rādītāju.

Punktu, kurā tika atrasts pēdējais marķieris, iekšēji saglabā funkcija, kas tiks izmantota nākamajā izsaukumā (nav nepieciešama īpaša bibliotēkas ieviešana, lai novērstu datu atteices).

strtok uztur iekšējo stāvokli. Izsaucot to ar vērtību, kas nav NULL, tā tiek atkārtoti inicializēta, lai izmantotu jūsu piegādāto virkni. Kad jūs to izsaucat ar NULL , tā izmanto šo virkni un jebkuru citu stāvokli, kas tai pašlaik ir, lai atgrieztu nākamo marķieri.

Strtok darbības veida dēļ, ja rakstāt vairākpavedienu lietojumprogrammu, noteikti izveidojiet saiti uz C izpildlaika vairākpavedienu versiju. Tas nodrošina, ka katrs pavediens iegūst savu strtok iekšējo stāvokli.

Funkcija strtok saglabā datus iekšējā statiskā mainīgajā, kas tiek koplietots starp visiem pavedieniem.

Vītnes drošībai jāizmanto strtok_r

Apskatiet statisko char *last;

Char * strtok(s, delim) register char *s; reģistrēt const char *delim; (reģistrs char *spanp; reģistrs int c, sc; char *tok; statiskā zīme *pēdējais; if (s == NULL && (s = pēdējais) == NULL) return (NULL); /* * Izlaist (span) sākuma norobežotāji (s += strspn(s, delim), sort of == sc) goto cont ) if (c == 0) ( /* bez norobežojošām rakstzīmēm */ last = NULL; return (NULL); ) tok = s - 1 * Skenēt atdalītājus : s += strcspn(s, delim) * Ņemiet vērā, ka delim ir jābūt vienam NUL; )delim do ( if ((sc = *spanp++) == c) ( if (c == 0) s = NULL; else s[-1] = 0; pēdējais = s; atgriezties (tok); ) ) while (sc != 0 ) /* NOTREACHED */ )

dalīties

1) Atrod nākamo marķieri nulles beigu baitu virknē, uz kuru norāda str . Atdalītāju rakstzīmes identificē ar nulles baitu virkni, uz kuru norāda delim .

Šo funkciju sauc par vairākkārtēju reizināšanu, lai iegūtu secīgus marķierus no vienas un tās pašas virknes.

• Ja str! = NULL str! = NULL , izsaukums tiek uzskatīts par pirmo strtok izsaukumu konkrētajai rindai. Funkcija meklē pirmo rakstzīmi, kas Nav ietverts delim.
• Ja šāds simbols netika atrasts, tad tajā nav marķieru, un funkcija atgriež nulles rādītāju.
• Ja šāds simbols tika atrasts, tas būs marķiera sākums. Pēc tam funkcija no šī punkta meklē pirmo rakstzīmi, kas ir ietverta delim .
• Ja šāda rakstzīme netiek atrasta, str ir tikai viens marķieris, un turpmākie izsaukumi strtok atgriež nulles rādītāju
• Ja šāds simbols tiek atrasts, tas aizstāts nulles rakstzīme "\0" un rādītājs uz nākamo rakstzīmi tiek saglabāti statiskā vietā turpmākajiem izsaukumiem.
• Pēc tam funkcija atgriež rādītāju uz marķiera sākumu
• Ja str == NULL , izsaukums tiek uzskatīts par nākamajiem strtok izsaukumiem: funkcija turpinās no vietas, kur tā tika atstāta iepriekšējā izsaukumā. Darbība ir tāda pati kā tad, ja iepriekš saglabātais rādītājs tiktu nodots kā str.

Rīcība nav definēta, ja vien str vai delim nav rādītājs uz nulles gala baitu virkni.

2) Tas pats, kas (1), izņemot to, ka katrā darbībā tiek ierakstīts redzamo rakstzīmju skaits laukā str uz *strmax un marķiera iekšējo stāvokli tiek ierakstīts *ptr . Atkārtotiem zvaniem (ar nulles strmax) ir jānokārto strmax un ptr ar vērtībām, kas saglabātas iepriekšējā zvanā. Turklāt izpildlaikā tiek konstatētas šādas kļūdas, un pašlaik instalētā ierobežojumu apstrādātāja funkcija tiek izsaukta, neko nesaglabājot objektā, uz kuru norāda ptr

• strmax , delim vai ptr — nulles rādītājs
• nesākotnējā izsaukuma gadījumā (ar null str), *ptr - nulles rādītājs
• pirmajā zvanā *strmax ir nulle vai lielāks par RSIZE_MAX
• meklējot marķiera beigas, tiek sasniegts sākotnējās virknes beigas (ko mēra pēc sākotnējās vērtības *strmax)), nesastopoties ar nulles terminatoru.

Darbība nav definēta, ja abas str norāda uz rakstzīmju masīvu, kurā nav nulles rakstzīmes, un strmax norāda uz vērtību, kas ir lielāka par šī rakstzīmju masīva lielumu. Tāpat kā visas ar robežām saistītās funkcijas, strtok_s ir garantēta tikai tad, ja __STDC_LIB_EXT1__ ir ieviests un ja lietotājs definē __STDC_WANT_LIB_EXT1__ vesela skaitļa konstantei 1 pirms string.h iekļaušanas.

iespējas

Atdeves vērtība

Atgriež rādītāju uz nākamā marķiera sākumu vai NULL, ja vairs nav marķieru.

Piezīme

Šī funkcija ir destruktīva: tā ieraksta "\0" rakstzīmes virknes str elementos. Konkrēti, virknes literālu nevar izmantot kā strtok pirmo argumentu.

Katrs strtok izsaukums maina statisku mainīgo: tas nav pavedienam drošs.

Atšķirībā no vairuma citu marķieru, strtok atdalītāji var atšķirties katram nākamajam marķierim un var būt pat atkarīgi no iepriekšējo marķieru satura.

Funkcija strtok_s atšķiras no POSIX funkcijas strtok_r ar to, ka tā tiek saglabāta ārpus marķierizētās virknes un pārbauda izpildlaika ierobežojumus.

piemērs

#define __STDC_WANT_LIB_EXT1__ 1 #include #iekļauts int main(void) ( char input = "Putns pastaigājās"; printf("Ievades virknes "%s" parsēšana\n", ievade); char *token = strtok(input, " "); while( marķieris) ( puts(token); marķieris = strtok(NULL, " "); ) printf("Ievades virknes saturs tagad: ""); for(size_t n = 0; n< sizeof input; ++n) input[n] ? printf("%c", input[n]) : printf("\\0"); puts("""); #ifdef __STDC_LIB_EXT1__ char str = "A bird came down the walk"; rsize_t strmax = sizeof str; const char *delim = " "; char *next_token; printf("Parsing the input string "%s"\n", str); token = strtok_s(str, &strmax, delim, &next_token); while(token) { puts(token); token = strtok_s(NULL, &strmax, delim, &next_token); } printf("Contents of the input string now: ""); for(size_t n = 0; n < sizeof str; ++n) str[n] ? printf("%c", str[n]) : printf("\\0"); puts("""); #endif }

Iespējamā izvade:

Ievades virknes parsēšana "Putns nokāpa ejot" Putns nokāpa pastaigā Ievades virknes saturs tagad: "A\0bird\0come\0down\0the\0walk\0" Ievades virknes parsēšana "Putns nokāpa staigāt" Putns nokāpa pa gājienu Ievades virknes saturs tagad: "A\0bird\0come\0down\0the\0walk\0"

• C11 (ISO/IEC 9899:2011):
• 7.24.5.8 Funkcija strtok (lpp: 369-370)
• K.3.7.3.1. Funkcija strtok_s (p: 620-621)
• C99 (ISO/IEC 9899:1999):
• 7.21.5.8. Funkcija strtok (332.-333. lpp.)
• C89/C90 (ISO/IEC 9899:1990):
• 4.11.5.8 strtok funkcija

	atrod jebkuras rakstzīmes pirmo atrašanās vietu vienā rindā, citā rindā (funkcija)
	tikai rakstzīmes, kas nav atrastas citā baitu virknē (funkcija)
	atgriež maksimālā sākuma segmenta garumu, kas sastāv no tikai rakstzīmes, kas atrodamas citā baitu virknē (funkcija)
(C95) (C11)	atrod nākamo žetonu platā virknē (funkcija)
C++ dokumentācija par strtok

Cits aizstājvārds

strtok

APSKATS

#iekļauts

char *strtok(char *str, const char *delim);
char *strtok_r(char *str, const char *delim,char**saveptr);

Prasības rekvizītu pārbaudes makro glibc (sk funkciju_testa_makro(7)):

strtok_r(): _SVID_SOURCE || _BSD_SOURCE || _POSIX_C_SOURCE >= 1 || _XOPEN_SOURCE || _POSIX_SOURCE

APRAKSTS

Funkcija strtok() sadala virkni nulles vai vairāku netukšu marķieru secībā. Pirmajā zvanā strtok() argumentā jānorāda parsētā virkne str. Katrā nākamajā izsaukumā, kas parsē to pašu virkni, vērtību str jābūt NULL.

Argumentā delim ir norādīta baitu kopa, kas tiek uzskatīta par marķieru atdalītājiem analizētajā virknē. Zvanītājs var norādīt dažādas līnijas delim nākamajos izsaukumos, parsējot to pašu virkni.

Katrs zvans strtok() atgriež rādītāju uz nulles gala virkni, kas satur nākamo marķieri. Šajā rindā nav iekļauts norobežotāja baits. Ja žetonu vairs nav, tad strtok() atgriež NULL.

Zvanu secība strtok(), kas darbojas ar vienu virkni, uztur rādītāju, kas norāda punktu, kurā sākas nākamā marķiera meklēšana. Pirmais zvans strtok() piešķir šim rādītājam atsauci uz virknes pirmo baitu. Nākamā marķiera sākums tiek noteikts, meklējot uz priekšu iekšā str nākamais baits nav atdalītājs. Ja tiek atrasts baits, tas tiek uzskatīts par nākamā marķiera sākumu. Ja šāds baits netiek atrasts, tad vairs nav marķieru un strtok() atgriež NULL (tukšai vai norobežotai virknei, tādā gadījumā NULL tiks atgriezta pirmajā izsaukšanas reizē strtok()).

Katra marķiera beigas tiek atrastas, meklējot uz priekšu, līdz tiek atrasts norobežotāja baits vai beigu nulles baits ("\0"). Ja tiek atrasts norobežotāja baits, tas tiek aizstāts ar nulles baitu, lai pārtrauktu pašreizējo marķieri, un strtok() saglabā rādītāju uz nākamo baitu; šis rādītājs tiks izmantots kā sākumpunkts, meklējot nākamo marķieri. Šajā gadījumā strtok() atgriež rādītāju uz atrastā marķiera sākumu.

No iepriekš minētā apraksta izriet, ka divu vai vairāku blakus esošu norobežotāju baitu secība skenētajā rindā tiek uzskatīta par vienu atdalītāju, un norobežotāja baiti virknes sākumā vai beigās tiek ignorēti. Citiem vārdiem sakot, žetoni atgriezās strtok() - vienmēr nav tukšas virknes. Tas ir, piemēram, ja ir rinda " aaa;;bbb,", tad nākamie zvani strtok() ar dotajiem rindu atdalītājiem " ;, "atgrieztu stīgas" aaa" Un " bbb" un pēc tam nulles rādītājs.

Funkcija strtok_r() ir atkārtoti ienācēja versija strtok(). Arguments saveptr ir rādītājs uz mainīgo char* kas tiek lietots iekšēji strtok_r(), lai, analizējot vienu un to pašu virkni, ņemtu vērā kontekstu starp nākamajiem izsaukumiem.

Pirmajā zvanā strtok_r() nozīme str jānorāda uz parsējamo virkni un vērtību saveptr ignorēts. Nākamajos zvanos vērtība str ir jābūt NULL un vērtībai saveptr nedrīkst mainīties kopš iepriekšējā zvana.

Dažādas rindas var analizēt vienlaicīgi vairākos palaijumos strtok_r() ar dažādiem argumentiem saveptr.

ATGRIEŠANAS VĒRTĪBA

Funkcijas strtok() Un strtok_r() atgriezt rādītāju uz nākamo marķieri vai NULL, ja vairs nav marķieru.

ATRIBŪTI

Šīs sadaļas terminu aprakstu sk atribūti(7).

Interfeiss	Atribūts	Nozīme
strtok()	nekaitīgums pavedienos	nedrošas (MT-Nedrošas sacīkstes:strtok)
strtok_r()	nekaitīgums pavedienos	nekaitīgs (MT-Safe)

ATBILSTĪBA

strtok() POSIX.1-2001, POSIX.1-2008, C89, C99, SVr4, 4.3BSD. strtok_r() POSIX.1-2001, POSIX.1-2008.

Defekti

Izmantojiet šīs funkcijas piesardzīgi. Lūdzu, ņemiet vērā, ka: * Šīs funkcijas maina savu pirmo argumentu. * Šīs funkcijas nevar izmantot ar nemainīgām virknēm. * Atdalītāja baita identitāte ir zaudēta. * Analizējot funkciju strtok() izmanto statisku buferi un tāpēc nav vītnes drošs. Izmantot strtok_r() šajā gadījumā.

PIEMĒRS

Tālāk norādītajā programmā izsaukšanai tiek izmantotas ligzdotas cilpas strtok_r(), lai sadalītu virkni to veidojošos marķieros. Pirmajā parametrā komandrinda ir norādīta analizējamā virkne. Otrais parametrs norāda atdalīšanas baitu(-us), kas tiek izmantots, lai sadalītu virkni “saliktos” marķieros. Trešais parametrs norāda atdalīšanas baitu(-s), kas tiek izmantots, lai sadalītu “saliktos” marķierus apakštokenos.

Programmas izvades piemērs:

$./a.out "a/bbb///cc;xxx:yyy:" ":;" "/" 1: a/bbb///cc --> a --> bbb --> cc 2: xxx --> xxx 3: yyy --> yyy

Programmas pirmkods

#iekļauts #iekļauts #iekļauts int main(int argc, char *argv) ( char *str1, *str2, *token, *subtoken; char *saveptr1, *saveptr2; int j; if (argc != 4) ( fprintf(stderr, "Lietojums: % s string delim subdelim\n", argv); iziet (EXIT_FAILURE); ) for (j = 1, str1 = argv; ; j++, str1 = NULL) ( marķieris = strtok_r(str1, argv, &saveptr1); if (token = = NULL) breakf("%d: %s\n", j, marķieris (str2 = marķieris; ; str2 = NULL) ( apakštokens = strtok_r(str2, argv, &saveptr2); if (apakštokens ==); NULL) pārtraukums printf(" --> %s\n", apakštokens) ) iziet(EXIT_SUCCESS)

Vēl viens programmas piemērs strtok(), var atrast getaddrinfo_a(3).

Programmēšanas valodas var ietvert īpašas funkcijas darbam ar virknēm, tādējādi atbrīvojot programmētāju no nepieciešamības rakstīt savas virkņu apstrādes funkcijas. Piemēram, jums bieži ir jānosaka virknes garums, un tāpēc valodas nodrošina funkciju, kas mēra tās garumu.

Programmēšanas valodā C funkcijas darbam ar virknēm tiek deklarētas galvenes failā string.h, kas jums jāatceras iekļaut avota kodā. Darbam ar virknēm ir aptuveni divdesmit funkcijas. Starp tiem ir tādas, kas meklē rakstzīmes virknē, salīdzināšanas funkcijas, virkņu kopēšanu, kā arī specifiskākas. Lielākā daļa esošo saraksts un apraksts Šis brīdis funkcijas C valodā var atrast B. Kernighan, D. Ritchie grāmatas “The Second Edition” pielikumā.

Visas string.h deklarētās funkcijas to darbības laikā var mainīt vai nemainīt vienu no rādītāja nodotajām virknēm. Tas ir atkarīgs no funkcijas mērķa. Tomēr lielākā daļa no tiem kaut ko atgriež: vai nu rādītāju uz rakstzīmi, vai veselu skaitli. Turklāt, ja funkcija maina kādu no saviem parametriem un tika izsaukta šim nolūkam, tad to, ko tā atgriež, var ignorēt (t.i., izsaukšanas funkcijā nekam nepiešķirt).

Piemēram, funkcijai strcpy() ir šāda deklarācija: char *strcpy (char *, const char*) . Tas kopē virkni, uz kuru norāda otrais parametrs, virknē, uz kuru norāda pirmais parametrs. Tādējādi tiek mainīts pirmais parametrs. Turklāt funkcija atgriež rādītāju uz virknes pirmo rakstzīmi:

char s1[10], s2[10]; char * s3; s3 = s2; izpaužas(s1); s3 = strcpy(s2, s1); liek (s2) ; liek (s3) ; printf("%p, %p \n", s2, s3) ;

Šeit s2 un s3 norāda uz vienu un to pašu simbolu (printf () izvada tās pašas adreses). Tomēr to, ko strcpy() atgriež, nevar piešķirt masīvam. Šīs funkcijas rezultāts parasti netiek piešķirts nekam; Dažreiz pietiek ar to, ka tas vienkārši maina vienu no rādītāja nodotajām virknēm.

Cita lieta ir tādas funkcijas kā strlen() vai strcmp() , kuras nemaina parametrus, bet tiek izsauktas rezultāta labad. Funkcija strcmp() salīdzina divas argumentu virknes burtus pa burtiem (leksikogrāfiski) un atgriež 0, -1 vai 1. Piemēram, izsaucot strcmp("boy", "body"), tiks atgriezts 1, jo Burta "y" kods ir lielāks par burtu "d". Izsaucot strcmp("body", "boy"), tiks atgriezts -1, jo pirmais arguments leksikogrāfiski ir mazāks par otro.

funkcija strtok()

Izmantojot strtok funkcijas() virkni var sadalīt atsevišķās daļās (žetonos). Šīs funkcijas deklarācija izskatās šādi: char *strtok (char *, const char *) . Kad funkcija tiek izsaukta pirmo reizi, pirmais parametrs ir virkne, kas jāsadala. Otrais parametrs norāda atdalīšanas virkni. Turpmākajos funkcijas izsaukumos tai pašai virknei pirmajam parametram jābūt NULL, jo funkcija jau ir “atcerējusies”, ar ko tā darbojas. Apskatīsim piemēru:

char str = "viens, divi, trīs, četri, pieci" ; char * sp; sp = strtok (str, ", " ) ; while (sp) ( liek (sp); sp = strtok (NULL, ", " ) ; )

Šī koda izpildes rezultātā ekrānā kolonnā tiek parādīti šādi vārdi:

Viens divi trīs četri pieci

Pirmo reizi izsaucot strtok(), funkcijai tiek nodots rādītājs uz masīva pirmo rakstzīmi un norobežotāja virkne. Pēc šī izsaukuma tiek mainīts masīvs str, tajā paliek tikai vārds "one", un funkcija arī atgriež rādītāju uz šo vārdu, kas tiek piešķirts sp.

Lai gan mēs esam pazaudējuši pārējo masīvu izsaukšanas funkcijā, rādītājs uz pārējo masīvu tiek saglabāts iekšā strtok (). Kad NULL ir nodota, funkcija "zina" strādāt ar šo "asti".

Stīgu daļu kopēšana

Ja jums vienkārši jāsavieno divas virknes, problēmu var viegli atrisināt, izsaucot funkciju strcat (), kas pirmā argumenta beigām pievieno otro. Līdzīga funkcija strncat() pievieno n otrās virknes rakstzīmes pirmajai. n ir norādīts kā trešais parametrs.

Ko darīt, ja situācija ir sarežģītāka? Piemēram, ir divas rindas, kas nav tukšas, un jums ir jāsavieno pirmās rindas sākums un otrās beigas. To var izdarīt, izmantojot funkciju strcpy(), ja nododat atsauces nevis uz rindu pirmajām rakstzīmēm:

char s1[20] = "Pīters Smits" , s2 = "Džūlija Robertsa" ; strcpy (s1+ 5 , s2+ 5 ); liek (s1) ;

Šajā gadījumā ekrānā tiks parādīts "Peter Roberts". Kāpēc tas notika? Rādītājs uz pirmās rindas sesto rakstzīmi tika nodots funkcijai strcpy (). Tas noveda pie tā, ka kopējot šīs rindas rakstzīmes tiek pārrakstītas tikai sākot ar 6., jo strcpy() neko "nezina" par iepriekšējām rakstzīmēm. Tikai daļa no virknes tiek nodota arī kā otrais arguments, kas tiek kopēts uz pirmo.

Kā ievietot vienu rindiņu otras vidū? Šo problēmu var atrisināt, izmantojot trešo “bufera” rindiņu, kur vispirms varat kopēt pirmo rindiņu, pēc tam otro, izdzēšot pirmās rindas beigas, pēc tam pievienojiet pirmās rindas beigas. Bet jūs varat arī rīkoties šādi:

char s1[20] = "viens trīs" , s2[20] = "divi"; strcpy (s2+ 3 , s1+ 3 ); strcpy (s1+ 4, s2); liek (s1) ;

Šeit vispirms pirmās beigas tiek kopētas otrajā rindā, iegūstot “divi trīs”. Pēc tam otrā rinda tiek kopēta pirmajā rindā, apejot tās sākumu.

Dažu funkciju apraksts darbam ar virknēm

Vingrinājums
Tālāk ir sniegti dažu funkciju apraksti, kas veic darbības ar virknēm. Izstrādājiet un rakstiet nelielas programmas, lai ilustrētu šo funkciju darbību.

• char * strchr (const char *, int c) . Atgriež rādītāju uz rakstzīmes c pirmo reizi virknē. Atgriež NULL, ja virknē šādas rakstzīmes nav.
• char *strstr (const char *s2, const char *s1) . Atgriež rādītāju uz virknes s1 pirmo reizi virknē s2. Ja atbilstības nav, atgriež NULL.
• char *strncpy (char *, const char *, size_t n) . Kopē n rakstzīmes no otrās rindas uz pirmo.
• size_t strspn (const char *, const char *) . Atgriež pirmās virknes sākuma garumu, kas ietver rakstzīmes, kas veido otro virkni.

Apraksts

Funkcija strtok meklē marķierus virknes virknē. Šīs funkcijas izsaukumu secība sadala virkni marķieros, kas ir rakstzīmju secības, kas atdalītas ar norobežojošām rakstzīmēm.

Pirmajā izsaukumā funkcija kā argumentu izmanto virkni, kuras pirmā rakstzīme tiek izmantota kā sākumpunkts marķieru meklēšanai. Turpmākajos izsaukumos funkcija gaida nulles rādītāju un izmanto pozīciju tūlīt pēc pēdējā marķiera beigām kā jauno skenēšanas vietu.

Lai noteiktu marķiera sākumu, funkcija vispirms nosaka rakstzīmes, kas nav ietvertas virknē delim , tas ir, tās ir norobežojošās rakstzīmes. Un tad tas pārbauda atlikušo virknes daļu pēc rakstzīmes līdz pirmajai norobežojošajai rakstzīmei, kas norāda marķiera beigas.

Šis beigu marķieris tiek automātiski aizstāts ar nulles rakstzīmi, un funkcija to atgriež. Pēc tam nākamie funkcijas strtok izsaukumi sākas ar šo nulles rakstzīmi.

Iespējas:

• stīga
  Virkne, kurā meklēt leksēmas. Šīs virknes saturs tiks mainīts, tā tiks sadalīta mazākās virknēs (žetonos). Šis parametrs var saturētnulles rādītājs, tādā gadījumā funkcija turpina skenēšanu no vietas, kur tika pārtraukta iepriekšējā veiksmīgā funkcijas izsaukšana.
• delim
  Virkne, kas satur atdalītājus. Tie var atšķirties atkarībā no vienas funkcijas izsaukuma uz citu funkcijas izsaukumu.

Atdeves vērtība

Rādītājs uz pēdējo virknē atrasto marķieri.
Nulles rādītājs tiek atgriezts, ja netiek atrasts neviens marķieris.

Piemērs: programmas pirmkods

//funkcijas strtok izmantošanas piemērs #include #iekļauts int main () ( char str = "Nacionālās zvejas iezīmes — mākslas filma, komēdija."; std::cout<< "Разделение строки "" << str << "" на лексемы:n"; char * pch = strtok (str," ,.-"); // во втором параметре указаны разделитель (пробел, запятая, точка, тире) while (pch != NULL) // пока есть лексемы { std::cout << pch << "n"; pch = strtok (NULL, " ,.-"); } return 0; }