Veilige functies voor het werken met strings c. Invoer en uitvoer van tekenreeksen in C

p»їBetrouwbaar SEO-bureau India kan de inkomsten van kleine bedrijven verhogen

80% van de gebruikers zoekt op Google en andere zoekmachines voordat ze een aankoop doen en meer dan 50% van de via zoekmachines gegenereerde zoekopdrachten worden geconverteerd. Deze twee statistieken bewijzen het belang van zoekmachineoptimalisatie. Er zijn veel van dergelijke statistieken en feiten die een duidelijk punt maken: elk klein, middelgroot of grootschalig bedrijf heeft professionele SEO-diensten nodig. Kleine bedrijven en startups worden vaak geconfronteerd met budgetproblemen. Ze kunnen de hulp inroepen van elk betrouwbaar SEO-bureau uit India om de beste SEO-service binnen hun budget te krijgen en zo hun inkomsten te verhogen.
Zoeken heeft een grote impact op de geest van consumenten. Volgens de verschillende statistieken die zijn gedeeld door grote experts op het gebied van zoekmachineoptimalisatie op verschillende geautoriseerde websites zoals Search Engine Land, Moz, SEO Journal, Digital Marketers India, Hubspot, enz. SEO vangt een meerderheid van de leads op. Ook hebben de leads afkomstig uit de organische zoekresultaten een hoger conversiepercentage. Deze statistieken en consumentengedrag maken duidelijker dat de beste SEO-service geen luxe is, maar een noodzaak voor elk bedrijf.
Om de concurrentie te omzeilen en de bedrijfsgroei te vergroten, moet elke organisatie de diensten voor zoekmachineoptimalisatie gebruiken. De grote merken kunnen genoeg geld investeren voor de deskundige SEO-service die wordt aangeboden door een top SEO-bedrijf of een SEO-specialist, maar eigenaren van kleine bedrijven doen vaak concessies aan de kwaliteit van deze service vanwege een lager budget. Het is een moeilijk feit dat kleine bedrijven en startups uiteindelijk de kansen laten liggen die kunnen worden gecreëerd met de professionele SEO-service of een goedkope SEO-service gebruiken die geen positieve resultaten oplevert.
Eigenaars van kleine bedrijven en startups kunnen zelfs met een beperkt budget profiteren van professionele SEO-diensten. De beste oplossing is het vinden van een betrouwbaar SEO-bedrijf gevestigd in India. In India zijn er veel SEO-experts die samenwerken met het digitale marketingbureau en de beste diensten in de branche aanbieden. Zij kunnen u de benodigde SEO-diensten leveren binnen uw budget. Over de lonen kan worden onderhandeld met een SEO-bureau India om betere diensten tegen lagere tarieven te krijgen. Val echter niet voor de goedkope SEO-service die minder in rekening brengt en belooft meer te geven, aangezien expertise op zichzelf komt. U moet de portefeuille bekijken of de juiste vragen stellen voordat u een bedrijf voor uw bedrijf inhuurt.
De SEO-experts in India zijn bedreven in de best practices van zoekmachineoptimalisatie. Er zijn ook enkele SEO-specialisten in India, zoals Ash Vyas, die gespecialiseerd zijn in het creëren van de beste zvoor een bedrijf met een bepaald budget. De SEO-professionals zullen een duidelijk plan opstellen en ook delen wat de verwachte resultaten kunnen zijn. Zo bent u goed op de hoogte van uw belegging en rendement. Dit helpt bij het nemen van een betere zakelijke beslissing.
Een goed idee is om zo snel mogelijk een betrouwbaar SEO-bedrijf uit India te vinden en te contracteren dat de beste SEO-diensten aanbiedt. U kunt ook beginnen met een klein budget en beperkte activiteiten om uw webpagina's geïndexeerd te krijgen en uw trefwoorden in zoekmachines een boost te geven. Wacht niet op het perfecte moment of de dag waarop u duizenden dollars heeft om te investeren in de beste SEO-diensten. Vroeg beginnen zal u helpen sneller resultaten te behalen als u agressief te werk kunt gaan met uw marketingaanpak. Een betrouwbaar SEO-bedrijf uit India helpt u bij het definiëren van uw huidige en toekomstige plannen om goede resultaten te behalen. Meer geïndexeerde pagina's zorgen voor een hogere ranking en een geloofwaardig merk van uw bedrijf. Gemaakt met continue professionele SEO-praktijken zal het aantal aanvragen, omzet en inkomsten verdubbelen. Elk klein bedrijf kan beginnen met een investering van twee cijfers in de professionele SEO-diensten. Er zijn veel SEO-bureaus in India die een laag budget aanbieden en toch het resultaat zijn van georiënteerde.

enquêtes uit ballingschap

CraigWew
12.04.2018
p»їHet belang van het opbouwen van een goede verstandhouding met de klant op het gebied van onroerend goed en algemene verkoop

Het belang van een goede verstandhouding met de klant.
Het opbouwen van een goede verstandhouding met een klant moet worden verdiend en moet worden benaderd als een zeer integraal onderdeel van het verkoopproces.
Om ervoor te zorgen dat een klant en uzelf een echte één-op-één-relatie met elkaar kunnen hebben, zijn er twee dingen nodig!
Eerst moet je op de hoogte zijn en er zijn! Ten tweede moet je begrijpen dat er tijdens dit proces twee verschillende fasen zullen plaatsvinden.
A-Wees erbij, wat betekent dat?
o De meeste mensen luisteren niet echt naar een andere persoon terwijl ze praten. Over het algemeen zijn ze zo druk bezig met het formuleren van hun volgende antwoord of stelling dat ze onmogelijk echt kunnen luisteren.
o Als dit op jou lijkt, betekent aanwezig zijn dat je je mond moet houden en moet luisteren!
B-Wat is de eerste of initiële fase?
o Over het algemeen heeft u slechts een paar minuten de tijd om uzelf in de geest van de klant te vestigen als iemand met wie zij zaken willen doen.
o Bij twijfel is het het beste om eerst vragen te stellen die hen aanspreken en over zichzelf praten.
o Het is ook altijd veilig om als professional over te komen. Ik bedoel niet stoïcijns of droogjes, maar iemand die weet wat hij doet, praat en er goed uitziet.
C-Andere fasen
o Naarmate de tijd verstrijkt, zul je door middel van gesprekken en vragen die ze zullen hebben, je vaardigheden vaststellen of niet.
o Houd er rekening mee dat ze je waarschijnlijk nog een tijdje zullen meten. Het goede nieuws is dat als u succesvol bent in het opbouwen van een goede verstandhouding, ze zich op een gegeven moment zullen ontspannen en u zich kunt concentreren op het vinden of verkopen van het huis.
Wat kan mij nog meer helpen een goede verstandhouding te ontwikkelen?
o Door verschillende persoonlijkheidstypes te proberen begrijpen en vervolgens de juiste vragen te stellen en te stellen.
o Als je een goede verstandhouding hebt (op dezelfde golflengte zit als de klant), dan is de verkoop in principe voorbij, nu is het gewoon een kwestie van het vinden van het juiste huis of het invullen van de aanbiedingspapieren.
Hoe zit het met verschillende persoonlijkheden
o Omdat dit geen boek over psychiatrie is, moeten we nu eerst twee hoofdtypen begrijpen.
o Er zijn introverte en extraverte mensen.
o Je kent het type. Bedenk drie mensen die je kent die in elke classificatie passen.
Hoe zit het met lichaamstaal en spraakpatronen?
o Als ze snel of langzaam praten, probeer dan hun spraakpatronen na te bootsen.
o Als ze luid of zacht praten, doe dan hetzelfde. Leunen ze naar voren of naar achteren?
o Het is onnodig om te zeggen dat er veel boeken over dit onderwerp zijn geschreven. Houd er rekening mee dat dit een belangrijke factor is, vooral als u in een vergaderruimte zit of bij iemand thuis een deal van $ 400.000 bespreekt.
Het ontwikkelen van een goede verstandhouding is een vaardigheid die kan worden geleerd en verbeterd.
o We hebben allemaal wel eens een verkoper meegemaakt die ons iets verkocht en toch hadden we niet het gevoel dat we verkocht werden. De reden is dat hij of zij ervoor zorgde dat u zich op uw gemak voelde op de plek waar u ze vertrouwde.
Hoe ontwikkelen we een verstandhouding?
o Gebruik je ogen en oren en stel vragen. Uitleggen
o Gebruik de ogen:
o Kijk naar hun kleding, hun auto, hun persoonlijke bezittingen en ik bedoel, kijk echt naar ze en ontcijfer wat dat je over hen vertelt.
o Gebruik de oren:
o Luister naar wat ze zeggen en stel vragen om hun echte MOTIVATIE te doorgronden!
Tijdens dit hele gesprek zul je waarschijnlijk een of twee dingen ontdekken die je met hen gemeen hebt. (Familie, geografische gebieden, vissen, enz.) Als u gemeenschappelijke punten tegenkomt, laat hen dan weten dat u bekend bent en neem dan even de tijd om dit met hen te bespreken.
Wat is het doel?
o Zodra ze je als een van hen accepteren, ben je in een positie om echt een geweldige ervaring in de verkoop te hebben, omdat je nu samenwerkt en als een team – je bent niet langer de verkoper, je zit nu in een adviserende positie .
o Bedenk dat de klant je wel of niet in zijn wereld wil laten komen. Als je dit begrijpt en echt je best doet om empathisch voor hem/haar te worden, kun je een vertrouwenspositie verwerven. In de meeste gevallen zul je ze daadwerkelijk zien ontspannen (lichaamstaal) als dit onderweg gebeurt.
o Om dit te illustreren, heb je ooit een toespraak gehouden en gemerkt dat als je eindelijk contact maakte met een publiekslid, hij of zij goedkeurend knikte. Deze dingen lijken misschien allemaal banaal, maar dat zijn ze niet.
Tot slot: als je het vertrouwen van een klant kunt winnen, is het verkopen van een product of dienst veel gemakkelijker en kan de ervaring voor alle betrokkenen plezierig zijn.
Onthoud altijd dat een Win/Win de beste situatie is.

