Memahami Urutan Melarikan Diri
Urutan melarikan diri dalam C++ membenarkan aksara yang melaksanakan fungsi kawalan dalam rentetan menjadi sebahagian daripada teks tanpa disalah anggap sebagai kod. Satu perangkap biasa untuk pemula ialah kekeliruan untuk memasukkan petikan dalam rentetan literal. Sebagai contoh, baris kod berikut akan mengakibatkan ralat penyusunan kerana petikan di sekitar '\t escape sequence' menamatkan rentetan lebih awal:
rentetan txt = 'Artikel ini adalah mengenai meneroka ' \t urutan melarikan diri' dengan bantuan contoh.' ;Untuk membetulkan ini dalam atur cara C++, kami akan menggunakan garis miring ke belakang '\' sebagai watak melarikan diri untuk memberi isyarat kepada pengkompil bahawa aksara berikut mempunyai tafsiran khas. Begini cara ia dilakukan:
rentetan txt = 'Artikel ini adalah tentang meneroka\ “ \\ t escape sequence\” dengan bantuan contoh.' ;
Menyelam ke dalam Watak Khas (\t) dalam C++
Urutan '\t' adalah lebih daripada sekadar alat jarak. Ia mewakili watak tab yang menyebabkan kursor beralih ke hentian tab seterusnya. Ini amat berguna untuk mencipta paparan teks yang diformat dengan kemas dalam aplikasi terminal. Di luar “\t”, C++ menyokong pelbagai jujukan melarikan diri untuk tujuan yang berbeza—contohnya, “\n” mencipta baris baharu. Walau bagaimanapun, Dalam artikel ini, kami akan menumpukan semata-mata pada jujukan pelarian '\t' dalam C++ dengan memberikan contoh untuk menunjukkan tujuan dan penggunaannya. Ini akan memberi anda pengetahuan untuk menggunakan tab mendatar dalam tugas pengaturcaraan anda dengan berkesan. Mari kita beralih kepada contoh untuk memahami cara kerja jujukan melarikan diri '\t' dalam program C++.
Contoh 1:
Contoh kod C++ berikut termasuk program mudah yang digunakan untuk mencetak teks ke konsol. Rujuk kod berikut dan kami akan menerangkannya selepas itu:
#include
menggunakan ruang nama std ;
int utama ( ) {
cout << 'Ini adalah baris pertama teks.' << endl ;
cout << 'Ini adalah teks baris kedua. \t ' ;
cout << “Barisan ini diikuti oleh a \\ urutan t melarikan diri.' ;
kembali 0 ;
}
Berikut ialah butiran setiap bahagian kod:
#include
menggunakan ruang nama std; – Kod ini membolehkan anda menggunakan nama yang disertakan dalam pustaka standard tanpa memberi awalan dengan 'std::'. Sebagai contoh, anda boleh menulis 'cout' dan bukannya 'std::cout'.
int main() { – Ini ialah pengisytiharan dan titik masuk fungsi utama untuk setiap program C++. 'int' sebelum 'utama' biasanya menunjukkan bahawa fungsi mengembalikan nilai integer.
cout << “Ini ialah baris pertama teks.”<
cout << “Ini ialah baris kedua teks.\t”; – Di sini, program mengeluarkan rentetan lain iaitu 'Ini ialah baris kedua teks.\t'. Perhatikan “\t” di hujungnya. Apabila dicetak pada konsol, ia menambah ruang tab mendatar sejurus selepas teks.
cout << 'Barisan ini diikuti oleh \\t urutan melarikan diri.'; – Dalam baris ini, atur cara mencetak 'Barisan ini diikuti dengan urutan \t melarikan diri.'. Urutan melarikan diri '\\t' digunakan untuk memasukkan '\t' secara literal dalam output kerana garisan sembang ke belakang '\' itu sendiri dilarikan oleh garis serong ke belakang yang lain supaya '\t' itu sendiri dicetak dan bukannya tab mendatar.
pulangan 0; – Ini menandakan berakhirnya fungsi utama dan mengembalikan sifar yang menandakan kejayaan pelaksanaan program. Apabila program ini dijalankan, output kelihatan seperti ini:
Contoh 2:
Sekarang, mari kita lihat contoh lain dan lihat keajaiban watak melarikan diri '\t'. Contohnya ialah program C++ mudah yang merangkumi perpustakaan aliran input-output standard dan menggunakan ruang nama standard. Program ini direka bentuk untuk mencetak jadual nama yang diformat dan bandar serta negara yang berkaitan ke konsol.
#includemenggunakan ruang nama std ;
int utama ( ) {
cout << 'Nama \t | \t Bandar \t | \t negara' << endl ;
cout << '--------------------------------------------------------' << endl ;
cout << 'Alice \t | \t Beijing \t | \t China' << endl ;
cout << 'Bob \t | \t Austin \t | \t Amerika' << endl ;
cout << 'Cathe \t | \t Paris \t | \t Perancis' << endl ;
cout << 'David \t | \t Durban \t | \t Afrika Selatan' << endl ;
cout << '--------------------------------------------------------' << endl ;
kembali 0 ;
}
Berikut ialah pecahan kod:
sekali lagi, #include
menggunakan ruang nama std; – Ia membenarkan untuk menggunakan entiti daripada ruang nama 'std' tanpa perlu mendahuluinya dengan 'std::'.
The int main() { ialah titik masuk setiap program C++. Apabila anda menjalankan program, pelaksanaan bermula dari sini.
Dalam fungsi utama, kami mempunyai yang berikut:
cout << “Nama\t|\tBandar\t|\tNegara”<
cout << “——————————————-“<
Empat baris cout seterusnya masing-masing mencetak satu baris jadual. Baris ini mengikut format yang sama dengan tab dan merupakan sebahagian daripada mencipta output jadual. Selepas setiap baris data, 'endl' digunakan untuk beralih ke baris seterusnya. Baris cout terakhir sekali lagi mencetak garis pemisah untuk menunjukkan penghujung data jadual.
pulangan 0;: – Baris ini menunjukkan kejayaan pelaksanaan program. Nilai pulangan 0 menunjukkan kejayaan.
Apabila program ini disusun dan dijalankan, output akan muncul sebagai jadual pada konsol dengan nama individu, bandar dan negara yang dijajarkan dengan kemas dalam lajur yang dipisahkan oleh bar menegak (|) dan tab. Lihat output berikut:
Catatan: Ingat bahawa penjajaran sebenar teks dalam konsol bergantung pada lebar tetapan tab dalam konsol atau terminal anda yang boleh mengakibatkan penampilan jadual yang berbeza-beza pada sistem yang berbeza.
Contoh 3:
Program C++ yang ringkas tetapi menarik ini menggunakan jujukan pelarian tab '\t' untuk mencetak bentuk berlian pada skrin. Kod ini menskalakan saiz berlian berdasarkan pembolehubah 'berlian' yang menentukan saiz dan mewakili bilangan garisan dari tengah berlian ke bahagian atas atau bawahnya. Semak kod yang diberikan berikut:
#includemenggunakan ruang nama std ;
int utama ( ) {
int berlian = 3 ;
untuk ( int i = 1 ; i <= berlian ; ++ i ) {
untuk ( int j = 0 ; j < berlian - i ; ++ j ) {
cout << ' \t ' ;
}
untuk ( int j = 0 ; j < 2 * i - 1 ; ++ j ) {
cout << '* \t ' ; }
cout << endl ;
}
untuk ( int i = berlian - 1 ; i >= 1 ; -- i ) {
untuk ( int j = 0 ; j < berlian - i ; ++ j ) {
cout << ' \t ' ;
}
untuk ( int j = 0 ; j < 2 * i - 1 ; ++ j ) {
cout << '* \t ' ; }
cout << endl ;
}
kembali 0 ;
}
Seperti yang anda lihat, program ini terdiri daripada dua bahagian: satu mencetak bahagian atas berlian dan satu lagi mencetak bahagian bawah. Bahagian atas berlian dicetak dengan terlebih dahulu mengeluarkan bilangan tab yang semakin berkurangan untuk membuat inden, diikuti dengan peningkatan bilangan asterisk “*”, dipisahkan dengan tab. Ini dikendalikan dalam gelung 'untuk' pertama.
Separuh bahagian bawah dicetak dengan cara yang sama, tetapi dengan gelung berulang secara terbalik untuk mengurangkan bilangan asterisk dan menambah inden sekali lagi, mewujudkan separuh bahagian bawah berlian. Ini dikendalikan dalam gelung 'untuk' kedua.
Apabila menjalankan program dengan 'diamond= 3', output kelihatan seperti berlian yang berpusat pada skrin disebabkan oleh aksara tab. Lihat output program khusus ini:
Sila ambil perhatian bahawa penampilan sebenar mungkin berbeza bergantung pada konsol atau terminal yang anda gunakan kerana lebar tab boleh berbeza-beza.
Kesimpulan
Urutan melarikan diri dalam C++ ialah alat yang berkuasa untuk mewakili aksara yang tidak mudah dipaparkan dalam tetingkap keluaran standard. Antara jujukan ini, tab mendatar, yang dilambangkan dengan '\t', amat berguna untuk menambah ruang mendatar terkawal dalam teks. Menggunakan '\t', pengaturcara boleh menyelaraskan output teks mereka, meningkatkan kebolehbacaan dan menstruktur data secara sistematik. Watak ini meniru menekan kekunci 'tab' pada papan kekunci, memajukan kursor ke kedudukan tab seterusnya. Dalam artikel ini, kami meneroka kefungsian jujukan pelarian '\t' dalam bahasa C++, menyerlahkan aplikasinya dengan contoh yang mudah dan praktikal untuk menggambarkan tingkah lakunya.