Hem › Program › strtok funktioner. Hur fungerar strtok-funktionen i C? Exempel: programkällkod

strtok funktioner. Hur fungerar strtok-funktionen i C? Exempel: programkällkod

Andra Alias

strtok

RECENSION

#omfatta

char *strok(char *str, konst char *delim);
char *strtok_r(char *str, konst char *delim,röding**septr);

Krav för egenskapstestningsmakrot för glibc (se feature_test_macros(7)):

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

BESKRIVNING

Fungera strtok() delar upp en sträng i en sekvens med noll eller fler icke-tomma tokens. Vid första samtalet strtok() strängen som ska analyseras måste anges i argumentet str. I varje efterföljande anrop som analyserar samma sträng, värdet str måste vara NULL.

I argumentation delim en uppsättning byte specificeras som anses vara tokenseparatorer i den analyserade strängen. Den som ringer kan ange olika linjer i delim i efterföljande anrop när samma sträng analyseras.

Varje samtal strtok() returnerar en pekare till en noll-terminerad sträng som innehåller nästa token. Den här raden innehåller ingen avgränsningsbyte. Om det inte finns fler polletter, då strtok() returnerar NULL.

Samtalssekvens strtok(), som arbetar på en enda sträng, upprätthåller en pekare som anger punkten där sökningen efter nästa token börjar. Första samtalet strtok() tilldelar denna pekare en referens till den första byten i strängen. Starten på nästa token bestäms genom att söka framåt in str nästa byte är inte en avgränsare. Om en byte hittas tas den som början på nästa token. Om en sådan byte inte hittas finns det inga fler tokens och strtok() returnerar NULL (för en tom eller avgränsad sträng, i vilket fall kommer NULL att returneras första gången den anropas strtok()).

Slutet på varje token hittas genom en sökning framåt tills en avgränsningsbyte eller en efterföljande nollbyte ("\0") hittas. Om en avgränsningsbyte hittas, ersätts den med en nollbyte för att avsluta den aktuella token, och strtok() lagrar en pekare till nästa byte; den här pekaren kommer att användas som utgångspunkt när du söker efter nästa token. I detta fall strtok() returnerar en pekare till början av den hittade token.

Av beskrivningen ovan följer att en sekvens av två eller flera sammanhängande avgränsningsbyte i raden som ska skannas betraktas som en enda avgränsare, och avgränsningsbytes i början eller slutet av strängen ignoreras. Med andra ord, polletterna återvände strtok() - alltid icke-tomma strängar. Det vill säga om det till exempel finns en linje " aaa;;bbb,", sedan efterföljande samtal strtok() med givna radavgränsare " ;, "skulle returnera strängarna" aaa"och" bbb" och sedan en nollpekare.

Fungera strtok_r() är den återkommande versionen strtok(). Argument septrär en pekare till en variabel röding* som används internt strtok_r() för att ta hänsyn till sammanhanget mellan efterföljande anrop när samma sträng analyseras.

Vid första samtalet strtok_r() betydelse str måste peka på strängen som analyseras och värdet septr ignoreras. Vid efterföljande samtal värdet str måste vara NULL och värdet septr bör inte ändras sedan föregående samtal.

Olika rader kan analyseras samtidigt över flera körningar strtok_r() med olika argument septr.

RETURVÄRDE

Funktioner strtok() Och strtok_r() returnera en pekare till nästa token eller NULL om det inte finns fler tokens.

ATTRIBUT

För en beskrivning av termerna i detta avsnitt, se attribut(7).

Gränssnitt	Attribut	Menande
strtok()	ofarlighet i trådar	osäker (MT-Unsafe race:strtok)
strtok_r()	ofarlighet i trådar	ofarlig (MT-Safe)

EFTERLEVANDE

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

DEFEKT

Använd dessa funktioner med försiktighet. Observera att: * Dessa funktioner ändrar sitt första argument. * Dessa funktioner kan inte användas med konstanta strängar. * Identiteten för separatorbyten går förlorad. * Vid analys av funktionen strtok() använder en statisk buffert och är därför inte trådsäker. Använda sig av strtok_r() I detta fall.

EXEMPEL

Programmet nedan använder kapslade loopar för att anropa strtok_r() för att dela en sträng i dess beståndsdelar. I den första parametern kommandorad strängen som ska analyseras anges. Den andra parametern specificerar separatorbyte(n), som används för att dela upp strängen i "sammansatta" tokens. Den tredje parametern specificerar separatorbyten(erna), som används för att separera "sammansatta" tokens till subtokens.

Exempel på programutgång:

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

Programkällkod

#omfatta #omfatta #omfatta int main(int argc, char *argv) ( char *str1, *str2, *token, *subtoken; char *saveptr1, *saveptr2; int j; if (argc != 4) ( fprintf(stderr, "Användning: % s string delim subdelim\n", argv); exit(EXIT_FAILURE); ) för (j = 1, str1 = argv; ; j++, str1 = NULL) ( token = strtok_r(str1, argv, &saveptr1); if (token = = NULL) break; printf("%d: %s\n", j, token); för (str2 = token; ; str2 = NULL) ( subtoken = strtok_r(str2, argv, &saveptr2); if (subtoken == NULL) break; printf(" --> %s\n", subtoken); ) ) exit(EXIT_SUCCESS); )

Ett annat exempel på ett program som använder strtok(), finns i getaddriinfo_a(3).

