Ontsnappingssequenties begrijpen
Escape-reeksen in C++ zorgen ervoor dat de tekens die de besturingsfuncties binnen de tekenreeksen uitvoeren, deel uitmaken van de tekst zonder dat ze als code worden aangezien. Een veel voorkomende valkuil voor beginners is de verwarring over het opnemen van aanhalingstekens in een letterlijke tekenreeks. De volgende coderegel resulteert bijvoorbeeld in een compilatiefout omdat de aanhalingstekens rond “\t escape sequence” de tekenreeks voortijdig beëindigen:
tekenreeks txt = 'Dit artikel gaat over het verkennen van de' \T escape sequence” met behulp van voorbeelden.' ;Om dit in een C++-programma te corrigeren, gebruiken we de backslash “\” als escape-teken om de compiler te laten weten dat het volgende teken een speciale interpretatie heeft. Zo werkt het:
tekenreeks txt = 'Dit artikel gaat over het verkennen van de\' \\ t escape sequence\” met behulp van voorbeelden.' ;
Duiken in het speciale teken (\t) in C++
De reeks “\t” is meer dan alleen een hulpmiddel voor de spatiëring. Het vertegenwoordigt een tabteken dat ervoor zorgt dat de cursor naar de volgende tabstop verschuift. Dit is vooral handig voor het maken van netjes opgemaakte tekstweergaven in terminaltoepassingen. Naast “\t” ondersteunt C++ een verscheidenheid aan ontsnappingsreeksen voor verschillende doeleinden; “\n” maakt bijvoorbeeld een nieuwe regel. In dit artikel zullen we ons echter uitsluitend concentreren op de ontsnappingssequentie “\t” in C++ door voorbeelden te geven om het doel en gebruik ervan te demonstreren. Dit geeft u de kennis om het horizontale tabblad effectief in uw programmeertaken te gebruiken. Laten we verder gaan met de voorbeelden om de werking van de “\t” escape-reeks in een C++-programma te begrijpen.
Voorbeeld 1:
Het volgende C++-codevoorbeeld bevat een eenvoudig programma dat wordt gebruikt om de tekst naar de console af te drukken. Raadpleeg de volgende code en we zullen het daarna uitleggen:
#include
namespace std; gebruiken ;
int voornaamst ( ) {
uit << 'Dit is een eerste regel tekst.' << eindl ;
uit << ‘Dit is de tweede regel tekst. \T ' ;
uit << 'Deze lijn wordt gevolgd door een \\ t ontsnappingsreeks.' ;
opbrengst 0 ;
}
Hier is een detail van elk deel van de code:
#include
namespace std; gebruiken; – Met deze code kunt u de namen gebruiken die in de standaardbibliotheek zijn opgenomen, zonder dat er “std::” voor staat. U kunt bijvoorbeeld 'cout' schrijven in plaats van 'std::cout'.
int hoofd() { – Dit is de declaratie en het startpunt van de hoofdfunctie voor elk C++-programma. De “int” vóór “main” geeft doorgaans aan dat de functie een geheel getal retourneert.
cout << “Dit is de eerste regel tekst.”<
cout << “Dit is de tweede regel tekst.\t”; – Hier voert het programma nog een tekenreeks uit, namelijk 'Dit is de tweede regel tekst.\t'. Let op de “\t” aan het einde. Wanneer het naar de console wordt afgedrukt, wordt er direct na de tekst een horizontale tabruimte toegevoegd.
cout << “Deze regel wordt gevolgd door een \\t escape-reeks.”; – Op deze regel drukt het programma af: 'Deze regel wordt gevolgd door een \t-escape-reeks.'. De ontsnappingsreeks “\\t” wordt gebruikt om letterlijk “\t” in de uitvoer op te nemen, aangezien de backslash “\” zelf wordt geëscaped door een andere backslash, zodat “\t” zelf wordt afgedrukt in plaats van een horizontaal tabblad.
retour 0; – Dit markeert het einde van de hoofdfunctie en retourneert nul, wat de succesvolle uitvoering van het programma aangeeft. Wanneer dit programma wordt uitgevoerd, ziet de uitvoer er als volgt uit:
Voorbeeld 2:
Laten we nu naar een ander voorbeeld kijken en de magie van het ontsnappingskarakter “\t” zien. Het voorbeeld is een eenvoudig C++-programma dat een standaard invoer-uitvoerstreambibliotheek bevat en de standaardnaamruimte gebruikt. Het programma is ontworpen om een opgemaakte tabel met namen en de bijbehorende stad en land naar de console af te drukken.
#includenamespace std; gebruiken ;
int voornaamst ( ) {
uit << 'Naam \T | \T Stad \T | \T Land' << eindl ;
uit << '---------------------------------------' << eindl ;
uit << 'Alice \T | \T Peking \T | \T China' << eindl ;
uit << 'Bob \T | \T Austin \T | \T Amerika' << eindl ;
uit << 'Kathe \T | \T Parijs \T | \T Frankrijk' << eindl ;
uit << 'David \T | \T Durban \T | \T Zuid-Afrika' << eindl ;
uit << '---------------------------------------' << eindl ;
opbrengst 0 ;
}
Hier is een overzicht van de code:
Opnieuw, #include
namespace std; gebruiken; – Het maakt het mogelijk om de entiteiten uit de “std” naamruimte te gebruiken zonder dat ze voorafgegaan moeten worden door “std::”.
De int hoofd() { is het startpunt van elk C++-programma. Wanneer u het programma uitvoert, begint de uitvoering vanaf hier.
Binnen de hoofdfunctie hebben we het volgende:
cout << “Naam\t|\tStad\t|\tLand”<
cout << “———————————————-“<
De volgende vier afleglijnen drukken elk een rij van de tabel af. Deze regels volgen hetzelfde formaat met tabbladen en maken deel uit van het maken van de tabeluitvoer. Na elke regel met gegevens wordt “endl” gebruikt om naar de volgende regel te gaan. De laatste lijn drukt opnieuw de scheidingslijn af om het einde van de tabelgegevens aan te geven.
retour 0;: – Deze regel geeft de succesvolle uitvoering van het programma aan. Een retourwaarde van 0 duidt op succes.
Wanneer dit programma is gecompileerd en uitgevoerd, zal de uitvoer verschijnen als een tabel op de console met de namen, steden en landen van de individuen, netjes uitgelijnd in kolommen gescheiden door verticale balken (|) en tabbladen. Zie de volgende uitvoer:
Opmerking: Houd er rekening mee dat de daadwerkelijke uitlijning van de tekst in de console afhangt van de breedte van de tabbladinstellingen in uw console of terminal, wat kan resulteren in verschillende tabelweergaven op verschillende systemen.
Voorbeeld 3:
Dit eenvoudige maar interessante C++-programma maakt gebruik van de “\t”-tab-escape-reeksen om een ruitvorm op het scherm af te drukken. Deze code schaalt de diamantgrootte op basis van de “diamant”-variabele die de grootte specificeert en het aantal lijnen vertegenwoordigt vanaf het midden van de diamant naar de boven- of onderkant. Controleer de volgende gegeven code:
#includenamespace std; gebruiken ;
int voornaamst ( ) {
int diamant = 3 ;
voor ( int i = 1 ; i <= diamant ; ++ i ) {
voor ( int J = 0 ; J < diamant - i ; ++ J ) {
uit << ' \T ' ;
}
voor ( int J = 0 ; J < 2 * i - 1 ; ++ J ) {
uit << '* \T ' ; }
uit << eindl ;
}
voor ( int i = diamant - 1 ; i >= 1 ; -- i ) {
voor ( int J = 0 ; J < diamant - i ; ++ J ) {
uit << ' \T ' ;
}
voor ( int J = 0 ; J < 2 * i - 1 ; ++ J ) {
uit << '* \T ' ; }
uit << eindl ;
}
opbrengst 0 ;
}
Zoals u kunt zien bestaat dit programma uit twee delen: het ene drukt de bovenste helft van de diamant af en het andere drukt de onderste helft af. De bovenste helft van de ruit wordt afgedrukt door eerst een kleiner aantal tabs uit te voeren om de inspringing te creëren, gevolgd door een toenemend aantal sterretjes “*”, gescheiden door tabs. Dit wordt afgehandeld binnen de eerste “for”-lus.
De onderste helft wordt op dezelfde manier afgedrukt, maar met de lussen in omgekeerde volgorde om het aantal sterretjes te verkleinen en de inspringing weer te vergroten, waardoor de onderste helft van de ruit ontstaat. Dit wordt afgehandeld in de tweede “for”-lus.
Wanneer het programma wordt uitgevoerd met “diamond= 3”, ziet de uitvoer eruit als een ruit die gecentreerd is op het scherm vanwege de tabtekens. Bekijk de uitvoer van dit specifieke programma:
Houd er rekening mee dat het werkelijke uiterlijk kan verschillen, afhankelijk van de console of terminal die u gebruikt, omdat de tabbreedtes kunnen variëren.
Conclusie
Escape-reeksen in C++ zijn een krachtig hulpmiddel voor het weergeven van tekens die niet gemakkelijk kunnen worden weergegeven in een standaarduitvoervenster. Van deze reeksen is de horizontale tab, aangegeven met “\t”, vooral handig voor het toevoegen van gecontroleerde horizontale spaties in de tekst. Met behulp van “\t” kunnen programmeurs hun tekstuitvoer uitlijnen, de leesbaarheid verbeteren en de gegevens systematisch structureren. Dit teken imiteert het indrukken van de “tab”-toets op een toetsenbord, waardoor de cursor naar de volgende tabpositie wordt verplaatst. In dit artikel hebben we de functionaliteit van de “\t”-escape-reeks binnen de C++-taal onderzocht, waarbij we de toepassing ervan benadrukken met duidelijke en praktische voorbeelden om het gedrag ervan te illustreren.