C ++ Streng Fjern siste tegn

C ++ strengklassen har mange medlemsfunksjoner. To av dem er POP_BACK () og Slett () -funksjonene. Pop_back () -funksjonen fjerner det siste elementet fra strengen. Sletting () -funksjonen kan slette et element hvor som helst i strengen. Det er tre varianter av slettefunksjonen. De er forskjellige i den typen argumenter de tar. Slike funksjoner med samme navn kalles overbelastede funksjoner.

C ++ strenger kan deklareres på to hovedmåter: som en konstant peker til chars (Array-of-Char) eller instantiert fra strengklassen på strengbiblioteket. Her er POP_BACK () og ERASE () -funksjonene av strengobjektet, instantiert fra strengklassen. Det siste elementet i en matrise-av-chars kan ikke fjernes fordi en matrise-av-sjarer ikke er et instantiert objekt.

Det er sant at en streng bokstavelig består av verdier som er tegn. Hver karakter er innenfor et element. Så strengen bokstavelig består faktisk av elementer. Den siste karakteren fjernes med det siste elementet.

Denne artikkelen forklarer hvordan du fjerner det siste elementet i en streng, sammen med karakteren.

Artikkelinnhold

• ugyldig pop_back ()
• iterator slette (const_iterator p)
• iterator erase (const_iterator først, const_iterator sist)
• BASIC_STRING & ERASE (Size_Type POS = 0, Size_Type N = NPOS)
• Konklusjon

ugyldig pop_back ()

Denne medlemsfunksjonen til strengklassen fjerner det siste elementet i strengen. Funksjonen returnerer tomrom. Dette betyr at ingenting returneres fra det, og ingen variabel kan motta noe som returneres fra det. Bruken av denne funksjonen er illustrert i følgende program:

#inkludere
#inkludere
ved hjelp av navneområdet STD;
int main ()

