Forstå rømningssekvenser
Escape-sekvenser i C++ lar tegnene som utfører kontrollfunksjonene i strengene være en del av teksten uten å forveksles som en kode. En vanlig fallgruve for nybegynnere er forvirringen over å inkludere anførselstegn i en bokstavelig streng. For eksempel vil følgende kodelinje resultere i en kompileringsfeil fordi anførselstegnene rundt '\t escape-sekvens' avslutter strengen for tidlig:
streng txt = 'Denne artikkelen handler om å utforske \t escape-sekvens' ved hjelp av eksempler.' ;For å rette opp dette i et C++-program, vil vi bruke omvendt skråstrek «\» som et escape-tegn for å signalisere kompilatoren at følgende tegn har en spesiell tolkning. Slik gjøres det:
streng txt = 'Denne artikkelen handler om å utforske \\ t escape sequence\' ved hjelp av eksempler.' ;
Dykke inn i spesialtegnet (\t) i C++
'\t'-sekvensen er mer enn bare et mellomromsverktøy. Det representerer et tabulatortegn som får markøren til å skifte til neste tabulatorstopp. Dette er spesielt nyttig for å lage pent formaterte tekstvisninger i terminalapplikasjoner. Utover '\t', støtter C++ en rekke escape-sekvenser for forskjellige formål - for eksempel oppretter '\n' en ny linje. I denne artikkelen vil vi imidlertid fokusere utelukkende på '\t'-escape-sekvensen i C++ ved å gi eksempler for å demonstrere formålet og bruken. Dette vil gi deg kunnskapen til å bruke den horisontale kategorien i programmeringsoppgavene dine effektivt. La oss gå videre til eksemplene for å forstå hvordan '\t'-escape-sekvensen fungerer i et C++-program.
Eksempel 1:
Følgende C++-kodeeksempel inkluderer et enkelt program som brukes til å skrive ut teksten til konsollen. Se følgende kode, og vi vil forklare det etterpå:
#include
bruker navneområde std ;
int hoved- ( ) {
cout << 'Dette er en første linje med tekst.' << endl ;
cout << 'Dette er andre tekstlinje. \t ' ;
cout << 'Denne linjen blir fulgt av en \\ t escape-sekvens.' ;
komme tilbake 0 ;
}
Her er en detalj av hver del av koden:
#include
bruker navneområde std; – Denne koden lar deg bruke navnene som er inkludert i standardbiblioteket uten å prefiksere dem med 'std::'. Du kan for eksempel skrive 'cout' i stedet for 'std::cout'.
int main() { – Dette er erklæringen og inngangspunktet for hovedfunksjonen for hvert C++-program. 'int' før 'main' indikerer vanligvis at funksjonen returnerer en heltallsverdi.
cout << “Dette er den første tekstlinjen.”<
cout << “Dette er andre tekstlinje.\t”; – Her sender programmet ut en annen streng som er 'This is second line of text.\t'. Legg merke til '\t' på slutten. Når den skrives ut på konsollen, legger den til et horisontalt tabulatorrom rett etter teksten.
cout << “Denne linjen følges av en \\t escape-sekvens.”; – På denne linjen skriver programmet 'Denne linjen etterfølges av en \t escape-sekvens'. '\\t'-escape-sekvensen brukes til å bokstavelig talt inkludere '\t' i utdataene siden omvendt skråstrek '\' i seg selv er escaped av en annen omvendt skråstrek slik at selve '\t' skrives ut i stedet for en horisontal tabulator.
returner 0; – Dette markerer slutten på hovedfunksjonen og returnerer null som betyr vellykket kjøring av programmet. Når dette programmet kjører, ser utdataene slik ut:
Eksempel 2:
La oss nå se på et annet eksempel og se magien til '\t'-escape-karakteren. Eksemplet er et enkelt C++-program som inkluderer et standard input-output-strømbibliotek og bruker standard navneområde. Programmet er designet for å skrive ut en formatert tabell med navn og deres tilhørende by og land til konsollen.
#includebruker navneområde std ;
int hoved- ( ) {
cout << 'Navn \t | \t By \t | \t Land' << endl ;
cout << '---------------------------------------------------' << endl ;
cout << 'Alice \t | \t Beijing \t | \t Kina' << endl ;
cout << 'Bob \t | \t Austin \t | \t Amerika' << endl ;
cout << 'Cathe \t | \t Paris \t | \t Frankrike' << endl ;
cout << 'David \t | \t Durban \t | \t Sør-Afrika' << endl ;
cout << '---------------------------------------------------' << endl ;
komme tilbake 0 ;
}
Her er en oversikt over koden:
En gang til, #include
bruker navneområde std; – Den lar deg bruke enhetene fra 'std'-navneområdet uten å måtte prefiksere dem med 'std::'.
De int main() { er inngangspunktet for hvert C++-program. Når du kjører programmet, starter kjøringen herfra.
Innenfor hovedfunksjonen har vi følgende:
cout << “Navn\t|\tBy\t|\tLand”<
cout << “————————————————“<
De neste fire utsnittslinjene skriver ut en rad av tabellen. Disse linjene følger samme format med tabulatorer og er en del av å lage tabellutdata. Etter hver linje med data brukes 'endl' for å gå til neste linje. Den siste utstrekningslinjen skriver ut skillelinjen igjen for å indikere slutten av tabellens data.
returner 0;: – Denne linjen indikerer vellykket kjøring av programmet. En returverdi på 0 indikerer suksess.
Når dette programmet er kompilert og kjørt, vil utdataene vises som en tabell på konsollen med enkeltpersoners navn, byer og land som er pent justert i kolonner atskilt med vertikale streker (|) og faner. Se følgende utgang:
Merk: Husk at den faktiske justeringen av teksten i konsollen avhenger av bredden på faneinnstillingene i konsollen eller terminalen, noe som kan resultere i varierende tabellutseende på forskjellige systemer.
Eksempel 3:
Dette enkle, men interessante C++-programmet bruker '\t'-fane-escape-sekvensene for å skrive ut en diamantform på skjermen. Denne koden skalerer diamantstørrelsen basert på 'diamant'-variabelen som spesifiserer størrelsen og representerer antall linjer fra midten av diamanten til toppen eller bunnen. Sjekk følgende gitte kode:
#includebruker navneområde std ;
int hoved- ( ) {
int diamant = 3 ;
til ( int Jeg = 1 ; Jeg <= diamant ; ++ Jeg ) {
til ( int j = 0 ; j < diamant - Jeg ; ++ j ) {
cout << ' \t ' ;
}
til ( int j = 0 ; j < 2 * Jeg - 1 ; ++ j ) {
cout << '* \t ' ; }
cout << endl ;
}
til ( int Jeg = diamant - 1 ; Jeg >= 1 ; -- Jeg ) {
til ( int j = 0 ; j < diamant - Jeg ; ++ j ) {
cout << ' \t ' ;
}
til ( int j = 0 ; j < 2 * Jeg - 1 ; ++ j ) {
cout << '* \t ' ; }
cout << endl ;
}
komme tilbake 0 ;
}
Som du kan se, består dette programmet av to deler: en skriver ut den øvre halvdelen av diamanten og den andre skriver ut den nedre halvdelen. Den øvre halvdelen av diamanten skrives ut ved først å skrive ut et avtagende antall tabulatorer for å lage innrykk, etterfulgt av et økende antall stjerner '*', atskilt med tabulatorer. Dette håndteres innenfor den første 'for'-løkken.
Den nedre halvdelen er trykt på samme måte, men med løkkene itererende i revers for å redusere antall stjerner og øke innrykk igjen, og skape den nederste halvdelen av diamanten. Dette håndteres i den andre 'for'-løkken.
Når du kjører programmet med 'diamond= 3', ser utgangen ut som en diamant som er sentrert på skjermen på grunn av tabulatortegnene. Se resultatet av dette spesielle programmet:
Vær oppmerksom på at det faktiske utseendet kan variere avhengig av konsollen eller terminalen du bruker, da fanebreddene kan variere.
Konklusjon
Escape-sekvenser i C++ er et kraftig verktøy for å representere tegn som ikke lett kan vises i et standard utdatavindu. Blant disse sekvensene er den horisontale fanen, betegnet med '\t', spesielt nyttig for å legge til kontrollerte horisontale mellomrom i teksten. Ved å bruke '\t' kan programmererne justere tekstutdataene sine, forbedre lesbarheten og strukturere dataene systematisk. Dette tegnet imiterer å trykke 'tab'-tasten på et tastatur, og flytter markøren til neste tabulatorposisjon. I denne artikkelen utforsket vi funksjonaliteten til '\t'-escape-sekvensen i C++-språket, og fremhevet dens anvendelse med enkle og praktiske eksempler for å illustrere oppførselen.