Habra, hallo!
Nog niet zo lang geleden overkwam mij een nogal interessant incident, waarbij een van de docenten van een computerwetenschappenschool betrokken was.
Het gesprek over Linux-programmering ging langzaam over in de richting van deze persoon die betoogde dat de complexiteit van systeemprogrammering eigenlijk enorm overdreven was. Dat de C-taal zo simpel is als een lucifer, in feite net als de Linux-kernel (in zijn woorden).
Ik had een laptop met Linux bij me, die een herenset hulpprogramma's bevatte voor ontwikkeling in de C-taal (gcc, vim, make, valgrind, gdb). Ik weet niet meer welk doel we onszelf toen hadden gesteld, maar na een paar minuten zat mijn tegenstander achter deze laptop, helemaal klaar om het probleem op te lossen.
En letterlijk op de allereerste regels maakte hij een ernstige fout bij het toewijzen van geheugen aan... een regel.
Char *str = (char *)malloc(groottevan(char) * strlen(buffer));
buffer - een stapelvariabele waarin gegevens van het toetsenbord zijn geschreven.
Ik denk dat er zeker mensen zullen zijn die zullen vragen: “Hoe kan hier iets mis mee zijn?”
Geloof me, dat kan.
En wat precies - lees over de kat.
Een beetje theorie - een soort LikBez.
Als u het weet, bladert u naar de volgende kop.Een string in C is een array van karakters, die altijd moet eindigen met een "\0" - het teken aan het einde van de regel. Tekenreeksen op de stapel (statisch) worden als volgt gedeclareerd:
Char str[n] = ( 0 );
n is de grootte van de karakterarray, hetzelfde als de lengte van de string.
Toewijzing ( 0 ) - de string op nul zetten (optioneel, u kunt deze zonder deze declareren). Het resultaat is hetzelfde als het uitvoeren van de functies memset(str, 0, sizeof(str)) en bzero(str, sizeof(str)). Het wordt gebruikt om te voorkomen dat er rommel achterblijft in niet-geïnitialiseerde variabelen.
Je kunt ook onmiddellijk een string op de stapel initialiseren:
Char buf = "standaard buffertekst\n";
Bovendien kan een string als pointer worden gedeclareerd en kan er geheugen voor worden toegewezen op de heap:
Char *str = malloc(grootte);
size - het aantal bytes dat we toewijzen aan de string. Dergelijke strings worden dynamisch genoemd (vanwege het feit dat de vereiste grootte dynamisch wordt berekend + de toegewezen geheugengrootte op elk moment kan worden vergroot met behulp van de realloc() functie).
In het geval van een stapelvariabele gebruikte ik de notatie n om de grootte van de array te bepalen; in het geval van een heapvariabele gebruikte ik de notatiegrootte. En dit weerspiegelt perfect de ware essentie van het verschil tussen een declaratie op de stapel en een declaratie met geheugentoewijzing op de heap, omdat n meestal wordt gebruikt als het over het aantal elementen gaat. En grootte is een heel ander verhaal...
Valgrind zal ons helpen
In mijn vorige artikel noemde ik het ook. Valgrind (, twee - een kleine how-to) is een zeer nuttig programma dat de programmeur helpt geheugenlekken en contextfouten op te sporen - precies de dingen die het vaakst opduiken bij het werken met strings.Laten we eens kijken naar een korte lijst die iets implementeert dat lijkt op het programma dat ik noemde en het door valgrind laten lopen:
#erbij betrekken
En in feite het resultaat van het programma:
$ gcc main.c $ ./a.out -> Hallo, Habr!
Nog niets ongewoons. Laten we dit programma nu uitvoeren met valgrind!
$ valgrind --tool=memcheck ./a.out ==3892== Memcheck, een geheugenfoutdetector ==3892== Copyright (C) 2002-2015, en GNU GPL"d, door Julian Seward et al. == 3892== Valgrind-3.12.0 en LibVEX gebruiken; opnieuw uitvoeren met -h voor copyright-info ==3892== Commando: ./a.out ==3892== ==3892== Ongeldig schrijven van grootte 2 ==3892= = bij 0x4005B4: main (in /home/indever/prg/C/public/a.out) ==3892== Adres 0x520004c is 12 bytes binnen een blok van grootte 13 alloc"d ==3892== bij 0x4C2DB9D: malloc (vg_replace_malloc.c:299) ==3892== door 0x400597: main (in /home/indever/prg/C/public/a.out) ==3892== ==3892== Ongeldige lezing van maat 1 == 3892== bij 0x4C30BC4: strlen (vg_replace_strmem.c:454) ==3892== door 0x4E89AD0: vfprintf (in /usr/lib64/libc-2.24.so) ==3892== door 0x4E90718: printf (in /usr/ lib64/libc-2.24.so) ==3892== door 0x4005CF: main (in /home/indever/prg/C/public/a.out) ==3892== Adres 0x520004d is 0 bytes na een blok van grootte 13 alloc"d ==3892== bij 0x4C2DB9D: malloc (vg_replace_malloc.c:299) ==3892== door 0x400597: main (in /home/indever/prg/C/public/a.out) ==3892== -> Hallo, Habr! ==3892== ==3892== HEAP SAMENVATTING: ==3892== in gebruik bij afsluiten: 0 bytes in 0 blokken ==3892== totaal heapgebruik: 2 allocs, 2 frees, 1.037 bytes toegewezen ==3892= = ==3892== Alle heap-blokken zijn vrijgegeven - er zijn geen lekken mogelijk ==3892== ==3892== Voor tellingen van gedetecteerde en onderdrukte fouten, herhaalt u met: -v ==3892== FOUTSAMENVATTING: 3 fouten uit 2 contexten (onderdrukt: 0 uit 0)
==3892== Alle heap-blokken zijn vrijgegeven - er zijn geen lekken mogelijk- er zijn geen lekken, en dat is goed nieuws. Maar het is de moeite waard om je ogen wat lager te richten (hoewel ik wil opmerken dat dit slechts een samenvatting is, de belangrijkste informatie staat op een iets andere plaats):
==3892== FOUTSAMENVATTING: 3 fouten uit 2 contexten (onderdrukt: 0 uit 0)
3 fouten. In 2 contexten. In zo'n eenvoudig programma. Hoe!?
Ja, heel simpel. Het hele “grappige” is dat de strlen-functie geen rekening houdt met het teken aan het einde van de regel - “\0”. Zelfs als u dit expliciet opgeeft in de binnenkomende regel (#define HELLO_STRING “Hallo, Habr!\n\0”), zal het worden genegeerd.
Net boven het resultaat van de programma-uitvoering, de lijn -> Hallo, Habr! er is een gedetailleerd rapport van wat en waar onze dierbare valgrind niet leuk vond. Ik stel voor dat u zelf naar deze lijnen kijkt en uw eigen conclusies trekt.
Eigenlijk zal de juiste versie van het programma er als volgt uitzien:
#erbij betrekken
Laten we het door valgrind halen:
$ valgrind --tool=memcheck ./a.out -> Hallo, Habr! ==3435== ==3435== HEAP SAMENVATTING: ==3435== in gebruik bij afsluiten: 0 bytes in 0 blokken ==3435== totaal heapgebruik: 2 allocs, 2 frees, 1.038 bytes toegewezen ==3435= = ==3435== Alle heap-blokken zijn vrijgegeven - er zijn geen lekken mogelijk ==3435== ==3435== Voor tellingen van gedetecteerde en onderdrukte fouten, herhaalt u met: -v ==3435== FOUTSAMENVATTING: 0 fouten vanaf 0 contexten (onderdrukt: 0 vanaf 0)
Geweldig. Er zijn geen fouten, +1 byte toegewezen geheugen heeft het probleem opgelost.
Wat interessant is, is dat in de meeste gevallen zowel het eerste als het tweede programma hetzelfde zullen werken, maar als het geheugen dat was toegewezen aan de regel waarin het eindteken niet paste niet op nul was gezet, dan zou de functie printf() bij het uitvoeren van zo'n regel , zal ook al het afval na deze regel uitvoeren - alles zal worden afgedrukt totdat een teken aan het einde van de regel printf() in de weg staat.
Weet je echter, (strlen(str) + 1) is zo'n oplossing. Wij worden geconfronteerd met 2 problemen:
- Wat als we geheugen moeten toewijzen aan een string die is gegenereerd met bijvoorbeeld s(n)printf(..)? Wij ondersteunen de argumenten niet.
- Verschijning. De variabele declaratieregel ziet er gewoon verschrikkelijk uit. Sommige jongens slagen er ook in om (char *) aan malloc te hechten, alsof ze onder plussen schrijven. In een programma waarin je regelmatig strings moet verwerken, is het logisch om een elegantere oplossing te vinden.
snprintf()
int snprintf(char *str, size_t size, const char *format, ...);- een functie - een uitbreiding van sprintf, die een string opmaakt en naar de pointer schrijft die als eerste argument is doorgegeven. Het verschilt van sprintf() doordat str geen byte schrijft die groter is dan de opgegeven grootte.De functie heeft één interessant kenmerk: het retourneert in ieder geval de grootte van de gegenereerde string (zonder rekening te houden met het teken aan het einde van de regel). Als de string leeg is, wordt 0 geretourneerd.
Een van de problemen die ik heb beschreven bij het gebruik van strlen heeft betrekking op de functies sprintf() en snprintf(). Laten we aannemen dat we iets in de string str moeten schrijven. De laatste regel bevat de waarden van de andere variabelen. Onze inzending zou er ongeveer zo uit moeten zien:
Char * str = /* wijs hier geheugen toe */; sprintf(str, "Hallo, %s\n", "Habr!");
De vraag rijst: hoe bepaal je hoeveel geheugen moet worden toegewezen aan de string str?
Char * str = malloc(groottevan(char) * (strlen(str, "Hallo, %s\n", "Habr!") + 1));
#erbij betrekken
const char *s betekent niet dat de string die wordt doorgegeven aan s een string met variadisch formaat kan zijn.
De nuttige eigenschap van de functie snprintf(), die ik hierboven noemde, zal ons hier helpen. Laten we eens kijken naar de code voor het volgende programma:
#erbij betrekken
Voer het programma uit in Valgrind:
$ valgrind --tool=memcheck ./a.out -> Hallo, Habr! ==4132== ==4132== HEAP SAMENVATTING: ==4132== in gebruik bij afsluiten: 0 bytes in 0 blokken ==4132== totaal heapgebruik: 2 allocs, 2 frees, 1.041 bytes toegewezen ==4132= = ==4132== Alle heap-blokken zijn vrijgegeven - er zijn geen lekken mogelijk ==4132== ==4132== Voor tellingen van gedetecteerde en onderdrukte fouten, herhaalt u met: -v ==4132== FOUTSAMENVATTING: 0 fouten uit 0 contexten (onderdrukt: 0 uit 0) $
Geweldig. Wij hebben argumentatieondersteuning. Omdat we null als tweede argument doorgeven aan de functie snprintf(), zal het schrijven naar een null-pointer nooit een Seagfault veroorzaken. Desondanks retourneert de functie nog steeds de vereiste grootte voor de string.
Maar aan de andere kant moesten we een extra variabele introduceren, en wel het ontwerp
Size_t Needed_mem = snprintf(NULL, 0, "Hallo, %s!\n", "Habr") + sizeof("\0");
ziet er nog slechter uit dan in het geval van strlen().
Over het algemeen kan + sizeof("\0") worden verwijderd als u expliciet "\0" opgeeft aan het einde van de opmaakregel (size_t require_mem = snprintf(NULL, 0, "Hallo, %s!\n \0
", "Habr");), maar dit is lang niet altijd mogelijk (afhankelijk van het stringverwerkingsmechanisme kunnen we een extra byte toewijzen).
We moeten iets doen. Ik dacht een beetje na en besloot dat dit het moment is om een beroep te doen op de wijsheid van de Ouden. Laten we een macrofunctie beschrijven die snprintf() aanroept met een null-aanwijzer als eerste argument, en null als tweede. En laten we het einde van de rij niet vergeten!
#define strsize(args...) snprintf(NULL, 0, args) + sizeof("\0")
Ja, het kan voor sommigen nieuws zijn, maar C-macro's ondersteunen een variabel aantal argumenten, en de ellips vertelt de preprocessor dat het opgegeven macrofunctieargument (in ons geval args) overeenkomt met verschillende echte argumenten.
Laten we onze oplossing in de praktijk bekijken:
#erbij betrekken
Laten we beginnen met valgrund:
$ valgrind --tool=memcheck ./a.out -> Hallo, Habr! ==6432== ==6432== HEAP SAMENVATTING: ==6432== in gebruik bij afsluiten: 0 bytes in 0 blokken ==6432== totaal heapgebruik: 2 allocs, 2 frees, 1.041 bytes toegewezen ==6432= = ==6432== Alle heap-blokken zijn vrijgegeven - er zijn geen lekken mogelijk ==6432== ==6432== Voor tellingen van gedetecteerde en onderdrukte fouten, herhaalt u met: -v ==6432== FOUTSAMENVATTING: 0 fouten vanaf 0 contexten (onderdrukt: 0 vanaf 0)
Ja, er zijn geen fouten. Alles klopt. En valgrind is blij, en de programmeur kan eindelijk gaan slapen.
Maar tot slot wil ik nog één ding zeggen. In het geval dat we geheugen moeten toewijzen aan een string (zelfs met argumenten), is dat al het geval volledig werkende oplossing.
We hebben het over de asprintf-functie:
#define _GNU_SOURCE /* Zie feature_test_macros(7) */ #include
Het neemt een pointer naar een string (**strp) als eerste argument en wijst geheugen toe aan de pointer waarvan de verwijzingen zijn verwijderd.
Ons programma geschreven met asprintf() ziet er als volgt uit:
#erbij betrekken
En in feite, in Valgrind:
$ valgrind --tool=memcheck ./a.out -> Hallo, Habr! ==6674== ==6674== HEAP SAMENVATTING: ==6674== in gebruik bij afsluiten: 0 bytes in 0 blokken ==6674== totaal heapgebruik: 3 allocs, 3 frees, 1.138 bytes toegewezen ==6674= = ==6674== Alle heap-blokken zijn vrijgegeven - er zijn geen lekken mogelijk ==6674== ==6674== Voor tellingen van gedetecteerde en onderdrukte fouten, herhaalt u met: -v ==6674== FOUTSAMENVATTING: 0 fouten vanaf 0 contexten (onderdrukt: 0 vanaf 0)
Alles is in orde, maar zoals je kunt zien, is er meer geheugen toegewezen en zijn er nu drie toewijzingen, niet twee zwakke ingebedde systemen. Het gebruik van deze functie is ongewenst.
Als we bovendien man asprintf in de console schrijven, zullen we het volgende zien:
VOLDOET AAN Deze functies zijn GNU-extensies, niet in C of POSIX. Ze zijn ook beschikbaar onder *BSD. De FreeBSD-implementatie stelt strp bij fouten in op NULL.
Dit maakt duidelijk dat deze functie alleen beschikbaar is in GNU-bronnen.
Conclusie
Concluderend wil ik zeggen dat het werken met strings in C een zeer complex onderwerp is dat een aantal nuances kent. Om bijvoorbeeld “veilige” code te schrijven bij het dynamisch toewijzen van geheugen, wordt het aanbevolen om de functie calloc() te gebruiken in plaats van malloc() - calloc vult het toegewezen geheugen met nullen. Of gebruik na het toewijzen van geheugen de functie memset(). Anders kan de rommel die zich aanvankelijk in het toegewezen geheugengebied bevond, problemen veroorzaken tijdens het debuggen en soms bij het werken met de string.Meer dan de helft van de C-programmeurs die ik ken (de meesten van hen zijn beginners) die op mijn verzoek het probleem van het toewijzen van geheugen voor strings oplosten, deden dit op een manier die uiteindelijk tot contextfouten leidde. In één geval - zelfs met een geheugenlek (nou ja, iemand vergat free(str) te doen, het overkomt nooit iemand). Dit was voor mij de aanleiding om deze creatie te maken die je zojuist hebt gelezen.
Ik hoop dat dit artikel nuttig zal zijn voor iemand. Waarom maak ik al deze ophef? Geen enkel taalgebruik is eenvoudig. Overal heeft zijn eigen subtiliteiten. En hoe ingewikkelder de taal die u kent, hoe beter uw code.
Ik geloof dat na het lezen van dit artikel je code een beetje beter zal worden :)
Veel succes, Habr!
In een programma kunnen strings als volgt worden gedefinieerd:
- als stringconstanten;
- als karakterarrays;
- via een verwijzing naar een tekentype;
- zoals arrays van strings.
Bovendien moet er in geheugentoewijzing worden voorzien om de string op te slaan.
Elke reeks tekens tussen dubbele aanhalingstekens "" wordt behandeld als tekenreeks constante.
Voor correcte uitvoer moet elke string eindigen met het nulteken "\0", waarvan de gehele waarde 0 is. Bij het declareren van een stringconstante wordt er automatisch het null-teken aan toegevoegd. Er wordt dus een reeks tekens, die een stringconstante is, in het RAM van de computer geplaatst, inclusief de nulbyte.
Opeenvolgende RAM-cellen worden toegewezen voor het opslaan van de string. Een string is dus een array van karakters. Er wordt 1 byte toegewezen om de code van elk teken in de string op te slaan.
Om sommige servicetekens in een stringconstante te plaatsen, worden tekencombinaties gebruikt. Als u dus een dubbel aanhalingsteken in een string moet opnemen, moet dit worden voorafgegaan door een backslash-teken: ‘\”‘ .
String-constanten bevinden zich in het statisch geheugen. Het startadres van een reeks tekens tussen dubbele aanhalingstekens wordt behandeld als het adres van een string. Tekenreeksconstanten worden vaak gebruikt om gebruikersinteractie te bieden in functies zoals printf().
Bij het bepalen karakterreeks u moet de compiler de vereiste geheugengrootte vertellen.
teken m;
De compiler kan ook onafhankelijk de grootte van een karakterarray bepalen als de initialisatie van de array wordt gespecificeerd wanneer deze wordt gedeclareerd als een stringconstante:
teken m2=;
teken m3=( "T", "i", "x", "i", "e", ", "d", "o", "l", "i", "n", "s", ", "p ", "o", "l", "n", "y", ", "s", "v", "e", "zh", "e", "y", ", "m", "g", "l", "o", "y", "\0"};
In dit geval verwijzen de namen m2 en m3 naar de eerste elementen van de arrays:
- m2 is gelijk aan &m2
- m2 is gelijk aan 'G'
- m2 is gelijk aan 'o'
- m3 is gelijk aan &m3
- m3 is gelijk aan 'x'
Wanneer u een karakterarray declareert en deze initialiseert met een stringconstante, kunt u expliciet de grootte van de array opgeven, maar de opgegeven arraygrootte moet groter zijn dan de grootte van de initialiserende stringconstante:
teken m2= "De bergtoppen slapen in de duisternis van de nacht.";
Om een string in te stellen die u kunt gebruiken verwijzing naar tekentype.
teken *m4;
In dit geval kan bij het declareren van een array de variabele m4 het adres van de array worden toegewezen:
m4 = m3;
*m4 komt overeen met m3 = "T"
*(m4+1) is gelijk aan m3=‘en’
Hier is m3 een richtconstante. Je kunt m3 niet wijzigen, omdat dit zou betekenen dat de locatie (adres) van de array in het geheugen verandert, in tegenstelling tot m4.
Voor een aanwijzer kunt u de ophogingsbewerking gebruiken (naar het volgende teken gaan):
Arrays van tekenreeksen
Soms hebben programma's een beschrijving nodig reeks tekenreeksen. In dit geval kunt u de rijindex gebruiken om toegang te krijgen tot meerdere verschillende rijen.
char *dichter = ( "De dichter is overleden!", "- een slaaf van eer -",
"Gevallen", "lasterd door geruchten..."};
In dit geval is poet een array bestaande uit vier verwijzingen naar tekenreeksen. Elke tekenreeks is een tekenarray, dus er zijn vier array-pointers. De dichterwijzer verwijst naar de eerste regel:
*dichter equivalent "P",
*dichter[l] equivalent "-"
.
Initialisatie wordt uitgevoerd volgens de regels die voor arrays zijn gedefinieerd.
Geciteerde teksten zijn gelijk aan het initialiseren van elke string in de array. Een komma scheidt aangrenzende
sequenties.
Je kunt de grootte van tekenreeksen ook expliciet instellen met behulp van een beschrijving als deze:
char dichter;
Het verschil is dat deze vorm een "rechthoekige" array definieert waarin alle rijen dezelfde lengte hebben.
Gratis array
Beschrijving
char *dichter;
definieert een vrije array, waarbij de lengte van elke lijn wordt bepaald door de aanwijzer die deze lijn initialiseert. Een vrije array verspilt geen geheugen.
String-bewerkingen
De meeste C-bewerkingen die met strings te maken hebben, werken met pointers. Om een reeks tekens in het RAM-geheugen te plaatsen, moet u:
- wijs een RAM-blok toe voor de array;
- initialiseer de tekenreeks.
Om geheugen toe te wijzen voor het opslaan van een string, kunnen dynamische geheugentoewijzingsfuncties worden gebruikt. In dit geval moet rekening worden gehouden met de vereiste lijngrootte:
teken *naam;
naam = (char *)malloc(10);
scanf("%9s", naam);
De functie scanf() wordt gebruikt om een string in te voeren, en de ingevoerde string mag niet langer zijn dan 9 tekens. Het laatste teken bevat "\0" .
String-invoerfuncties
De functie scanf() kan worden gebruikt om een string in te voeren. Scanf() is echter ontworpen om een woord op te halen in plaats van een tekenreeks. Als u het "%s"-formaat voor invoer gebruikt, wordt de regel ingevoerd vóór (maar niet inclusief) het volgende lege teken, dat een spatie, tab of nieuwe regel kan zijn.
Gebruik de functie om een tekenreeks, inclusief spaties, in te voeren
char * krijgt(char *);
of het equivalent daarvan
char * krijgt_s(char *);
Een pointer naar de in te voeren string wordt als argument aan de functie doorgegeven. De functie vraagt de gebruiker om een string in te voeren, die in een array wordt geplaatst totdat de gebruiker op drukt Binnenkomen.
String-uitvoerfuncties
Om strings uit te voeren, kunt u de eerder besproken functie gebruiken
printf("%s" , str); // str - verwijzing naar tekenreeks
of in verkort formaat
printf(str);
De functie kan ook worden gebruikt om tekenreeksen uit te voeren
int zet (char *s);
die de string s afdrukt en de cursor naar een nieuwe regel verplaatst (in tegenstelling tot printf() ). De functie puts() kan ook worden gebruikt om tekenreeksconstanten tussen aanhalingstekens uit te voeren.
Karakterinvoerfunctie
De functie kan worden gebruikt om tekens in te voeren
char getchar();
die de waarde retourneert van het teken dat via het toetsenbord is ingevoerd. Deze functie werd in de eerder besproken voorbeelden gebruikt om het consolevenster te vertragen nadat het programma was uitgevoerd totdat er op een toets werd gedrukt.
Karakteruitvoerfunctie
De functie kan worden gebruikt om tekens uit te voeren
char putchar(char);
die de waarde retourneert van het af te drukken teken en het teken dat als argument naar het scherm wordt doorgegeven, afdrukt.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
#erbij betrekken
#erbij betrekken
#erbij betrekken
int hoofd() (
teken s, sym;
int telling, ik;
systeem("chcp 1251" );
systeem("cls" );
printf( "Voer de tekenreeks in: ");
krijgt_s(s);
printf( "Voer teken in: ");
sym = getchar();
aantal = 0;
voor (i = 0; s[i] != "\0" ; i++)
{
als (s[i] == sym)
tellen++;
}
printf("In regel\n" );
zet(en); // Voer een tekenreeks uit
printf("karakter ");
putchar(sym); // Voer het symbool uit
printf( "komt %d keer voor", graaf);
getchar(); getchar();
retour 0;
}
Uitvoering resultaat 
Belangrijkste functies van de standaardbibliotheek string.h
De belangrijkste functies van de standaardbibliotheek string.h worden in de tabel gegeven.
| Functie | Beschrijving |
|
teken *strcat(teken *s1, teken *s2) |
voegt s2 toe aan s1 en geeft s1 terug |
|
char *strncat(char *s1, char *s2, int n) |
voegt maximaal n tekens s2 tot en met s1 toe, beëindigt de tekenreeks met "\0", retourneert s1 |
|
char *strсpy(char *s1, char *s2) |
kopieert tekenreeks s2 naar tekenreeks s1, inclusief "\0", retourneert s1 |
| ); strncpy(m3, m1, 6); // voegt geen "\0" toe aan het einde van de regel zet( "Resultaatstrncpy(m3, m1, 6)"); zet(m3); strcpy(m3, m1); zet( "Resultaat strcpy(m3, m1)"); zet(m3); zet( "Het resultaat van strcmp(m3, m1) is"); printf("%d" , strcmp(m3, m1)); strncat(m3, m2, 5); zet( "Resultaat strncat(m3, m2, 5)"); zet(m3); strcat(m3, m2); zet( "Resultaatstrcat(m3, m2)"); zet(m3); zet( "Het aantal tekens in string m1 is strlen(m1) : "); printf("%d\n" , strlen(m1)); _strnset(m3, "f", 7); zet( "Resultaatreeks(m3, "f", 7)"); zet(m3); _strset(m3, "k" ); zet( "Resultaatreeks(m3, "k" )"); zet(m3); getchar(); retour 0; } Uitvoering resultaat |
Schort AdBlock op deze site op.
Dus strings in C-taal. Er is geen apart datatype voor, zoals in veel andere programmeertalen wel het geval is. In C is een string een array van karakters. Om het einde van een regel te markeren, wordt het teken "\0" gebruikt, wat we in het laatste deel van deze les hebben besproken. Het wordt op geen enkele manier op het scherm weergegeven, dus u kunt er niet naar kijken.
Een string maken en initialiseren
Omdat een string een array van tekens is, is het declareren en initialiseren van een string vergelijkbaar met soortgelijke bewerkingen met eendimensionale arrays.
De volgende code illustreert de verschillende manieren om tekenreeksen te initialiseren.
Lijst 1.
Tekenstr;
char str1 = ("Y", "o", "n", "g", "C", "o", "d", "e", "r", "\0");
char str2 = "Hallo!";
char str3 = "Hallo!";
De derde regel is analoog aan de tweede regel. Let op de afbeelding. Omdat Er staan minder tekens in de regel aan de rechterkant dan er elementen in de array zijn, de overige elementen worden gevuld met \0 .
Vierde lijn. Zoals u kunt zien, staat hier geen maat vermeld. Het programma berekent dit automatisch en maakt een reeks tekens van de vereiste lengte. In dit geval wordt het nulteken \0 als laatste ingevoegd.
Hoe een string uit te voeren
Laten we de bovenstaande code uitbreiden tot een volwaardig programma dat de gemaakte regels op het scherm weergeeft.
Lijst 2.
#erbij betrekken
Fig.2 Verschillende manieren om een string op het scherm weer te geven
Zoals u kunt zien, zijn er verschillende basismanieren om een string op het scherm weer te geven.
- gebruik de printf-functie met de %s-specificatie
- gebruik de puts-functie
- gebruik de fputs-functie, waarbij u de standaardstream voor uitvoer opgeeft als stdout als tweede parameter.
De enige nuance betreft de puts- en fputs-functies. Merk op dat de puts-functie de uitvoer naar de volgende regel doorloopt, maar de fputs-functie niet.
Zoals u kunt zien, is de conclusie vrij eenvoudig.
Tekenreeksen invoeren
Stringinvoer is iets ingewikkelder dan uitvoer. De eenvoudigste manier zou de volgende zijn:
Lijst 3.
#erbij betrekken
De functie get pauzeert het programma, leest een reeks tekens die via het toetsenbord zijn ingevoerd en plaatst deze in een tekenarray, waarvan de naam als parameter aan de functie wordt doorgegeven.
De functie get wordt afgesloten met het teken dat overeenkomt met de enter-toets en als een nulteken naar de string geschreven.
Heeft u het gevaar opgemerkt? Als dit niet het geval is, zal de compiler u vriendelijk hiervoor waarschuwen. Het probleem is dat de Get-functie alleen wordt afgesloten als de gebruiker op Enter drukt. Dit is beladen met het feit dat we in ons geval verder kunnen gaan dan de array - als er meer dan 20 tekens worden ingevoerd.
Overigens werden bufferoverflow-fouten voorheen beschouwd als het meest voorkomende type kwetsbaarheid. Ze bestaan nog steeds, maar het gebruik ervan om programma's te hacken is veel moeilijker geworden.
Dus wat hebben we? We hebben een taak: schrijf een string naar een array van beperkte grootte. Dat wil zeggen dat we op de een of andere manier het aantal tekens moeten controleren dat door de gebruiker wordt ingevoerd. En hier komt de fgets-functie ons te hulp:
Lijst 4.
#erbij betrekken
De fgets-functie heeft drie argumenten als invoer: de variabele waarnaar de string moet worden geschreven, de grootte van de string die moet worden geschreven en de naam van de stream waaruit de gegevens moeten worden opgehaald om naar de string te schrijven, in dit geval stdin. Zoals je al weet uit les 3, is stdin de standaardinvoerstroom die gewoonlijk met het toetsenbord wordt geassocieerd. Het is helemaal niet nodig dat de data uit de stdin-stream moeten komen; in de toekomst zullen we deze functie ook gebruiken om data uit bestanden te lezen.
Als we tijdens de uitvoering van dit programma een string invoeren die langer is dan 10 tekens, slechts 9 tekens vanaf het begin en er wordt nog steeds een regeleinde naar de array geschreven, zullen fgets de string op de gewenste lengte "knippen".
Houd er rekening mee dat de fgets-functie geen 10 tekens leest, maar 9! Zoals we ons herinneren, is in strings het laatste teken gereserveerd voor het nulteken.
Laten we het eens bekijken. Laten we het programma uitvoeren vanaf de laatste lijst. En voer de regel 1234567890 in. De regel 123456789 wordt op het scherm weergegeven.
Fig. 3 Voorbeeld van de fgets-functie
Er rijst een vraag. Waar is het tiende personage gebleven? En ik zal antwoorden. Het is niet verdwenen, het blijft in de inputstroom. Voer het volgende programma uit.
Lijst 5.
#erbij betrekken
Hier is het resultaat van haar werk.
Fig.4 Niet-lege stdin-buffer
Laat me uitleggen wat er is gebeurd. We hebben de fgets-functie genoemd. Ze opende de invoerstroom en wachtte tot wij de gegevens hadden ingevoerd. We hebben 1234567890\n ingevoerd via het toetsenbord (\n ik bedoel door op de Enter-toets te drukken). Dit ging naar de stdin-invoerstroom. De fgets-functie nam, zoals verwacht, de eerste 9 tekens 123456789 uit de invoerstroom, voegde het nulteken \0 eraan toe en schreef het naar de string str . Er zijn nog 0\n over in de invoerstroom.
Vervolgens declareren we de variabele h. We tonen de waarde ervan op het scherm. Vervolgens roepen we de scanf-functie aan. Hier wordt verwacht dat we iets kunnen invoeren, maar... er hangt 0\n in de invoerstroom, dan neemt de scanf-functie dit waar als onze invoer en schrijft 0 naar de variabele h. Vervolgens geven we het weer op het scherm.
Dit is uiteraard niet precies het gedrag dat we verwachten. Om dit probleem op te lossen, moeten we de invoerbuffer leegmaken nadat we de invoer van de gebruiker daaruit hebben gelezen. Hiervoor wordt een speciale functie Spoelen gebruikt. Het heeft slechts één parameter: de stream die moet worden gewist.
Laten we het laatste voorbeeld aanpassen, zodat de werking ervan voorspelbaar is.
Lijst 6.
#erbij betrekken
Nu werkt het programma zoals het hoort.
Fig.4 De stdin-buffer leegmaken met de fflush-functie
Samenvattend kunnen twee feiten worden opgemerkt. Eerst. Momenteel is de functie gets onveilig om te gebruiken, dus het wordt aanbevolen om de functie fgets overal te gebruiken.
Seconde. Vergeet niet de invoerbuffer leeg te maken als u de fgets-functie gebruikt.
Hiermee is het gesprek over het invoeren van tekenreeksen afgerond. Laten we verder gaan.
Laatst bijgewerkt: 31-10-2015
Aaneenschakeling
String-aaneenschakeling of unie kan worden gedaan met behulp van de + operator of de Concat-methode:
Tekenreeks s1 = "hallo"; tekenreeks s2 = "wereld"; tekenreeks s3 = s1 + " " + s2; // resultaat: string "hallo wereld" string s4 = String.Concat(s3, "!!!"); // resultaat: de string "Hallo wereld!!!" Console.WriteLine(s4);
De Concat-methode is een statische methode van de klasse String die twee strings als parameters gebruikt. Er zijn ook andere versies van de methode die een ander aantal parameters gebruiken.
De Join-methode kan ook worden gebruikt om strings samen te voegen:
Tekenreeks s5 = "appel"; tekenreeks s6 = "een dag"; tekenreeks s7 = "behoudt"; string s8 = "een dokter"; tekenreeks s9 = "weg"; tekenreekswaarden = nieuwe tekenreeks ( s5, s6, s7, s8, s9 ); Tekenreeks s10 = String.Join(" ", waarden); // resultaat: de string "appel per dag houdt een dokter weg"
De Join-methode is ook statisch. De hierboven gebruikte versie van de methode heeft twee parameters: een scheidingstekenreeks (in dit geval een spatie) en een array van tekenreeksen die door het scheidingsteken worden samengevoegd en gescheiden.
Snaarvergelijking
Gebruik de statische vergelijkingsmethode om tekenreeksen te vergelijken:
Tekenreeks s1 = "hallo"; tekenreeks s2 = "wereld"; int resultaat = String.Vergelijk(s1, s2); als (resultaat<0) { Console.WriteLine("Строка s1 перед строкой s2"); } else if (result >0) ( Console.WriteLine("Lijn s1 komt na regel s2"); ) else ( Console.WriteLine("Lijnen s1 en s2 zijn identiek"); ) // het resultaat is "Lijn s1 vóór regel s2"
Deze versie van de Compare-methode gebruikt twee tekenreeksen en retourneert een getal. Als de eerste tekenreeks alfabetisch hoger is dan de tweede, wordt een getal kleiner dan nul geretourneerd. Anders wordt een getal groter dan nul geretourneerd. En het derde geval: als de strings gelijk zijn, wordt het getal 0 geretourneerd.
In dit geval zal de eerste regel hoger zijn, aangezien het teken h alfabetisch hoger is dan het teken w.
Zoek in een tekenreeks
Met behulp van de IndexOf-methode kunnen we de index bepalen van de eerste keer dat een enkel teken of subtekenreeks in een tekenreeks voorkomt:
Tekenreeks s1 = "hallo wereld"; char ch = "o"; int indexOfChar = s1.IndexOf(ch); // gelijk aan 4 Console.WriteLine(indexOfChar); string subString = "wor"; int indexOfSubstring = s1.IndexOf(subString); // gelijk aan 6 Console.WriteLine(indexOfSubstring);
De LastIndexOf-methode werkt op een vergelijkbare manier, behalve dat deze de index vindt van de laatste keer dat een teken of subtekenreeks in een tekenreeks voorkomt.
Met een andere groep methoden kunt u achterhalen of een tekenreeks begint of eindigt met een specifieke subtekenreeks. Hiervoor zijn de methoden StartsWith en EndsWith ontworpen. We hebben bijvoorbeeld de taak om alle bestanden met de extensie .exe uit een map te verwijderen:
Tekenreekspad = @"C:\SomeDir"; tekenreeksbestanden = Directory.GetFiles(pad); voor (int i = 0; ik< files.Length; i++) { if(files[i].EndsWith(".exe")) File.Delete(files[i]); }
Het splitsen van snaren
Met de functie Splitsen kunnen we een string opsplitsen in een array van substrings. De Split-functie neemt een array van tekens of tekenreeksen als parameter, die als scheidingstekens zullen dienen. Laten we bijvoorbeeld het aantal woorden in een term tellen door deze te delen door witruimte:
String text = "En daarom gebeurde het allemaal"; stringwoorden = tekst.Split(nieuw teken (" ")); foreach (string s in woorden) ( Console.WriteLine(s); )
Dit is niet de beste manier om op spaties te splitsen, omdat we meerdere opeenvolgende spaties in de invoertekenreeks kunnen hebben en de resulterende array ook spaties zou bevatten. Het is dus beter om een andere versie van de methode te gebruiken:
Tekenreekswoorden = text.Split(new char (" "), StringSplitOptions.RemoveEmptyEntries);
De tweede parameter StringSplitOptions.RemoveEmptyEntries zegt dat alle lege substrings moeten worden verwijderd.
Een lijn afsnijden
Gebruik de Trim-functie om voorloop- of volgtekens bij te snijden:
String tekst = "hallo wereld"; tekst = tekst.Trim(); // resultaat "hallo wereld" tekst = tekst.Trim(nieuwe char ("d", "h" )); // resultaat "ello wereld"
De Trim-functie trimt, zonder parameters, voorloop- en volgspaties en retourneert de bijgesneden tekenreeks. Om expliciet te specificeren welke voor- en natekens moeten worden bijgesneden, kunnen we een array van die tekens aan de functie doorgeven.
Deze functie heeft gedeeltelijke analogen: de TrimStart-functie snijdt de begintekens af, en de TrimEnd-functie snijdt de eindtekens af.
Met de functie Substring kunt u een specifiek deel van een string inkorten:
String text = "Goedendag"; // afgesneden vanaf het derde teken tekst = text.Substring(2); // resultaat "goede dag" Console.WriteLine(text); // knip eerst tot de laatste twee tekens tekst = text.Substring(0, text.Length - 2); // resultaat "roshy de" Console.WriteLine(tekst);
De functie Substring retourneert ook de afgeknotte tekenreeks. De eerste gebruikte versie gebruikt de index als parameter, vanaf waar de string moet worden ingekort. De tweede versie gebruikt twee parameters: de trimstartindex en de lengte van het afgesneden deel van de string.
Invoegen
Om de ene rij in de andere in te voegen, gebruikt u de functie Invoegen:
String text = "Goedendag"; string subString = "geweldig"; tekst = tekst.Insert(8, subString); Console.WriteLine(tekst);
De eerste parameter in de functie Insert is de index waarin de subtekenreeks moet worden ingevoegd, en de tweede parameter is de subtekenreeks zelf.
Rijen verwijderen
De Remove-methode helpt bij het verwijderen van een deel van een string:
String text = "Goedendag"; // index van het laatste teken int ind = text.Length - 1; // knip het laatste teken uit tekst = text.Remove(ind); Console.WriteLine(tekst); // knip de eerste twee tekens uit tekst = text.Remove(0, 2);
De eerste versie van de Remove-methode neemt een index in de string, vanaf waar alle tekens moeten worden verwijderd. De tweede versie heeft nog een parameter nodig: hoeveel tekens moeten worden verwijderd.
Vervanging
Om een teken of subtekenreeks door een ander te vervangen, gebruikt u de Replace-methode:
Tekenreekstekst = "goede dag"; tekst = tekst.Replace("goed", "slecht"); Console.WriteLine(tekst); tekst = tekst.Replace("o", ""); Console.WriteLine(tekst);
In het tweede geval waarbij de functie Vervangen wordt gebruikt, wordt een reeks van één "o"-teken vervangen door een lege reeks, dat wil zeggen dat deze feitelijk uit de tekst wordt verwijderd. Met deze methode kunt u eenvoudig specifieke tekst in regels verwijderen.
Verander zaak
Om een tekenreeks naar hoofdletters en kleine letters te converteren, gebruikt u respectievelijk de functies ToUpper() en ToLower():
String hallo = "Hallo wereld!"; Console.WriteLine(hallo.ToLower()); // Hallo wereld! Console.WriteLine(hallo.ToUpper()); // HALLO WERELD!
De moderne C++-standaard definieert een klasse met functies en eigenschappen (variabelen) voor het organiseren van werk met strings (in de klassieke C-taal zijn er geen strings als zodanig, er zijn alleen arrays van char-tekens):
#erbij betrekken
#erbij betrekken#erbij betrekken
Om met strings te werken, moet je ook een standaard naamruimte koppelen:
Naamruimte std gebruiken;
Anders moet u overal de klassedescriptor std::string opgeven in plaats van string .
Hieronder staat een voorbeeld van een programma dat met string werkt (werkt niet in oudere C-compatibele compilers!):
#erbij betrekken
c_str();
- initialisatie met een karakterarray (een ingebouwd stringtype) of een ander object van het type string . Een ingebouwd type heeft de tweede mogelijkheid niet;
- kopiëren van de ene regel naar de andere. Voor een ingebouwd type moet je de strcpy() functie gebruiken;
- toegang tot individuele karakters van een string voor lezen en schrijven. In een ingebouwde array gebeurt dit met behulp van een indexbewerking of indirecte adressering met behulp van een pointer;
- twee strings vergelijken op gelijkheid. Voor een ingebouwd type worden de functies van de strcmp()-familie gebruikt;
- aaneenschakeling (aaneenschakeling) van twee strings, waardoor het resultaat ontstaat als een derde string of in plaats van een van de originele. Voor een ingebouwd type wordt de functie strcat() gebruikt, maar om het resultaat op een nieuwe regel te krijgen, moet je de functies strcpy() en strcat() opeenvolgend gebruiken, en ook zorgen voor de geheugentoewijzing;
- ingebouwde manier om de lengte van een string te bepalen (klasselidfuncties size() en lengte()). De enige manier om de lengte van een ingebouwde typestring te achterhalen is door deze te berekenen met de functie strlen();
- mogelijkheid om erachter te komen of een string leeg is.
Laten we deze basisfuncties in meer detail bekijken.
Strings initialiseren bij het beschrijven en snaar lengte(exclusief de afsluitende null-terminator):
String st("Mijn string\n"); uit<< "Длина " << st << ": " << st.size() << " символов, включая символ новой строки\n";
De string kan ook leeg zijn:
String st2;
Om dat te controleren is de regel leeg, je kunt de lengte ervan vergelijken met 0:
Als (! st.size()) // leeg
of gebruik de empty() methode, die true retourneert voor een lege string en false voor een niet-lege string:
Als (st.empty()) // leeg
De derde vorm van het maken van tekenreeksen initialiseert een object van het type string met een ander object van hetzelfde type:
Tekenreeks st3(st);
De string st3 wordt geïnitialiseerd met de string st. Hoe kunnen we ervoor zorgen dat deze de lijnen komen overeen? Laten we de vergelijkingsoperator (==) gebruiken:
If (st == st3) // initialisatie werkte
Hoe kopieer de ene regel naar de andere? Met behulp van de normale toewijzingsoperator:
St2 = st3; // kopieer st3 naar st2
Voor aaneenschakeling van tekenreeksen de optellingsoperator (+) of de optelling plus toewijzingsoperator (+=) wordt gebruikt. Laten we twee regels geven:
Tekenreeks s1("hallo, "); string s2("wereld\n");
We kunnen op deze manier een derde string krijgen die bestaat uit een aaneenschakeling van de eerste twee:
Tekenreeks s3 = s1 + s2;
Als we s2 aan het einde van s1 willen toevoegen, moeten we schrijven:
S1 += s2;
De optelbewerking kan klasseobjecten aaneenschakelen snaar niet alleen onderling, maar ook met ingebouwde typestrings. U kunt het bovenstaande voorbeeld herschrijven, zodat speciale tekens en leestekens worden weergegeven door het ingebouwde type char *, en significante woorden worden weergegeven door objecten van de klassereeks:
Const char *pc = ", "; tekenreeks s1("hallo"); string s2("wereld"); tekenreeks s3 = s1 + pc + s2 + "\n"; uit<< endl << s3;
Dergelijke expressies werken omdat de compiler "weet" hoe hij automatisch objecten van het ingebouwde type moet converteren naar objecten van de stringklasse. Het is ook mogelijk om eenvoudig een ingebouwde string aan een stringobject toe te wijzen:
Tekenreeks s1; const char *pc = "een tekenarray"; s1 = pc; // juist
In dit geval de omgekeerde transformatie werkt niet. Als u probeert de volgende ingebouwde tekenreeks-initialisatie uit te voeren, zal dit een compilatiefout veroorzaken:
Char *str = s1; // compilatiefout
Om deze conversie uit te voeren, moet u expliciet een lidfunctie aanroepen met de naam c_str() ("C string"):
Const char *str = s1.c_str();
De functie c_str() retourneert een pointer naar een karakterarray die de string van het stringobject bevat, zoals deze zou verschijnen in het ingebouwde stringtype. Het const trefwoord verhindert hier de "gevaarlijke" mogelijkheid in moderne visuele omgevingen om de inhoud van een object rechtstreeks via een aanwijzer te wijzigen.
NAAR individuele karakters een object van het type string , zoals een ingebouwd type, is toegankelijk via de indexbewerking. Hier is bijvoorbeeld een stukje code dat alle punten vervangt door onderstrepingstekens:
String str("www.disney.com"); int grootte = str.grootte(); voor (int i = 0; ik< size; i++) if (str[i] == ".") str[ i ] = "_"; cout << str;
Vervang(str.begin(), str.end(), ".", "_");
Het is waar dat hier niet de vervangingsmethode van de stringklasse wordt gebruikt, maar het gelijknamige algoritme:
#erbij betrekken
Omdat het stringobject zich als een container gedraagt, kunnen er andere algoritmen op worden toegepast. Hiermee kunt u problemen oplossen die niet direct worden opgelost door de functies van de stringklasse.
Hieronder vindt u een korte beschrijving van de belangrijkste operators en functies van de stringklasse. Links in de tabel leiden naar Russischtalige beschrijvingen op internet. Een completere lijst van de mogelijkheden van de stringklasse is bijvoorbeeld te vinden op Wikipedia of op de website cplusplus.com.
|
Tekens in een string opgeven |
|
|
exploitant= |
wijst waarden toe aan een string |
|
toewijzen |
wijst tekens toe aan een string |
|
Toegang tot individuele karakters |
|
|
bij |
het opgegeven teken ophalen en controleren of de index buiten bereik is |
|
exploitant |
het opgegeven teken verkrijgen |
|
voorkant |
het eerste teken krijgen |
|
rug |
het laatste teken krijgen |
|
gegevens |
retourneert een pointer naar het eerste teken van de string |
|
c_str |
retourneert onveranderbaar een C-karakterarray die de karakters van de string bevat |
|
Lijncapaciteitscontrole |
|
|
leeg |
controleert of een string leeg is |
|
maat |
retourneert het aantal tekens in een tekenreeks |
|
max_grootte |
retourneert het maximale aantal tekens |
|
reserveren |
reserveert opslagruimte |
|
String-bewerkingen |
|
|
duidelijk |
wist de inhoud van een string |
|
invoegen |
tekens invoegen |
|
wissen |
tekens verwijderen |
|
push_back |
een teken aan het einde van een regel toevoegen |
|
pop_back |
verwijdert het laatste teken |
|
toevoegen |
|
|
exploitant+= |
voegt tekens toe aan het einde van een tekenreeks |
|
vergelijken |
vergelijkt twee strings |
|
vervangen |
vervangt elk voorkomen van het opgegeven teken |
|
onderstr |
retourneert een subtekenreeks |
|
kopiëren |
kopieert karakters |
|
formaat wijzigen |
verandert het aantal opgeslagen tekens |
Wij raden aan“Thema's van bronnen van derden worden niet ondersteund” in MIUI: hoe je het verbod kunt omzeilenBent u op zoek naar MIUI 9-thema's van derden en wilt u weten hoe u MIUI 9-thema's van derden kunt toepassen op Redmi Note 4 en andere Xiaomi-thema's. Maak je geen zorgen, wij...
| |