String str = "lmnopqr";
cout <str.pop_back ();
for (int i = 0; icout <cout <retur 0;

Utgangen er:

Lmnopqr
Lmnopq

Den siste karakteren er fjernet. De to første linjene i programmet inkluderer de nødvendige bibliotekene. En av dem er selvfølgelig strengbiblioteket. Strengbiblioteket må inkluderes siden alle involverte strenger blir instantiert fra strengklassen. Neste linje er en uttalelse. Den erklærer at alle navn under det er av standard navneområdet med mindre annet er angitt.

Hovedfunksjonen () funksjonen begynner med erklæringen (instantiering) av strengobjektet. Neste uttalelse viser den bokstavelige av denne nylig erklærte strengen ved utgangen. Uttalelsen etter fjerner den siste tegnet ved å bruke POP_BACK () medlemsfunksjonen. Neste kodesegment bruker en for-loop med indekser for å vise alle tegnene, som ikke lenger har det siste, i en kontinuerlig sekvens.

iterator slette (const_iterator p)

Hvis iteratoren peker på det siste elementet (karakter), kan slette medlemsfunksjonen fjerne det siste elementet. Denne funksjonen returnerer en iterator som peker på elementet like etter den som ble fjernet (eller like etter det siste elementet, hvis den fjernet var det siste elementet). Følgende program illustrerer dette:

#inkludere
#inkludere
ved hjelp av navneområdet STD;
int main ()

String str = "lmnopqr";
cout <streng :: iterator p = str.slutt();
p--;
streng :: iterator it = str.slette (p);
for (int i = 0; icout <cout <retur 0;

Utgangen er:

Lmnopqr
Lmnopq

De tre første linjene i programmet blir forklart på samme måte som det forrige programmet. I hovedkroppen () er den første uttalelsen erklærer strengobjektet. Neste uttalelse viser den bokstavelige av denne nylig erklærte strengen ved utgangen. Denne utskriften kunne fortsatt ha blitt gjort med en for-loop. Uttalelsen etter oppnår en iterator som peker rett etter det siste karakterelementet. Dette gjøres med medlemsfunksjonen, slutt (). Legg merke til hvordan iteratoren ble erklært (venstre side av, =). Da blir iteratoren dekrementert for å peke på det siste elementet.

Deretter fjernes det siste elementet med slettingsmedlemmets funksjonsfunksjon (). Neste kodesegment bruker en for-loop med indekser for å vise alle tegnene, som ikke lenger har den siste på terminalen i en kontinuerlig sekvens.

iterator erase (const_iterator først, const_iterator sist)

Denne medlemsfunksjonen ville slette en rekke karakterelementer fra strengen. Her er først en iterator som peker på det første elementet i området. Iteratoren returnerte peker på elementet som var der, like etter rekkevidden. Hvis det ikke var noen elementer der, ville det peke på slutten av strengen. Sist er en iterator som peker på det siste elementet i området. Dette siste elementet er ikke involvert i slettingen.

For å fjerne det siste elementet, er trikset å gjøre "sist", peke rett utover det siste elementet i strengen; og gjør det "første" poenget på det siste elementet i strengen. Med alt dette vil slettefunksjonen ta av det siste elementet. Følgende program viser hvordan det gjøres:

#inkludere
#inkludere
ved hjelp av navneområdet STD;
int main ()

String str = "lmnopqr";
cout <streng :: iterator p = str.begynne();
P = P + 6;
String :: iterator q = str.slutt();
streng :: iterator it = str.slette (p, q);
for (det = -det; det> = str.begynne(); den--)
cout << *it;
cout <retur 0;

Utgangen er:

Lmnopqr
Qponml

Etter å ha fjernet tegnet, R (sammen med elementet), ble den gjenværende strengen trykt karakter-for-karakter, men i omvendt rekkefølge.

De tre første linjene i programmet blir forklart på samme måte som det forrige programmet. I hovedkroppen () er den første uttalelsen erklærer strengobjektet. Neste uttalelse skriver ut den nylig erklærte strengen.

Kodesegmentet som følger har tre uttalelser. Den første erklærer en iterator som peker på strengens første karakter. Seks tegn til i strengen må telles før den siste tegnet, 'R' er nådd. Så den andre uttalelsen til dette segmentet legger 6 til iteratoren. Den neste uttalelsen i dette segmentet erklærer en iterator, Q, som peker rett etter enden av strengen. Situasjonen er nå satt for å slette det siste elementet: Q peker rett etter 'R' og P peker til 'R'.

Uttalelsen som sletter 'R' er:

streng :: iterator it = str.slette (p, q);

Etter at 'R' er slettet, blir den siste karakteren 'Q'. Den returnerte iteratoren, 'It' Here, peker like etter 'Q'.

Neste kodesegment er en for-loop. Initialiseringsuttalelsen av denne for-loopen reduserer ganske enkelt “det” for å peke på den nye siste karakteren, 'q'. 'Q' skrives ut til terminalen. For-loopen fortsetter å redusere "det", og trykker den tilsvarende karakteren, mens 'det' er større enn STR.begynne(). Når “det” er lik STR.Begynn (), det vil si at "det" peker på 'L', for-loop-utskrifter 'L' og stopper. På denne måten skrives strengen uten 'R' i omvendt rekkefølge.

For å oppnå verdien som er pekt til en iterator, kan du gå foran iteratoren med indireksjonsoperatøren, * .

BASIC_STRING & ERASE (Size_Type POS = 0, Size_Type N = NPOS)

Denne medlemsfunksjonen sletter et område, akkurat som ovennevnte funksjon. Imidlertid bruker den indekser og ikke iteratorer. Hvis argumentet POS er 0, begynner området fra det første elementet. Hvis argumentet n er lengden på strengen (antall tegn), slutter området med siste karakter. Begge argumentene har standardverdiene. Denne funksjonen returnerer strengklasseobjektet, med tegnene på området fjernet.

Trikset å spille her er å gjøre verdien av POS til indeksen for den siste karakteren. Indeksen for det siste tegnet (elementet) er størrelsen (lengden) på listen minus 1. Det andre argumentet her bør utelates for dette problemet. Den siste indeksen er gitt av,

str.størrelse () - 1

Følgende program bruker denne medlemsfunksjonen, for å ta av den siste tegnet, 'R' fra strengen:

#inkludere
#inkludere
ved hjelp av navneområdet STD;
int main ()

String str = "lmnopqr";
cout <int l = str.størrelse () - 1;
String ret = str.slette (l);
for (int i = 0; i cout <cout <for (int i = 0; i cout <cout <retur 0;

Utgangen er:

Lmnopqr
Lmnopq
Lmnopq

Både den originale og returnerte strengen mistet 'r'. De tre første linjene i programmet blir forklart på samme måte som det forrige programmet. I hovedkroppen () er den første uttalelsen erklærer strengobjektet. Neste uttalelse skriver ut den nylig erklærte strengen.

Neste uttalelse bestemmer indeksen for det siste elementet i den opprinnelige strengen. Uttalelsen etter slettet den siste tegnet ved hjelp av denne indeksen. Neste kodesegment skriver ut tegnene på returstrengen, en etter en, ved hjelp av indekser. Det siste kodesegmentet skriver ut tegnene til den opprinnelige strengen, en etter en, ved hjelp av indekser.

Konklusjon

Den normale strengklassemedlemmer funksjonen, for å fjerne den siste tegnet til en streng, med dets element som holder den, er POP_BACK () -funksjonen. Det er tre sletting () overbelastede medlemsfunksjoner som også kan brukes til dette. En av dem tar en iterator som peker på den siste karakteren og fjerner den siste karakteren. En annen tar et område, indikert av to iteratorer: den ene iteratoren peker på den siste karakteren, og de andre punktene like etter den siste karakteren. Med det blir den siste karakteren tatt av. Den tredje overbelastede funksjonen bruker indeksen for den siste karakteren for å fjerne den. All diskusjonen i denne artikkelen har vært C ++ 20 kompatibel.