Lijnen. String-invoer/-uitvoer. Geformatteerde I/O. Stringverwerking met behulp van standaard C-taalfuncties. Werken met geheugen.

1.1. Declaratie en initialisatie van strings.

Een string is een array van tekens die eindigt met het lege teken '\0'. De string wordt gedeclareerd als een reguliere karakterarray, bijvoorbeeld

teken s1; // tekenreeks van negen tekens lang

teken *s2; // verwijzing naar tekenreeks

Het verschil tussen pointers s1 en s2 is dat pointer s1 een benoemde constante is, en pointer s2 een variabele.

Tekenreeksconstanten worden tussen dubbele aanhalingstekens geplaatst, in tegenstelling tot tekens die tussen enkele aanhalingstekens staan. Bijvoorbeeld,

“Dit is een touwtje.”

De lengte van een stringconstante mag volgens de standaard niet langer zijn dan 509 tekens. Veel implementaties maken echter langere tekenreekslengtes mogelijk.

Bij het initialiseren van strings is het beter om de arraygrootte niet op te geven; de compiler doet dit door de lengte van de string te berekenen en er één aan toe te voegen. Bijvoorbeeld,

char s1 = “Dit is een tekenreeks.”;

In de programmeertaal C zijn er een groot aantal functies voor het werken met strings, waarvan de prototypes worden beschreven in de headerbestanden stdlib.h en string.h. Het werken met deze functies wordt in de volgende paragrafen besproken.

1.2. String-invoer/-uitvoer.

Gebruik de functie om een tekenreeks vanuit de console in te voeren

char* krijgt(char *str);

die een string naar het adres str schrijft en het adres van de ingevoerde string retourneert. De functie stopt de invoer als deze een ‘\n’- of EOF-teken (einde van bestand) tegenkomt. Het nieuweregelteken wordt niet gekopieerd. Aan het einde van de leesregel wordt een nulbyte geplaatst. Als dit lukt, retourneert de functie een verwijzing naar de gelezen regel, en als dit niet lukt, NULL.

Gebruik de standaardfunctie om een string naar de console uit te voeren

int zet (const char *s);

die, indien succesvol, een niet-negatief getal retourneert, en indien niet succesvol, EOF retourneert.

De prototypes van de functie Gets en Puts worden beschreven in het headerbestand stdio.h.

#erbij betrekken

printf("Invoerreeks: ");

1.3. Geformatteerde I/O.

Gebruik de functie voor geformatteerde gegevensinvoer vanaf de console

int scanf (const char *format, ...);

die, indien succesvol, het aantal gelezen gegevenseenheden retourneert, en indien niet succesvol, EOF retourneert. De formatparameter moet verwijzen naar de te formatteren string, die de specificaties voor het invoerformaat bevat. Het aantal en de typen argumenten die op de opmaaktekenreeks volgen, moeten overeenkomen met het aantal en de typen invoerindelingen die in de opmaaktekenreeks zijn opgegeven. Als niet aan deze voorwaarde wordt voldaan, is het resultaat van de functie onvoorspelbaar.

Een spatie, "\t" of "\n" teken in een opmaaktekenreeks beschrijft een of meer lege tekens in de invoerstroom, waaronder de tekens: spatie, '\t', '\n', '\v', '\F '. De scanf-functie slaat lege tekens in de invoerstroom over.

Letterlijke tekens in een formatstring, met uitzondering van het %-teken, vereisen dat exact dezelfde tekens in de invoerstroom verschijnen. Als een dergelijk teken niet bestaat, stopt de scanf-functie met invoeren. De scanf-functie slaat letterlijke tekens over.

Over het algemeen ziet de specificatie van het invoerformaat er als volgt uit:

%[*] [breedte] [modifiers] type

Het symbool '*' duidt op een weglating bij het invoeren van een veld dat door deze specificatie wordt gedefinieerd;

- ‘breedte’ definieert het maximale aantal tekens dat volgens deze specificatie kan worden ingevoerd;

Het type kan de volgende waarden aannemen:

c – karakterarray,

s – een reeks tekens, regels worden gescheiden door lege tekens,

d – geheel getal met teken van 10 s/s,

i – geheel getal met teken, het getalsysteem is afhankelijk van de eerste twee cijfers,

u – geheel getal zonder teken bij 10 s/s,

o – geheel getal zonder teken in 8 s/s,

x, X – geheel getal zonder teken bij 16 s/s,

e, E, f, g, G – zwevend getal,

p – aanwijzer naar aanwijzer,

n – verwijzing naar een geheel getal,

[…] – een reeks gescande tekens, bijvoorbeeld .

In het laatste geval worden alleen de tekens tussen vierkante haken ingevoerd uit de invoerstroom. Als het eerste teken tussen de vierkante haakjes '^' is, worden alleen de tekens ingevoerd die niet in de array staan. Het tekenbereik in de array wordt gespecificeerd met behulp van het symbool '-'. Wanneer u tekens invoert, worden ook de eerste blanco tekens en de laatste null-byte van de tekenreeks ingevoerd.

Modifiers kunnen de volgende waarden aannemen:

h – kort geheel getal,

l, L – lang geheel getal of zwevend,

en worden alleen gebruikt voor gehele getallen of zwevende getallen.

In het volgende voorbeeld ziet u het gebruik van de scanf-functie. Houd er rekening mee dat de formaatspecificatie, beginnend met de invoer van zwevende getallen, wordt voorafgegaan door een spatie.

#erbij betrekken

printf("Voer een geheel getal in: ");

scanf("%d", &n);

printf("Voer een dubbele in: ");

scanf(" %lf", &d);

printf("Voer een teken in: ");

scanf(" %c", &c);

printf("Voer een tekenreeks in: ");

scanf(" %s", &s);

Merk op dat in dit programma het drijvende-kommagetal wordt geïnitialiseerd. Dit wordt gedaan zodat de compiler een bibliotheek bevat ter ondersteuning van het werken met zwevende getallen. Als dit niet wordt gedaan, zal er tijdens runtime een fout optreden bij het invoeren van een zwevend getal.

Gebruik de functie voor geformatteerde uitvoer van gegevens naar de console

int printf (const char *formaat, ...);

die, indien succesvol, het aantal gegevensuitvoereenheden retourneert, en indien niet succesvol, EOF retourneert. De formaatparameter is een formaattekenreeks die specificaties voor uitvoerformaten bevat. Het aantal en de typen argumenten die volgen op de indelingsreeks moeten overeenkomen met het aantal en de typen uitvoerindelingsspecificaties die zijn opgegeven in de indelingsreeks. Over het algemeen ziet de specificatie van het uitvoerformaat er als volgt uit:

%[flags] [breedte] [.precision] [modifiers] type

- ‘vlaggen’ zijn verschillende symbolen die het uitvoerformaat specificeren;

- ‘breedte’ definieert het minimumaantal tekens dat wordt uitgevoerd volgens deze specificatie;

- ‘.precision’ definieert het maximale aantal weergegeven tekens;

- ‘modifiers’ specificeren het type argumenten;

- 'type' specificeert het type argument.

Om ondertekende gehele getallen uit te voeren, wordt het volgende uitvoerformaat gebruikt:

%[-] [+ | ruimte] [breedte] [l] d

- – uitlijning links, standaard – rechts;

