Разбиране на Escape Sequences
Escape последователностите в C++ позволяват знаците, които изпълняват контролните функции в рамките на низовете, да бъдат част от текста, без да бъдат объркани като код. Един често срещан капан за начинаещи е объркването при включването на кавички в буквален низ. Например, следният ред от код ще доведе до грешка при компилиране, защото кавичките около „\t escape sequence“ прекратяват низа преждевременно:
низ txt = „Тази статия е за изследване на „ \T изходна последователност' с помощта на примери.' ;За да коригираме това в C++ програма, ще използваме обратната наклонена черта “\” като екраниращ знак, за да сигнализираме на компилатора, че следващият знак има специална интерпретация. Ето как се прави:
низ txt = „Тази статия е за изследване на\ “ \\ бягстваща последователност\” с помощта на примери. ;
Гмуркане в специалния символ (\t) в C++
Последователността „\t“ е нещо повече от инструмент за разпределение. Той представлява табулатор, който кара курсора да се премести към следващия табулатор. Това е особено удобно за създаване на спретнато форматирани текстови дисплеи в терминални приложения. Освен „\t“, C++ поддържа различни последователности за изход за различни цели – например „\n“ създава нов ред. Въпреки това, в тази статия ще се съсредоточим единствено върху последователността за избягване на „\t“ в C++, като предоставим примери, за да демонстрираме нейната цел и употреба. Това ще ви даде знанията за ефективно използване на хоризонталния раздел във вашите програмни задачи. Нека преминем към примерите, за да разберем работата на екраниращата последователност „\t“ в C++ програма.
Пример 1:
Следният пример на C++ код включва проста програма, която се използва за отпечатване на текста в конзолата. Обърнете се към следния код и ние ще го обясним след това:
#include
използване на пространство от имена std ;
вътр основен ( ) {
cout << „Това е първи ред от текст.“ << endl ;
cout << „Това е втори ред от текст. \T ' ;
cout << „Този ред е последван от a \\ бягстваща последователност.' ;
връщане 0 ;
}
Ето подробности за всяка част от кода:
#include
използване на пространство от имена std; – Този код ви позволява да използвате имената, които са включени в стандартната библиотека, без да им поставяте префикс „std::“. Например, можете да напишете „cout“ вместо „std::cout“.
int main() { – Това е декларацията и входната точка на основната функция за всяка C++ програма. „Int“ преди „main“ обикновено показва, че функцията връща целочислена стойност.
cout << “Това е първият ред от текст.”<
cout << “Това е втори ред от текст.\t”; – Тук програмата извежда друг низ, който е „Това е втори ред от текст.\t“. Обърнете внимание на '\t' в края. Когато се отпечата в конзолата, той добавя хоризонтален табулатор веднага след текста.
cout << „Този ред е последван от \\t изходна последователност.“; – В този ред програмата отпечатва „Този ред е последван от \t изходна последователност.“. Екраниращата последователност “\\t” се използва за буквално включване на “\t” в изхода, тъй като самата обратна наклонена черта “\” е екранирана от друга обратна наклонена черта, така че самият “\t” се отпечатва вместо хоризонтален раздел.
връщане 0; – Това маркира края на основната функция и връща нула, което означава успешното изпълнение на програмата. Когато тази програма се изпълнява, изходът изглежда така:
Пример 2:
Сега нека разгледаме друг пример и да видим магията на символа за избягване на „\t“. Примерът е лесна C++ програма, която включва стандартна библиотека за входно-изходни потоци и използва стандартното пространство от имена. Програмата е предназначена да отпечата на конзолата форматирана таблица с имена и свързаните с тях град и държава.
#includeизползване на пространство от имена std ;
вътр основен ( ) {
cout << „Име \T | \T град \T | \T Държава' << endl ;
cout << '------------------------------------------' << endl ;
cout << „Алис \T | \T Пекин \T | \T Китай' << endl ;
cout << „Боб \T | \T Остин \T | \T Америка' << endl ;
cout << „Кейт \T | \T Париж \T | \T Франция' << endl ;
cout << „Дейвид \T | \T Дърбан \T | \T Южна Африка' << endl ;
cout << '------------------------------------------' << endl ;
връщане 0 ;
}
Ето разбивка на кода:
Отново, #include
използване на пространство от имена std; – Позволява да се използват обектите от пространството на имената „std“, без да е необходимо да им се добавя префикс „std::“.
The int main() { е входната точка на всяка C++ програма. Когато стартирате програмата, изпълнението започва от тук.
В рамките на основната функция имаме следното:
cout << “Име\t|\tГрад\t|\tДържава”<
cout << “———————————————-“<
Всеки от следващите четири cout реда отпечатва ред от таблицата. Тези редове следват същия формат с раздели и са част от създаването на изхода на таблицата. След всеки ред с данни „endl“ се използва за преминаване към следващия ред. Последният ред на cout отново отпечатва разделителната линия, за да посочи края на данните в таблицата.
върне 0;: – Този ред показва успешното изпълнение на програмата. Върната стойност 0 показва успех.
Когато тази програма бъде компилирана и стартирана, изходът ще се появи като таблица на конзолата с имената на хората, градовете и държавите, които са добре подравнени в колони, разделени от вертикални ленти (|) и раздели. Вижте следния резултат:
Забележка: Не забравяйте, че действителното подравняване на текста в конзолата зависи от ширината на настройките на раздела във вашата конзола или терминал, което може да доведе до различни изяви на таблици в различните системи.
Пример 3:
Тази проста, но интересна C++ програма използва екраниращите последователности на раздела „\t“, за да отпечата диамантена форма на екрана. Този код мащабира размера на диаманта въз основа на променливата „диамант“, която определя размера и представлява броя на линиите от центъра на диаманта до горната или долната част. Проверете следния даден код:
#includeизползване на пространство от имена std ;
вътр основен ( ) {
вътр диамант = 3 ;
за ( вътр аз = 1 ; аз <= диамант ; ++ аз ) {
за ( вътр й = 0 ; й < диамант - аз ; ++ й ) {
cout << ' \T ' ;
}
за ( вътр й = 0 ; й < 2 * аз - 1 ; ++ й ) {
cout << '* \T ' ; }
cout << endl ;
}
за ( вътр аз = диамант - 1 ; аз >= 1 ; -- аз ) {
за ( вътр й = 0 ; й < диамант - аз ; ++ й ) {
cout << ' \T ' ;
}
за ( вътр й = 0 ; й < 2 * аз - 1 ; ++ й ) {
cout << '* \T ' ; }
cout << endl ;
}
връщане 0 ;
}
Както можете да видите, тази програма се състои от две части: едната отпечатва горната половина на диаманта, а другата отпечатва долната половина. Горната половина на диаманта се отпечатва, като първо се извеждат намаляващ брой раздели, за да се създаде отстъп, последван от нарастващ брой звездички „*“, разделени с раздели. Това се обработва в рамките на първия цикъл „for“.
Долната половина се отпечатва по подобен начин, но като циклите се повтарят в обратен ред, за да се намали броят на звездичките и отново да се увеличи отстъпът, създавайки долната половина на диаманта. Това се обработва във втория цикъл 'for'.
Когато стартирате програмата с „диамант= 3“, изходът изглежда като диамант, който е центриран на екрана поради знаците за разделяне. Вижте резултата от тази конкретна програма:
Моля, обърнете внимание, че действителният вид може да се различава в зависимост от конзолата или терминала, които използвате, тъй като ширината на разделите може да варира.
Заключение
Escape последователностите в C++ са мощен инструмент за представяне на знаци, които не могат да бъдат показани лесно в стандартен изходен прозорец. Сред тези последователности хоризонталният раздел, означен с „\t“, е особено полезен за добавяне на контролирани хоризонтални интервали в текста. Използвайки „\t“, програмистите могат да подравнят изходния текст, да подобрят четливостта и да структурират данните систематично. Този знак имитира натискане на клавиша „tab“ на клавиатурата, придвижвайки курсора до следващата позиция на раздела. В тази статия проучихме функционалността на escape-последователността „\t“ в рамките на езика C++, подчертавайки нейното приложение с ясни и практически примери, за да илюстрираме нейното поведение.