Funktionen strtok() returnerar en pekare till nästa token i strängen som str1 pekar på. Tecknen som utgör strängen som adresseras av str2 är avgränsare som definierar token. Om det inte finns någon token att returnera, returneras en nollpekare.

I version C99 tillämpas limit-kvalificeraren på parametrarna str1 och str2.

För att dela en sträng i tokens, första gången strtok() anropas, måste str1-parametern peka på början av strängen. Efterföljande anrop till funktionen måste använda en nollpekare som str1-parameter. I detta fall kommer hela strängen att ändras varje gång funktionen anropas.

Varje anrop till strtok()-funktionen kan använda en annan uppsättning tokenavgränsare.

Funktionen strtok() tillhandahåller ett sätt att reducera en sträng till dess beståndsdelar. Till exempel tokeniserar följande program strängen "En, två och tre".

#omfatta #omfatta int main(void) char *p; p = strtok("En, två och tre.", ","); printf(p); do ( p = strtok(NULL, ",. "); if(p) printf("|%s", p); ) while(p), return 0; )

Resultatet av detta program är följande.

En | två | och | tre

Lägg märke till hur strtok funktion() anropas först med den ursprungliga strängen, men efterföljande anrop till den använder NULL som första argument. Strtok()-funktionen upprätthåller en intern pekare till strängen som bearbetas. Om det första argumentet till strtok() pekar på en sträng, sätts den interna pekaren till början av den strängen. Om det första argumentet är NULL, fortsätter strtok() att bearbeta den föregående strängen, med start vid positionen som lärdes in i föregående steg, och flyttar fram den interna pekaren när nästa token hämtas. Funktionen strtok() "passerar" alltså hela strängen. Lägg också märke till hur avgränsningssträngen ändras vid det första och efterföljande anropet till funktionen. Avgränsningarna kan definieras olika för varje samtal.

#omfatta char *strok(char * str1, konst char * str2);

Funktionen strtok() returnerar en pekare till nästa token i strängen som adresseras av parametern str1. Tecken som bildar strängen som adresseras av parametern str2, är avgränsare som definierar en token. Om det inte finns någon token att returnera, returneras en nollpekare.

I version C99 till parametrar str1 Och str2 Begränsningskvalificeringen tillämpas.

För att dela en sträng i tokens, första gången du anropar strtok(), parametern str1 måste peka på början av denna rad. Vid efterföljande anrop till funktionen som parameter str1 du måste använda en nollpekare. På så sätt delas hela strängen i tokens.

Varje anrop till strtok()-funktionen kan använda en annan uppsättning avgränsare.

Exempel

Det här programmet bryter strängen "Gräset är grönt, solen skiner" till symboler åtskilda av mellanslag och kommatecken. Resultatet blir

Gräset|blir grönt|solen|glittrar #inkludera #omfatta int main(void) ( char *p; p = strtok("Gräset är grönt, solen skiner", " "); printf(p); do ( p = strtok("\0", ", ") ; if(p ) printf("|%s", p); ) while(p); return 0; )

Syntax:

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

Argument:

str – pekare till strängen som ska delas.
sep – pekare till en sträng som innehåller en uppsättning avgränsare.

Returvärde:

NULL – om strängen str inte kan delas upp i delar.
En pekare till det första tecknet i den valda delen av strängen.

Beskrivning:

Strtok-funktionen väljer nästa del av strängen som str-argumentet pekar på, separerad av ett av avgränsningstecknen som anges i strängen som pekas på av sep-argumentet. På varandra följande anrop till strtok-funktionen resulterar i att strängen str delas upp i delar (tokens).

"Det första anropet till strtok-funktionen anger början av strängen som ska delas (str) och början av strängen som innehåller separatorer (sep). Strtok-funktionen börjar med att titta igenom tecknen i strängen str en i taget och leta efter ett tecken som inte finns i den avgränsade strängen sep. Om i strängen str linjeslutstecknet påträffas innan ett tecken som inte ingår i strängen sep hittades, kan strängen str inte delas upp i delar och en nollpekare (NULL) returneras. Om ett sådant tecken hittas, anses det vara början på den första delen av strängen str."

Därefter letar strtok-funktionen efter separatorn, det vill säga tecknet som ingår i strängen sep. Om ett sådant tecken inte hittas, anses strängen str bestå av en del och efterföljande uppdelningar av strängen str kommer att returnera en nollpekare. Om en sådan symbol hittas. då ersätts det med ett nolltecken (radsluttecken). Därefter kommer strtok-funktionen ihåg den aktuella positionen (en pekare till tecknet från vilket sökningen efter nästa del av strängen kommer att börja) och returnerar en pekare till början av den först valda delen av strängen.

Om strtok-funktionen returnerade en icke-null-pekare, kan du fortsätta dela strängen str i bitar. För att fortsätta dela strängen anropas strtok-funktionen igen, men istället för en pekare till strängen som ska delas anges NULL som första augment. I det här fallet kommer strtok-funktionen att fortsätta dela från den minnesvärda adressen. Partitioneringsalgoritmen förblir densamma.

Exempel:

I exemplet är strängen "test1/test2/test3/test4" uppdelad i delar med hjälp av "/"-avgränsaren med strtok-funktionen. Resultatet av uppdelningen matas ut till konsolen.

Resultat:

Konsolutgång:

Populär i kategorin: