Forstå flugtsekvenser
Escape-sekvenser i C++ tillader de tegn, der udfører kontrolfunktionerne i strengene, at være en del af teksten uden at blive forvekslet som en kode. En almindelig faldgrube for begyndere er forvirringen over at inkludere citater i en bogstavelig streng. For eksempel vil følgende kodelinje resultere i en kompileringsfejl, fordi anførselstegnene omkring '\t escape-sekvens' afslutter strengen for tidligt:
streng txt = 'Denne artikel handler om at udforske' \t escape-sekvens' ved hjælp af eksempler.' ;For at rette op på dette i et C++-program vil vi bruge omvendt skråstreg '\' som et escape-tegn for at signalere compileren, at det følgende tegn har en speciel fortolkning. Sådan gøres det:
streng txt = 'Denne artikel handler om at udforske\' \\ t escape-sekvens\' ved hjælp af eksempler.' ;
Dykker ned i specialkarakteren (\t) i C++
'\t'-sekvensen er mere end blot et mellemrumsværktøj. Det repræsenterer et tabulatortegn, der får markøren til at skifte til næste tabulatorstop. Dette er især praktisk til at skabe de pænt formaterede tekstvisninger i terminalapplikationer. Ud over '\t' understøtter C++ en række escape-sekvenser til forskellige formål - for eksempel opretter '\n' en ny linje. I denne artikel vil vi imidlertid udelukkende fokusere på '\t'-escape-sekvensen i C++ ved at give eksempler for at demonstrere dens formål og brug. Dette vil give dig viden til at bruge den vandrette fane i dine programmeringsopgaver effektivt. Lad os gå videre til eksemplerne for at forstå, hvordan '\t'-escape-sekvensen fungerer i et C++-program.
Eksempel 1:
Følgende C++ kodeeksempel inkluderer et simpelt program, der bruges til at udskrive teksten til konsollen. Se følgende kode, og vi vil forklare det bagefter:
#include
bruger navneområde std ;
int vigtigste ( ) {
cout << 'Dette er en første tekstlinje.' << endl ;
cout << 'Dette er anden tekstlinje. \t ' ;
cout << 'Denne linje efterfølges af en \\ t flugtsekvens.' ;
Vend tilbage 0 ;
}
Her er en detalje af hver del af koden:
#include
bruger navneområde std; – Denne kode giver dig mulighed for at bruge de navne, der er inkluderet i standardbiblioteket uden at præfikse dem med 'std::'. For eksempel kan du skrive 'cout' i stedet for 'std::cout'.
int main() { – Dette er erklæringen og indgangspunktet for hovedfunktionen for hvert C++-program. 'int' før 'main' angiver typisk, at funktionen returnerer en heltalsværdi.
cout << “Dette er den første tekstlinje.”<
cout << 'Dette er anden tekstlinje.\t'; – Her udsender programmet en anden streng, som er 'Dette er anden tekstlinje.\t'. Bemærk '\t' i slutningen. Når den udskrives til konsollen, tilføjer den et vandret tabulatorum lige efter teksten.
cout << “Denne linje efterfølges af en \\t escape-sekvens.”; – På denne linje udskriver programmet 'Denne linje efterfølges af en \t escape-sekvens'. '\\t'-escape-sekvensen bruges bogstaveligt til at inkludere '\t' i outputtet, da omvendt skråstreg '\' i sig selv er escaped af en anden omvendt skråstreg, så selve '\t' udskrives i stedet for en vandret fane.
returnere 0; – Dette markerer slutningen af hovedfunktionen og returnerer nul, hvilket betyder, at programmet er gennemført. Når dette program kører, ser outputtet sådan ud:
Eksempel 2:
Lad os nu se på et andet eksempel og se magien ved '\t'-escape-karakteren. Eksemplet er et nemt C++-program, der inkluderer et standard input-output stream-bibliotek og bruger standardnavneområdet. Programmet er designet til at udskrive en formateret tabel med navne og deres tilknyttede by og land til konsollen.
#includebruger navneområde std ;
int vigtigste ( ) {
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 Frankrig' << endl ;
cout << 'David \t | \t Durban \t | \t Sydafrika' << endl ;
cout << '--------------------------------------------------------' << endl ;
Vend tilbage 0 ;
}
Her er en opdeling af koden:
En gang til, #include
bruger navneområde std; – Det giver mulighed for at bruge entiteterne fra 'std'-navneområdet uden behov for at præfikse dem med 'std::'.
Det int main() { er indgangspunktet for hvert C++-program. Når du kører programmet, starter udførelsen herfra.
Inden for hovedfunktionen har vi følgende:
cout << “Navn\t|\tBy\t|\tLand”<
cout << “————————————————“<
De næste fire snitlinjer udskriver hver en række af bordet. Disse linjer følger samme format med faner og er en del af oprettelsen af tabeloutputtet. Efter hver linje med data bruges 'endl' til at flytte til næste linje. Den sidste cout-linje udskriver igen separatorlinjen for at angive slutningen af tabellens data.
returner 0;: – Denne linje angiver den succesfulde udførelse af programmet. En returværdi på 0 indikerer succes.
Når dette program er kompileret og kørt, vil output vises som en tabel på konsollen med personernes navne, byer og lande, som er pænt justeret i kolonner adskilt af lodrette streger (|) og faner. Se følgende output:
Bemærk: Husk, at den faktiske justering af teksten i konsollen afhænger af bredden af faneindstillingerne i din konsol eller terminal, hvilket kan resultere i varierende tabeludseende på forskellige systemer.
Eksempel 3:
Dette enkle, men interessante C++-program bruger '\t'-fane-escape-sekvenserne til at udskrive en diamantform på skærmen. Denne kode skalerer diamantstørrelsen baseret på 'diamant'-variablen, som angiver størrelsen og repræsenterer antallet af linjer fra midten af diamanten til dens top eller bund. Tjek følgende givne kode:
#includebruger navneområde std ;
int vigtigste ( ) {
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 ;
}
Vend tilbage 0 ;
}
Som du kan se, består dette program af to dele: den ene udskriver den øverste halvdel af diamanten og den anden udskriver den nederste halvdel. Den øverste halvdel af diamanten udskrives ved først at udskrive et faldende antal tabulatorer for at skabe indrykket, efterfulgt af et stigende antal stjerner '*', adskilt af tabulatorer. Dette håndteres inden for den første 'for'-løkke.
Den nederste halvdel er trykt på samme måde, men med løkkerne itererende omvendt for at mindske antallet af stjerner og øge indrykket igen, hvilket skaber den nederste halvdel af diamanten. Dette håndteres i den anden 'for'-løkke.
Når du kører programmet med 'diamant= 3', ligner outputtet en diamant, der er centreret på skærmen på grund af tabulatortegnene. Se output fra dette særlige program:
Bemærk venligst, at det faktiske udseende kan variere afhængigt af den konsol eller terminal, du bruger, da fanebredderne kan variere.
Konklusion
Escape-sekvenser i C++ er et kraftfuldt værktøj til at repræsentere de tegn, der ikke umiddelbart kan vises i et standardoutputvindue. Blandt disse sekvenser er den vandrette fane, betegnet med '\t', særlig nyttig til at tilføje de kontrollerede vandrette mellemrum i teksten. Ved at bruge '\t' kan programmørerne justere deres tekstoutput, forbedre læsbarheden og strukturere dataene systematisk. Dette tegn imiterer at trykke på 'tab'-tasten på et tastatur, og flytter markøren til den næste tabulatorposition. I denne artikel undersøgte vi funktionaliteten af '\t'-escape-sekvensen i C++-sproget og fremhævede dens anvendelse med ligetil og praktiske eksempler for at illustrere dens adfærd.