+ – het ‘+’ teken wordt weergegeven. Houd er rekening mee dat voor negatieve getallen altijd het ‘-’ teken wordt weergegeven;

‘spatie’ – er wordt een spatie weergegeven op de tekenpositie;

d – int-gegevenstype.

Om niet-ondertekende gehele getallen uit te voeren, gebruikt u het volgende uitvoerformaat:

%[-] [#] [breedte] [l]

# – initiële 0 wordt uitgevoerd voor getallen in 8 c/c of initiële 0x of 0X voor getallen in 16 c/c,

l – lange datatype-modifier;

u – geheel getal in 10c/c,

o – geheel getal in 8 c/c,

x, X – geheel getal bij 16 c/c.

Om getallen met drijvende komma uit te voeren, wordt het volgende uitvoerformaat gebruikt:

%[-] [+ | spatie] [breedte] [.precisie]

"precisie" - geeft het aantal cijfers achter de komma aan voor de formaten f, e en E of het aantal significante cijfers voor de formaten g en G. Getallen worden afgerond. De standaardprecisie is zes decimalen;

f – vast puntnummer,

e – een getal in exponentiële vorm, de exponent wordt aangegeven met de letter “e”,

E – een getal in exponentiële vorm, de exponent wordt aangegeven met de letter “E”,

g – de kortste van de f- of g-formaten,

G – de kortste van de f- of G-formaten.

printf ("n = %d\n f = %f\n e = %e\n E = %E\n f = %.2f", -123, 12.34, 12.34, 12.34, 12.34);

// afdrukken: n = 123 f = 12,340000 e = 1,234000e+001 E = 1,234000E+001 f = 12,34

1.4. Tekenreeksen opmaken.

Er zijn varianten van de functies scanf en printf die zijn ontworpen om tekenreeksen op te maken en die respectievelijk sscanf en sprintf worden genoemd.

int sscanf (const char *str, const char *format, ...);

leest gegevens uit de string gespecificeerd door str, volgens de formatstring gespecificeerd door format. Als dit lukt, wordt het aantal gelezen gegevens geretourneerd en als dit niet lukt, wordt EOF geretourneerd. Bijvoorbeeld,

#erbij betrekken

char str = "a 10 1.2 String Geen invoer";

sscanf(str, "%c %d %lf %s", &c, &n, &d, s);

printf("%c\n", c); // afdrukken: een

printf("%d\n", n); // afdrukken: 10

printf("%f\n", d); // afdrukken: 1.200000

printf("%s\n", s); //afdrukken: String

int sprintf (char *buffer, const char *format, ...);

formatteert de tekenreeks in overeenstemming met het formaat dat is opgegeven door de formatparameter en schrijft het resulterende resultaat naar de bufferkarakterarray. De functie retourneert het aantal tekens dat naar de tekenarraybuffer is geschreven, exclusief de afsluitende nulbyte. Bijvoorbeeld,

#erbij betrekken

char str = "c = %c, n = %d, d = %f, s = %s";

char s = "Dit is een tekenreeks.";

sprintf(buffer, str, c, n, d, s);

printf("%s\n", buffer); // prints: c = c, n = 10, d = 1,200000, s = Dit is een string

1.5. Converteer tekenreeksen naar numerieke gegevens.

Prototypes van functies voor het converteren van strings naar numerieke gegevens worden gegeven in het headerbestand stdlib.h, dat in het programma moet worden opgenomen.

Gebruik de functie om een string naar een geheel getal te converteren

int atoi (const char *str);

char *str = “-123”;

n = atoi(str); // n = -123

Gebruik de functie om een string naar een lang geheel getal te converteren

lange int atol (const char *str);

die, indien succesvol, het gehele getal retourneert waarnaar de tekenreeks str wordt geconverteerd, en indien niet succesvol, 0 retourneert. Bijvoorbeeld:

char *str = “-123”;

n = atol(str); // n = -123

Gebruik de functie om een string naar een dubbel getal te converteren

dubbele atof(const char *str);

die, in geval van succes, een zwevend getal van het type double retourneert, waarin de string str wordt omgezet, en in geval van mislukking 0. Bijvoorbeeld:

char *str = “-123.321”;

n = atof(str); // n = -123,321

De volgende functies voeren soortgelijke functies uit als atoi, atol, atof, maar bieden meer geavanceerde functionaliteit.

lange int strtol (const char *str, char **endptr, int base);

converteert de string str naar een lang int-getal, dat wordt geretourneerd. De parameters van deze functie hebben de volgende doeleinden.

Als grondtal 0 is, hangt de conversie af van de eerste twee tekens van str:

Als het eerste teken een getal van 1 tot en met 9 is, wordt aangenomen dat het getal wordt weergegeven in 10 c/c;

Als het eerste teken het cijfer 0 is en het tweede teken een cijfer van 1 tot en met 7, wordt aangenomen dat het getal wordt weergegeven in 8 c/c;

Als het eerste teken 0 is en het tweede 'X' of 'x', wordt aangenomen dat het getal wordt weergegeven in 16 c/c.

Als grondtal een getal tussen 2 en 36 is, wordt die waarde genomen als het grondtal van het getalsysteem en stopt elk teken buiten het getalsysteem met converteren. In getalsystemen met grondtal 11 tot en met grondtal 36 worden de symbolen 'A' tot 'Z' of 'a' tot 'z' gebruikt om cijfers weer te geven.

De waarde van het endptr-argument wordt ingesteld door de strtol-functie. Deze waarde bevat een verwijzing naar het teken dat ervoor zorgde dat de tekenreeks str niet werd geconverteerd. Als dit lukt, retourneert de functie strtol het geconverteerde getal, en als dit niet lukt, retourneert deze 0. Bijvoorbeeld:

n = strtol (“12a”, &p, 0);

printf("n = %ld, %stop = %c, n, *p); // n = 12, stop = een

n = strtol("012b", &p, 0);

printf("n = %ld, %stop = %c, n, *p); // n = 10, stop = b

n = strtol (“0x12z”, &p, 0);

printf("n = %ld, %stop = %c, n, *p); // n = 18, stop = z

n = strtol (“01117”, &p, 0);

printf("n = %ld, %stop = %c, n, *p); // n = 7, stop = 7

niet-ondertekende lange int strtol (const char *str, char **endptr, int base);

werkt op dezelfde manier als de strtol-functie, maar converteert de symbolische weergave van een getal naar een getal van het type unsigned long int.

dubbele strtod (const char *str, char **endptr);

Converteert de symbolische weergave van een getal naar een dubbel.

Alle in deze paragraaf genoemde functies stoppen met werken wanneer ze het eerste teken tegenkomen dat niet past in het formaat van het betreffende getal.

Als de tekenwaarde van een getal bovendien het bereik van acceptabele waarden voor het overeenkomstige gegevenstype overschrijdt, stellen de functies atof, strtol, strtoul, strtod de waarde van de errno-variabele in op ERANGE. De errno-variabele en de ERANGE-constante worden gedefinieerd in het math.h-headerbestand. In dit geval retourneren de functies atof en strtod de waarde HUGE_VAL, retourneert de functie strtol de waarde LONG_MAX of LONG_MIN, en retourneert de functie strtoul de waarde ULONG_MAX.

De niet-standaard functies itoa, ltoa, utoa, ecvt, fcvt en gcvt kunnen worden gebruikt om numerieke gegevens naar tekenreeksen te converteren. Maar het is beter om voor deze doeleinden de standaard sprintf-functie te gebruiken.

1.6. Standaardfuncties voor het werken met strings.

In deze sectie worden functies besproken voor het werken met strings, waarvan de prototypes worden beschreven in het headerbestand string.h.

1. Stringvergelijking. De functies strcmp en strncmp worden gebruikt om strings te vergelijken.

int strcmp (const char *str1, const char *str2);

vergelijkt lexicografisch de strings str1, str2 en retourneert –1, 0 of 1 als str1 respectievelijk kleiner is dan, gelijk is aan of groter is dan str2.

int strncmp (const char *str1, const char *str2, size_t n);

vergelijkt lexicografisch maximaal de eerste n tekens uit de strings str1 en str2. De functie retourneert -1, 0 of 1 als de eerste n tekens uit str1 respectievelijk kleiner, gelijk aan of groter zijn dan de eerste n tekens uit str2.

// voorbeeld van stringvergelijking

#erbij betrekken

char str1 = "aa bb";

char str2 = "aa aa";

char str3 = "aa bb cc";

printf("%d\n", strcmp(str1, str3)); // afdrukken: -1

printf("%d\n", strcmp(str1, str1)); //afdrukken: -0

printf("%d\n", strcmp(str1, str2)); // afdrukken: 1

printf("%d\n", strncmp(str1, str3, 5)); //afdrukken: 0

2. Lijnen kopiëren. De strcpy- en strncpy-functies worden gebruikt om tekenreeksen te kopiëren.

char *strcpy (char *str1, const char *str2);

kopieert de tekenreeks str2 naar de tekenreeks str1. De volledige string str2 wordt gekopieerd, inclusief de afsluitende nulbyte. De functie retourneert een pointer naar str1. Als de lijnen elkaar overlappen, is het resultaat onvoorspelbaar.

char *strncpy (char *str1, const char *str2, size_t n);

kopieert n tekens van string str2 naar string str1. Als str2 minder dan n tekens bevat, wordt de laatste nulbyte zo vaak als nodig gekopieerd om str2 uit te breiden naar n tekens. De functie retourneert een verwijzing naar de tekenreeks str1.

char str2 = "Kopieer tekenreeks.";

strcpy(str1, str2);

printf(str1); // prints: tekenreeks kopiëren.

4. Snaren verbinden. De functies strcat en strncat worden gebruikt om strings samen te voegen tot één string.

char* strcat (char *str1, const char *str2);

voegt string str2 toe aan string str1, waarbij de laatste nulbyte van string str1 wordt gewist. De functie retourneert een verwijzing naar de tekenreeks str1.

char* strncat (char *str1, const char *str2, size_t n);

voegt n tekens toe van string str2 aan string str1, waarbij de laatste nulbyte van string str1 wordt gewist. De functie retourneert een verwijzing naar de tekenreeks str1. als de lengte van de string str2 kleiner is dan n, worden alleen de tekens uit de string str2 toegevoegd. Na het aaneenschakelen van strings wordt altijd een null-byte toegevoegd aan str1. De functie retourneert een verwijzing naar de tekenreeks str1.

#erbij betrekken

char str1 = "String";

char str2 = "catenatie";

char str3 = "Ja Nee";

strcat(str1, str2);

printf("%s\n", str1); // prints: String-catenatie

strncat(str1, str3, 3);

printf("%s\n", str1); // prints: String-catenatie Ja

5. Zoek naar een teken in een string. Om een teken in een string te zoeken, gebruik je de functies strchr, strrchr, strspn, strcspn en strpbrk.

char* strchr (const char *str, int c);

zoekt naar de eerste keer dat het teken voorkomt dat is opgegeven door c in de tekenreeks str. Als dit lukt, retourneert de functie een verwijzing naar het eerste gevonden teken, en als dit niet lukt, NULL.

char* strrchr (const char *str, int c);

zoekt naar de laatste keer dat het teken voorkomt dat is opgegeven door c in de tekenreeks str. Als dit lukt, retourneert de functie een verwijzing naar het laatst gevonden teken, en als dit niet lukt, NULL.

#erbij betrekken

char str = "Char zoeken";

printf("%s\n", strchr(str, "r")); //afdrukken: r zoeken

printf("%s\n", strrchr(str, "r")); // afdrukken: rch

size_t strspn (const char *str1, const char *str2);

retourneert de index van het eerste teken uit str1 dat niet in str2 staat.

size_t strcspn (const char *str1, const char *str2);

retourneert de index van het eerste teken uit str1 dat in str2 verschijnt.

char str = "123 abc";

printf ("n =%d\n", strspn (str, "321"); // prints: n = 3

printf ("n =%d\n", strcspn (str, "cba"); // prints: n = 4

char* strpbrk (const char *str1, const char *str2);

vindt het eerste teken in de string str1 dat gelijk is aan een van de tekens in de string str2. Als dit lukt, retourneert de functie een verwijzing naar dit teken, en als dit niet lukt, NULL.

char str = "123 abc";

printf("%s\n", strpbrk(str, "bca")); // afdrukken: abc

6. Stringvergelijking. De strstr-functie wordt gebruikt om strings te vergelijken.

char* strstr (const char *str1, const char *str2);

vindt de eerste keer dat str2 voorkomt (zonder de afsluitende nulbyte) in str1. Als dit lukt, retourneert de functie een verwijzing naar de gevonden subtekenreeks, en als dit niet lukt, NULL. Als de str1-aanwijzer naar een tekenreeks met lengte nul verwijst, retourneert de functie de str1-aanwijzer.

char str = "123 abc 456;

printf ("%s\n", strstr (str, "abc"); // print: abc 456

7. Een string in tokens parseren. De strtok-functie wordt gebruikt om een string in tokens te parseren.

char* strtok (char *str1, const char *str2);

retourneert een verwijzing naar het volgende token (woord) in de tekenreeks str1, waarbij de tokenscheidingstekens tekens uit de tekenreeks str2 zijn. Als er geen tokens meer zijn, retourneert de functie NULL. Bij de eerste aanroep van de functie strtok moet de parameter str1 verwijzen naar een tekenreeks die is getokeniseerd, en bij volgende aanroepen moet deze parameter worden ingesteld op NULL. Nadat een token is gevonden, schrijft de strtok-functie een null-byte na dit token in plaats van het scheidingsteken.

#erbij betrekken

char str = "12 34 abcd";

p = strtok(str, " ");

printf("%s\n", p); // drukt de waarden af in een kolom: 12 34 ab cd

p = strtok(NULL, " ");

8. Bepalen van de lengte van een snaar. De strlen-functie wordt gebruikt om de lengte van een string te bepalen.

size_t strlen (const char *str);

retourneert de lengte van de tekenreeks, exclusief de laatste nulbyte. Bijvoorbeeld,

char str = "123";

printf("len = %d\n", strlen(str)); //afdrukken: len = 3

1.7. Functies voor het werken met geheugen.

Het headerbestand string.h beschrijft ook functies voor het werken met geheugenblokken, die vergelijkbaar zijn met de overeenkomstige functies voor het werken met strings.

void* memchr (const void *str, int c, size_t n);

zoekt naar het eerste exemplaar van het teken gespecificeerd door c in n bytes van de string str.

int memcmp (const void *str1, const void *str2, size_t n);

vergelijkt de eerste n bytes van de strings str1 en str2.

void* memcpy (const void *str1, const void *str2, size_t n);

kopieert de eerste n bytes van string str1 naar string str2.

void* memmove (const void *str1, const void *str2, size_t n);

kopieert de eerste n bytes van str1 naar str2, zodat overlappende tekenreeksen correct worden afgehandeld.

void* memset (const void *str, int c, size_t n);

kopieert het teken gespecificeerd door c naar de eerste n bytes van str.

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:

Namespace 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 #erbij betrekken #erbij betrekken namespace std; gebruiken; int main() ( string s = "Test"; s.insert(1,"!"); cout<< s.c_str() << endl; string *s2 = new string("Hello"); s2->wissen(s2->einde()); uit<< s2->c_str(); cin.get(); retour 0; )

De belangrijkste kenmerken van de stringklasse:

initialisatie met een reeks tekens (een ingebouwd stringtype) of een ander object van het type string . Een ingebouwd type heeft de tweede mogelijkheid niet;
het 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 Snaarlengte(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"); tekenreeks 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; // Rechts

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 trefwoord const voorkomt 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

geeft terug onveranderbaar een C-karakterarray die de karakters van de string bevat

Lijncapaciteitscontrole

leeg

controleert of een string leeg is

maat
lengte

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

terugduwen

het toevoegen van een teken aan het einde van een string

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

Tekenreeksen declareren

Een string in de C-taal is een eendimensionale reeks tekens, waarvan het laatste element het teken aan het einde van de regel is: nul (een string die wordt beëindigd door nul, dat wil zeggen een NULL-beëindigde string).

Het declareren van een variabele van het type string in de C-taal is op drie manieren mogelijk, waarvan er twee de string initialiseren op het moment van declaratie.

Eerste manier:

Karakterarray-declaraties (vergeet niet om ruimte toe te voegen voor de afsluitende nul):

Char's;

Tweede manier:

Wijs de initiële waarde toe aan de stringvariabele (in dit geval kan de compiler de lengte van de string zelf berekenen):

Char s = "Voorbeeld van stringinitialisatie";

Rechts van het toewijzingsteken staat een stringconstante. Er wordt automatisch een nul (‘\0’) toegevoegd aan het einde van de regel. Tekenreeksconstanten worden in een statische geheugenklasse geplaatst.

Derde manier:

Impliciete indicatie dat een array wordt gebruikt. Links van het toewijzingsteken staat een verwijzing naar het symbool:

Char *s="Tweede initialisatieoptie";

De variabele s zal een verwijzing zijn naar de locatie in het RAM waar de stringconstante zich bevindt. Een mogelijke valkuil bij deze vorm van notatie is dat een verwijzing naar een teken vaak een string wordt genoemd. Het onderstaande item is slechts een verwijzing naar een teken, aangezien er geen ruimte is voor de string:

Char *s;

Een tekenreeks invoeren vanaf een standaardinvoerapparaat (toetsenbord)

Er is een reeks functies voor het werken met tekenreeksen. Voor invoer vanaf een standaard invoerapparaat (toetsenbord) worden meestal bibliotheekfuncties van de standaard invoer-/uitvoermodule gebruikt: scannenf En krijgt.

Om een string in te voeren met behulp van de functie scannenf, gebruikt het formaat « %S» en merk op dat het adresteken niet vóór de lijnidentificatie wordt gebruikt « & » , aangezien een eendimensionale array al wordt weergegeven door een verwijzing naar het begin:

Scanf("%s", s);

Functie krijgt() leest tekens totdat het een nieuwregelteken bereikt. De functie accepteert alle tekens tot aan het nieuweregelteken, maar neemt dit niet op. Aan het einde van de regel wordt een afsluitende nul ('\0') toegevoegd. Functie krijgt() plaatst de reeks tekens die vanaf het toetsenbord worden gelezen in een parameter van het type string en retourneert een verwijzing naar deze string (als de bewerking succesvol was), of NULL (in geval van een fout). Als de bewerking in het onderstaande voorbeeld succesvol is voltooid, worden twee identieke regels op het scherm weergegeven:

#erbij betrekken int main() ( char s; char *p; p=gets(s); printf(" \n De string %s is ingevoerd.",s); if (p) printf(" \n De string %s is ingevoerd.", p); return 0; )

Merk terloops op dat de get-functie vaak wordt gebruikt om gegevens van het toetsenbord als een string in te voeren met het oog op verdere conversie door de sscanf-functie naar het gewenste formaat of voor voorlopige analyse van de invoergegevens, bijvoorbeeld:

#erbij betrekken #erbij betrekken #erbij betrekken int main() ( char s; int x, err; do ( printf(" \n Voer een geheel getal in -> "); get(s); err=sscanf(s, "%d",&x); if (err !=1) printf(" \n Invoerfout. " ) while (err!=1); printf("\n Geheel getal ingevoerd -> %d", x )

Tekenreeksen afdrukken naar standaarduitvoer (monitorscherm)

Om strings naar het standaard uitvoerapparaat (monitorscherm) uit te voeren, kunt u twee functies gebruiken afdrukkenf En zet. De printf-functie wordt als formaat "%s" doorgegeven. Het gemak van het gebruik van deze functie is dat u naast een string direct gegevens van andere typen kunt weergeven. Kenmerk Kenmerk zet is dat nadat een regel is afgedrukt, deze automatisch naar de volgende regel gaat.

Functies voor het werken met strings

Om strings in de C-taal te converteren, is de stringbibliotheek beschikbaar. Elke functie heeft zijn eigen opnameformaat (prototype).

De meest gebruikte functies worden in dit artikel besproken. - lezen

Voorbeeld van programma's (lijst) die met strings werken

--- C#-handleiding --- Tekenreeksen

Vanuit een normaal programmeeroogpunt is string tekenreeks gegevenstype is een van de belangrijkste in C#. Dit type definieert en ondersteunt tekenreeksen. In een aantal andere programmeertalen is een string een array van tekens. En in C# zijn strings objecten. Daarom is het tekenreekstype een referentietype.

Snaren bouwen

De eenvoudigste manier om een tekenreeks te construeren is door een letterlijke tekenreeks te gebruiken. De volgende coderegel wijst bijvoorbeeld de tekenreeksreferentievariabele str een verwijzing toe naar een letterlijke tekenreeks:

String str = "Voorbeeldreeks";

In dit geval wordt de variabele str geïnitialiseerd met de reeks tekens "Example String". Een object van het type string kan ook worden gemaakt op basis van een array van het type char. Bijvoorbeeld:

Char chararray = ("e", "x", "a", "m", "p", "l", "e"); string str = nieuwe string(chararray);

Zodra een stringobject is gemaakt, kan het overal worden gebruikt waar u een tekstreeks tussen aanhalingstekens nodig heeft.

String persistentie

Vreemd genoeg kan de inhoud van een object van het type string niet worden gewijzigd. Dit betekent dat zodra een tekenreeks is gemaakt, deze niet meer kan worden gewijzigd. Maar deze beperking draagt bij aan een efficiëntere implementatie van tekenreeksen. Daarom verandert dit ogenschijnlijk voor de hand liggende nadeel feitelijk in een voordeel. Als er dus een string nodig is als variatie op een bestaande string, dan moet voor dit doel een nieuwe string worden aangemaakt die alle noodzakelijke wijzigingen bevat. En aangezien ongebruikte stringobjecten automatisch als afval worden verzameld, hoeft u zich niet eens zorgen te maken over het lot van onnodige strings.

Er moet echter worden benadrukt dat variabele verwijzingen naar strings (dat wil zeggen objecten van het type string) aan verandering onderhevig zijn, en daarom naar een ander object kunnen verwijzen. Maar de inhoud van het stringobject zelf verandert niet nadat het is gemaakt.

Laten we eens kijken naar een voorbeeld:

Static void addNewString() ( string s = "Dit is mijn streek"; s = "Dit is een nieuwe streek"; )

Laten we de applicatie compileren en de resulterende assembly in het hulpprogramma ildasm.exe laden. De afbeelding toont de CIL-code die wordt gegenereerd voor de void addNewString() -methode:

Merk op dat er talloze aanroepen zijn naar de ldstr-opcode (string load). Deze CIL ldstr-opcode laadt een nieuw stringobject op de beheerde heap. Als gevolg hiervan wordt het vorige object dat de waarde 'Dit is mijn slag' bevatte uiteindelijk verzameld als afval.

Werken met tekenreeksen

In de klas Systeem.String er is een reeks methoden beschikbaar voor het bepalen van de lengte van tekengegevens, het zoeken naar een subtekenreeks in de huidige tekenreeks, het converteren van tekens van hoofdletters naar kleine letters en omgekeerd, enz. Vervolgens zullen we deze klasse in meer detail bekijken.

Veld-, Indexer- en String-klasse-eigenschap

De klasse String definieert één enkel veld:

Openbare statische alleen-lezen tekenreeks Leeg;

Het lege veld geeft een lege string aan, d.w.z. een string die geen karakters bevat. Dit verschilt van een lege String-verwijzing, die eenvoudigweg naar een niet-bestaand object wordt gemaakt.

Bovendien definieert de klasse String een enkele alleen-lezen indexer:

Openbare char dit (krijg;)

Met deze indexer kunt u een teken bij een opgegeven index ophalen. Het indexeren van strings, zoals arrays, begint vanaf nul. String-objecten zijn persistent en veranderen niet. Het is dus logisch dat de klasse String een alleen-lezen indexeerfunctie ondersteunt.

Ten slotte definieert de klasse String een enkele alleen-lezen eigenschap:

Publieke int Lengte (krijg; )

De eigenschap Length retourneert het aantal tekens in de tekenreeks. Het onderstaande voorbeeld toont het gebruik van de indexer en de eigenschap Length:

Systeem gebruiken; class Voorbeeld ( static void Main() ( string str = "Eenvoudige string"; // Haal de lengte van de string en het 6e teken in de regel op met behulp van de indexer Console.WriteLine("Lengte van de string is (0), 6e teken is "(1)"" , str.Length, str);

Operators van stringklassen

De klasse String overbelast de volgende twee operators: == en !=. De operator == wordt gebruikt om twee tekenreeksen op gelijkheid te testen. Wanneer de operator == wordt toegepast op objectverwijzingen, wordt doorgaans getest of beide verwijzingen naar hetzelfde object worden gemaakt. En wanneer de operator == wordt toegepast op verwijzingen naar objecten van het type String, wordt de inhoud van de strings zelf op gelijkheid vergeleken. Hetzelfde geldt voor de !=-operator. Wanneer het wordt toegepast op verwijzingen naar objecten van het type String, wordt de inhoud van de strings zelf vergeleken op ongelijkheid. Andere relationele operatoren, waaronder =, vergelijken verwijzingen naar objecten van het type String echter op dezelfde manier als verwijzingen naar objecten van andere typen. En om te controleren of de ene string groter is dan de andere, moet je de Compare()-methode aanroepen die is gedefinieerd in de String-klasse.

Zoals duidelijk zal worden, zijn veel soorten tekenreeksvergelijkingen afhankelijk van culturele informatie. Maar dit geldt niet voor de operatoren == en !=. Ze vergelijken immers eenvoudigweg de ordinale waarden van karakters in strings. (Met andere woorden, ze vergelijken de binaire waarden van karakters die niet zijn gewijzigd door culturele normen, dat wil zeggen lokale normen.) Daarom voeren deze operators tekenreeksvergelijkingen uit op een hoofdletterongevoelige en cultuurongevoelige manier.

Methoden voor stringklassen

De volgende tabel bevat een aantal van de meest interessante methoden in deze klasse, gegroepeerd op doel:

Methoden voor het werken met snaren

Methode	Structuur en overbelasting	Doel
Snaarvergelijking
vergelijken()	public static int Vergelijk(string strA, string strB) Openbare statische int Compare(string strA, string strB, bool negeerCase) Openbare statische int Compare(string strA, string strB, StringComparison vergelijkingstype) Openbare statische int Compare (string strA, string strB, bool negeerCase, CultureInfo cultuur)	De statische methode vergelijkt string strA met string strB. Retourneert een positieve waarde als strA groter is dan strB; negatieve waarde als strA kleiner is dan strB; en nul als de strings strA en strB gelijk zijn. Vergelijkingen worden gemaakt op basis van register en cultuur. Als negeerCase resulteert in waar, houdt de vergelijking geen rekening met de verschillen tussen hoofdletters en kleine letters. Anders wordt met deze verschillen rekening gehouden. De parameter CompareType specificeert de specifieke manier waarop tekenreeksen worden vergeleken. De klasse CultureInfo wordt gedefinieerd in de naamruimte System.Globalization.
vergelijken()	public static int Compare(string strA, int indexA, string strB, int indexB, int lengte) Openbare statische int Compare(string strA, int indexA, string strB, int indexB, int lengte, bool negeerCase) Openbare statische int Compare(string strA, int indexA, string strB, int indexB, int lengte, StringComparison CompareType) Openbare statische int Compare(string strA, int indexA, string strB, int indexB, int lengte, bool negeerCase, CultureInfo cultuur)	Vergelijkt delen van de snaren strA en strB. De vergelijking begint met de stringelementen strA en strB en omvat het aantal tekens dat is opgegeven door de lengteparameter. De methode retourneert een positieve waarde als een deel van de string strA groter is dan een deel van de string strB; negatieve waarde als een deel van string strA kleiner is dan een deel van string strB; en nul als de delen van de strings strA en strB die worden vergeleken gelijk zijn. Vergelijkingen worden gemaakt op basis van register en cultuur.
Vergelijk ordinaal()	public static int CompareOrdinal(string strA, string strB) Openbare statische int CompareOrdinal(string strA, int indexA, string strB, int indexB, int count)	Doet hetzelfde als de methode Compare(), maar zonder rekening te houden met lokale instellingen
Vergelijk met()	public int CompareTo(objectwaarde)	Vergelijkt de aanroepende string met de stringrepresentatie van het waardeobject. Retourneert een positieve waarde als de aanroepende tekenreeks groter is dan de waarde; negatief als de aanroepende string kleiner is dan de waarde; en nul als de vergeleken strings gelijk zijn
Vergelijk met()	public int CompareTo(string strB)	Vergelijkt de aanroepende string met de string strB
Is gelijk aan()	openbare overschrijving bool is gelijk aan (object obj)	Retourneert de booleaanse waarde true als de aanroepende string dezelfde reeks tekens bevat als de stringrepresentatie van obj. Voert een ordinale vergelijking uit die hoofdlettergevoelig maar cultureel ongevoelig is
	public bool is gelijk aan (tekenreekswaarde) Openbare bool is gelijk aan (tekenreekswaarde, StringComparison-vergelijkingstype)	Retourneert de Booleaanse waarde true als de aanroepende tekenreeks dezelfde reeks tekens bevat als de tekenreekswaarde. Er wordt een ordinale vergelijking uitgevoerd die hoofdlettergevoelig maar niet cultureel gevoelig is. De parameter CompareType specificeert de specifieke manier waarop tekenreeksen worden vergeleken
	openbare statische bool is gelijk aan (string a, string b) Openbare statische bool is gelijk aan (tekenreeks a, tekenreeks b, StringComparison-vergelijkingstype)	Retourneert de Booleaanse waarde true als tekenreeks a dezelfde reeks tekens bevat als tekenreeks b . Er wordt een ordinale vergelijking uitgevoerd die hoofdlettergevoelig maar niet cultureel gevoelig is. De parameter CompareType specificeert de specifieke manier waarop tekenreeksen worden vergeleken
Aaneenschakeling (verbinding) van strings
Concat()	openbare statische tekenreeks Concat(string str0, string str1); openbare statische tekenreeks Concat(params tekenreekswaarden);	Combineert individuele stringinstanties tot één enkele string (aaneenschakeling)
Zoek in een tekenreeks
Bevat()	public bool Bevat(tekenreekswaarde)	Een methode waarmee je kunt bepalen of een string een bepaalde substring (waarde) bevat
Begint met()	openbare bool StartsWith(tekenreekswaarde) Openbare bool StartsWith(tekenreekswaarde, StringComparison-vergelijkingstype)	Retourneert de Booleaanse waarde true als de aanroepende tekenreeks begint met de subtekenreekswaarde. Anders wordt de Booleaanse waarde false geretourneerd. De parameter CompareType specificeert de specifieke manier waarop de zoekopdracht moet worden uitgevoerd
Eindigt met()	openbare bool EndsWith(tekenreekswaarde) Openbare bool EndsWith(tekenreekswaarde, StringComparison-vergelijkingstype)	Retourneert de Booleaanse waarde true als de aanroepende tekenreeks eindigt met de subtekenreekswaarde. Anders wordt de Booleaanse waarde false geretourneerd. De parameter CompareType specificeert de specifieke zoekmethode
Index van()	public int IndexOf(char-waarde) Public int IndexOf(tekenreekswaarde)	Zoekt de eerste keer dat een bepaalde subtekenreeks of teken in een tekenreeks voorkomt. Als het gezochte teken of de gezochte subtekenreeks niet wordt gevonden, wordt de waarde -1 geretourneerd.
Index van()	public int IndexOf(char-waarde, int startIndex) Public int IndexOf(tekenreekswaarde, int startIndex) Public int IndexOf(char-waarde, int startIndex, int aantal) Public int IndexOf(tekenreekswaarde, int startIndex, int aantal)	Retourneert de index van de eerste keer dat het teken of de subtekenreekswaarde voorkomt in de aanroepende tekenreeks. De zoekopdracht begint bij het element dat is opgegeven door startIndex en omvat het aantal elementen dat is opgegeven door count (indien opgegeven). De methode retourneert -1 als het gezochte teken of de gezochte subtekenreeks niet wordt gevonden
LaatsteIndexOf()	De overbelaste versies zijn vergelijkbaar met de IndexOf()-methode	Hetzelfde als IndexOf, maar vindt de laatste keer dat een teken of subtekenreeks voorkomt, niet de eerste
IndexVanElke()	public int IndexOfAny(char anyOf) Publieke int IndexOfAny(char anyOf, int startIndex) Publieke int IndexOfAny(char anyOf, int startIndex, int count)	Retourneert de index van de eerste keer dat een teken uit de anyOf-array voorkomt in de aanroepende tekenreeks. De zoekopdracht begint bij het element dat is opgegeven door startIndex en omvat het aantal elementen dat is opgegeven door count (indien opgegeven). De methode retourneert -1 als er geen enkel teken in de anyOf-array overeenkomt. Het zoeken gebeurt ordinaal
LaatsteIndexVanElk	De overbelaste versies zijn vergelijkbaar met de IndexOfAny()-methode	Retourneert de index van de laatste keer dat een teken uit de anyOf-array voorkomt in de aanroepende tekenreeks
Snaren splitsen en samenvoegen
Splitsen	public string Split(params char separator) Openbare tekenreeks Splitsen (params char separator, int count)	Een methode die een stringarray retourneert met de substrings die in deze instantie aanwezig zijn, die van elkaar zijn gescheiden door elementen uit de opgegeven char- of stringarray. De eerste vorm van de methode Split() splitst de aanroepende string in zijn samenstellende delen. Het resultaat is een array met de substrings die zijn verkregen uit de aanroepende string. De tekens die deze substrings afbakenen, worden doorgegeven in de separatorarray. Als de scheidingstekenreeks leeg is of verwijst naar de lege tekenreeks, wordt een spatie gebruikt als scheidingsteken voor de subtekenreeks. En in de tweede vorm van deze methode wordt het aantal substrings dat wordt bepaald door de count-parameter geretourneerd.
Splitsen	public string Split (params char separator, StringSplitOptions opties) Openbare tekenreeks splitsen (tekenreeksscheidingsteken, StringSplitOptions-opties) Openbare tekenreeks Split (params char separator, int count, StringSplitOptions-opties) Openbare tekenreeks splitsen (tekenreeksscheidingsteken, int-telling, StringSplitOptions-opties)	In de eerste twee vormen van de methode Split() wordt de aanroepende string in delen gesplitst en wordt een array geretourneerd met de substrings die zijn verkregen uit de aanroepende string. De tekens die deze substrings scheiden, worden doorgegeven in de separatorarray. Als de scheidingstekenreeks leeg is, wordt een spatie als scheidingsteken gebruikt. En in de derde en vierde vorm van deze methode wordt het aantal rijen geretourneerd dat wordt beperkt door de count-parameter. Maar in alle vormen specificeert de optieparameter een specifieke manier om lege regels af te handelen die worden geproduceerd wanneer twee scheidingstekens naast elkaar liggen. De StringSplitOptions-opsomming definieert slechts twee waarden: Geen En Verwijder lege vermeldingen. Als opties Geen is, worden lege tekenreeksen opgenomen in het uiteindelijke splitsingsresultaat van de oorspronkelijke tekenreeks. En als de parameter options is ingesteld op RemoveEmptyEntries, worden lege regels uitgesloten van het eindresultaat van het splitsen van de oorspronkelijke tekenreeks.
Meedoen()	openbare statische tekenreeks Join(tekenreeksscheidingsteken, tekenreekswaarde) Openbare statische tekenreeks Join (tekenreeksscheidingsteken, tekenreekswaarde, int startIndex, int aantal)	Construeert een nieuwe string door de inhoud van een array van strings te combineren. De eerste vorm van de methode Join() retourneert een tekenreeks die bestaat uit aaneengeschakelde subtekenreeksen die in de waardearray worden doorgegeven. De tweede vorm retourneert ook een tekenreeks die bestaat uit de subtekenreeksen die zijn doorgegeven in de waardearray, maar deze zijn aaneengeschakeld in een bepaald aantal, te beginnen met het waardearray-element. In beide vormen wordt elke volgende regel gescheiden van de vorige regel door een scheidingslijn die wordt gespecificeerd door de parameter separator.
Lijnen vullen en trimmen
Bijsnijden()	openbare tekenreeks Trim() Openbare tekenreeks Trim(params char trimChars)	Een methode waarmee u alle exemplaren van een specifieke reeks tekens vanaf het begin en einde van de huidige regel kunt verwijderen. De eerste vorm van de Trim()-methode verwijdert voorloop- en volgspaties uit de aanroepende string. En de tweede vorm van deze methode verwijdert de voorloop- en achterloop van de aanroepende tekenreeks uit de trimChars-array. Beide vormen retourneren de resulterende tekenreeks.
PadLinks()	openbare tekenreeks PadLeft(int totalWidth) Openbare tekenreeks PadLeft(int totalWidth, char opvullingChar)	Hiermee kunt u een tekenreeks met tekens aan de linkerkant opvullen. De eerste vorm van de PadLeft()-methode introduceert spaties aan de linkerkant van de aanroepende string, zodat de totale lengte gelijk wordt aan de waarde van de parameter totalWidth. En in de tweede vorm van deze methode worden de tekens die worden aangegeven door de parameter paddingChar ingevoerd aan de linkerkant van de aanroepende string, zodat de totale lengte gelijk wordt aan de waarde van de parameter totalWidth. Beide vormen retourneren de resulterende tekenreeks. Als de waarde van de parameter totalWidth kleiner is dan de lengte van de aanroepende tekenreeks, wordt een kopie van de ongewijzigde aanroepende tekenreeks geretourneerd.
PadRechts()	Hetzelfde als PadLeft()	Hiermee kunt u een tekenreeks met tekens aan de rechterkant toevoegen.
Rijen invoegen, verwijderen en vervangen
Invoegen()	openbare tekenreeks Insert(int startIndex, tekenreekswaarde)	Wordt gebruikt om de ene rij in de andere in te voegen, waarbij waarde de rij aangeeft die moet worden ingevoegd in de aanroepende rij bij startIndex. De methode retourneert de resulterende tekenreeks.
Verwijderen()	openbare tekenreeks Verwijderen(int startIndex) Openbare tekenreeks Remove(int startIndex, int count)	Wordt gebruikt om een deel van een string te verwijderen. In de eerste vorm van de methode Remove() begint het verwijderen op de locatie aangegeven door startIndex en gaat door tot het einde van de regel. En in de tweede vorm van deze methode wordt het aantal tekens bepaald door de count-parameter uit de string verwijderd, te beginnen vanaf de plaats aangegeven door de startIndex-index.
Vervangen()	openbare tekenreeks Vervangen(char oldChar, char newChar) Openbare tekenreeks Replace(tekenreeks oudeWaarde, tekenreeks nieuweWaarde)	Wordt gebruikt om een deel van een string te vervangen. In de eerste vorm van de Replace()-methode worden alle exemplaren van het teken oldChar in de aanroepende string vervangen door het teken newChar. En in de tweede vorm van deze methode worden alle exemplaren van de string oldValue in de oproepende lijn vervangen door de string newValue.
Verander zaak
NaarBoven()	openbare tekenreeks ToUpper()	Geeft alle letters in de aanroepende reeks een hoofdletter.
Verlagen()	openbare tekenreeks ToLower()	Alle letters in de aanroepende string worden in kleine letters weergegeven.
Een subtekenreeks uit een tekenreeks halen
Subtekenreeks()	openbare tekenreeks Subtekenreeks(int startIndex) Openbare tekenreeks Subtekenreeks(int startIndex, int lengte)	In de eerste vorm van de methode Substring() wordt een subtekenreeks opgehaald vanaf de locatie die wordt aangegeven door de parameter startIndex tot aan het einde van de aanroepende tekenreeks. En in de tweede vorm van deze methode wordt een subtekenreeks geëxtraheerd die bestaat uit het aantal tekens dat wordt bepaald door de lengteparameter, beginnend vanaf de plaats aangegeven door de startIndex-parameter.

Het volgende voorbeeldprogramma gebruikt verschillende van de bovenstaande methoden:

Systeem gebruiken; met behulp van System.Collections.Generic; met behulp van System.Linq; met behulp van System.Text; naamruimte ConsoleApplication1 ( class Program ( static void Main(string args) ( // Vergelijk de eerste twee regels string s1 = "dit is een string"; string s2 = "dit is tekst, en dit is een string"; if (String. CompareOrdinal(s1, s2) != 0) Console.WriteLine("Strings s1 en s2 zijn niet gelijk"); ("Ze bevatten echter dezelfde tekst"); // Aaneenschakeling van tekenreeksen Console.WriteLine(String.Concat("\n" + "Eén, twee", "drie, vier") // Zoeken in een tekenreeks / / Eerste keer dat een subtekenreeks voorkomt if (s2. IndexOf("this") != -1) Console.WriteLine("Het woord \"this\" wordt gevonden in de regel, het is "+ "gelegen op: (0) position", s2.IndexOf("this")); / Laatste exemplaar van de subtekenreeks if (s2.LastIndexOf("this") != -1) Console.WriteLine("Het laatste exemplaar van het woord \"this\" is " + "op (0) positie", s2.LastIndexOf("this" )); // Zoeken vanuit een reeks tekens char myCh = ("Y", "x", "t"); if (s2. IndexOfAny(myCh) != -1) Console.WriteLine("Een van de tekens uit de array ch "+ "gevonden in de huidige regel op positie (0)", s2.IndexOfAny(myCh)); // Bepaal of de regel begint met de opgegeven substring if (s2.StartsWith("this is text") == true) Console.WriteLine("Substring gevonden!"); // Bepaal of de string een substring bevat // gebruik het voorbeeld van het bepalen van de OS-string van de gebruiker myOS = Environment.OSVersion.ToString(); if (myOS.Contains("NT 5.1")) Console.WriteLine("Uw besturingssysteem is Windows XP"); else if (myOS.Contains("NT 6.1")) Console.WriteLine("Uw besturingssysteem is Windows 7"); Console.ReadLine(); ) ) )

Een beetje over stringvergelijking in C#

Waarschijnlijk de meest voorkomende van alle tekenreeksbewerkingen is het vergelijken van de ene tekenreeks met de andere. Voordat we kijken naar methoden voor het vergelijken van tekenreeksen, is het de moeite waard om het volgende te benadrukken: Tekenreeksvergelijkingen kunnen in het .NET Framework op twee manieren worden uitgevoerd:

Ten eerste kan de vergelijking de gewoonten en normen van een bepaalde culturele omgeving weerspiegelen, wat vaak culturele settings zijn die een rol gaan spelen wanneer het programma wordt geïmplementeerd. Dit is standaardgedrag voor sommige, maar niet alle, vergelijkingsmethoden.

En ten tweede kan de vergelijking, ongeacht de culturele instellingen, alleen worden gemaakt op basis van de ordinale waarden van de karakters waaruit de string bestaat. Over het algemeen gebruiken niet-culturele vergelijkingen van strings de lexicografische volgorde (en taalkundige kenmerken) om te bepalen of een string groter, kleiner dan of gelijk is aan een andere string. Bij ordinale vergelijking worden de strings eenvoudigweg geordend op basis van de ongewijzigde waarde van elk teken.

Vanwege de verschillen in de manier waarop culturele tekenreeksvergelijkingen en ordinale vergelijkingen verschillen, en de consequenties van elke dergelijke vergelijking, raden we u ten zeerste aan de best practices te volgen die momenteel door Microsoft worden aangeboden. Het kiezen van de verkeerde methode voor het vergelijken van strings kan immers leiden tot een onjuiste werking van het programma wanneer het wordt gebruikt in een andere omgeving dan waarin het is ontwikkeld.

Kiezen hoe tekenreeksen moeten worden vergeleken, is een zeer belangrijke beslissing. Als algemene regel, en zonder uitzondering, moet u ervoor kiezen om tekenreeksen op een cultureel gevoelige manier te vergelijken als dit wordt gedaan met het doel het resultaat aan de gebruiker weer te geven (bijvoorbeeld om een reeks tekenreeksen weer te geven, gesorteerd in lexicografische volgorde). Maar als de strings vaste informatie bevatten die niet mag worden aangepast vanwege culturele verschillen, zoals een bestandsnaam, trefwoord, websiteadres of beveiligingswaarde, dan moet je kiezen voor ordinale stringvergelijking. Uiteraard zullen de kenmerken van de specifieke applicatie die wordt ontwikkeld de keuze bepalen van een geschikte methode voor het vergelijken van tekenreeksen.

De klasse String biedt verschillende methoden voor het vergelijken van tekenreeksen, die in de bovenstaande tabel worden vermeld. De meest universele daarvan is de Compare()-methode. Hiermee kunnen twee tekenreeksen geheel of gedeeltelijk worden vergeleken, hoofdlettergevoelig of hoofdletterongevoelig, op een manier die wordt gespecificeerd door de parameter type Tekenreeksvergelijking, evenals culturele informatie die wordt verstrekt door de parameter type CultuurInfo.

De overbelastingen van de Compare()-methode die geen parameter van het type StringComparison bevatten, voeren een hoofdletter- en cultuurgevoelige vergelijking van tekenreeksen uit. En in de overbelaste varianten die geen CultureInfo-typeparameter bevatten, wordt informatie over de culturele omgeving bepaald door de huidige runtime-omgeving.

Het type StringComparison is een opsomming die de waarden definieert die in de onderstaande tabel worden weergegeven. Met behulp van deze waarden kunt u tekenreeksvergelijkingen maken die passen bij de behoeften van uw specifieke toepassing. Daarom breidt het toevoegen van een parameter van het type StringComparison de mogelijkheden van de Compare()-methode en andere vergelijkingsmethoden zoals Equals() uit. Dit maakt het ook mogelijk om eenduidig aan te geven hoe strings vergeleken moeten worden.

Vanwege de verschillen tussen cultureel gevoelige stringvergelijkingen en ordinale vergelijkingen is het belangrijk om in dit opzicht zo nauwkeurig mogelijk te zijn.

Waarden gedefinieerd in de StringComparison-opsomming

Betekenis	Beschrijving
HuidigeCultuur	Stringvergelijkingen worden gemaakt met behulp van de huidige culturele omgevingsinstellingen
CurrentCultureIgnoreCase	Tekenreeksvergelijkingen worden gemaakt met behulp van de huidige cultuurinstellingen, maar zijn niet hoofdlettergevoelig
InvariantCultuur	Stringvergelijkingen worden gemaakt met behulp van onveranderlijke, d.w.z. universele gegevens over de culturele omgeving
InvariantCultuurIgnoreCase	Stringvergelijkingen worden gemaakt met behulp van onveranderlijke, d.w.z. universele culturele gegevens en hoofdletterongevoelig
Ordinaal	Stringvergelijkingen worden gemaakt met behulp van de ordinale waarden van de tekens in de string. In dit geval kan de lexicografische orde worden verstoord en worden de conventies die in een bepaalde culturele omgeving zijn aangenomen, genegeerd
OrdinalIgnoreCase	Stringvergelijkingen worden gemaakt met behulp van de ordinale waarden van de tekens in de string, maar zijn niet hoofdlettergevoelig

In ieder geval retourneert de methode Compare() een negatieve waarde als de eerste vergeleken tekenreeks kleiner is dan de tweede; positief als de eerste vergeleken string groter is dan de tweede; en tenslotte nul als beide strings die worden vergeleken gelijk zijn. Hoewel de methode Compare() nul retourneert als de tekenreeksen die worden vergeleken gelijk zijn, is het over het algemeen beter om de methode Equals() of de operator == te gebruiken om te bepalen of tekenreeksen gelijk zijn.

Feit is dat de Compare()-methode de gelijkheid van de vergeleken strings bepaalt op basis van hun sorteervolgorde. Als er dus een culturele vergelijking wordt gemaakt tussen strings, kunnen beide strings hetzelfde zijn in hun sorteervolgorde, maar niet gelijk in essentie. Standaard wordt stringgelijkheid bepaald in de Equals()-methode, op basis van de ordinale waarden van de karakters en zonder rekening te houden met de culturele omgeving. Daarom worden beide tekenreeksen in deze methode standaard met elkaar vergeleken voor absolute, teken-voor-teken gelijkheid, vergelijkbaar met hoe dit wordt gedaan in de == operator.

Ondanks de grote veelzijdigheid van de Compare()-methode, is het voor eenvoudige ordinale vergelijkingen van tekenreeksen eenvoudiger om de CompareOrdinal()-methode te gebruiken. Houd er ten slotte rekening mee dat de methode CompareTo() alleen cultureel gevoelige tekenreeksvergelijkingen uitvoert.

Het volgende programma demonstreert het gebruik van de methoden Compare(), Equals(), CompareOrdinal() en de operatoren == en != om tekenreeksen te vergelijken. Merk op dat de eerste twee vergelijkingsvoorbeelden duidelijk de verschillen aantonen tussen cultureel gevoelige stringvergelijkingen en ordinale vergelijkingen in een Engelssprekende omgeving:

Systeem gebruiken; class Voorbeeld ( static void Main() ( string str1 = "alpha"; string str2 = "Alpha"; string str3 = "Beta"; string str4 = "alpha"; string str5 = "alpha, beta"; int resultaat; / / Demonstreer eerst de verschillen tussen cultuurgevoelige tekenreeksvergelijking // en ordinaal vergelijkingsresultaat = String.Compare(str1, str2, StringComparison.CurrentCulture); (str1 + " groter dan " + str2); Console.WriteLine(str1 + " gelijk aan " + str2); resultaat = String.Compare(str1, str2, StringComparison.Ordinal); ) Console.WriteLine(str1 + " groter dan " + str2); Console.WriteLine(str1 + " gelijk aan " + str4); // Gebruik de CompareOrdinal()-methode resultaat = String.CompareOrdinal( str1, str2); .Write("Teksten vergelijken met CompareOrdinal():\n"); (resultaat 0) Console.WriteLine(str1 + " groter dan " + str2); Console.WriteLine(); // Bepaal de gelijkheid van tekenreeksen met behulp van de == operator // Dit is een ordinale vergelijking van tekenreeksen if (str1 == str4) Console.WriteLine(str1 + " == " + str4); // Definieer lijnongelijkheid met behulp van de != operator if(str1 != str3) Console.WriteLine(str1 + " != " + str3); if(str1 != str2) Console.WriteLine(str1 + " != " + str2); Console.WriteLine(); // Voer een niet-hoofdlettergevoelige ordinale vergelijking van tekenreeksen uit // met behulp van de Equals()-methode if(String.Equals(str1, str2, StringComparison.OrdinalIgnoreCase)) Console.WriteLine("Vergelijking van tekenreeksen met behulp van de Equals()-methode met de " + "OrdinalIgnoreCase-parameter: \n" + str1 + "is gelijk aan " + str2); Console.WriteLine(); // Vergelijk delen van strings if(String.Compare(str2, 0, str5, 0, 3, StringComparison.CurrentCulture) > 0) ( Console.WriteLine("Vergelijk strings rekening houdend met de huidige culturele omgeving:" + "\n3 eerste tekens van de string " + str2 + " meer dan de eerste 3 tekens van de regel " + str5); ) ) )

Het uitvoeren van dit programma levert de volgende uitvoer op: