Studi tentang string berguna untuk lebih mengikat dalam hubungan antara pointer dan array. Hal ini juga memudahkan untuk menggambarkan bagaimana beberapa fungsi string standar C dapat diimplementasikan. Akhirnya menggambarkan bagaimana dan kapan pointer dapat dan harus dilewatkan ke fungsi.
Dalam C, string adalah array karakter. Ini tidak selalu benar dalam bahasa lain. Dalam BASIC, Pascal, Fortran dan bahasa lain berbagai string memiliki tipe data sendiri. Tapi di C tidak. Dalam C string adalah array dari karakter diakhiri dengan karakter nol biner (ditulis sebagai ''). Untuk memulai diskusi kami, kami akan menulis beberapa kode yang, sementara lebih disukai untuk tujuan ilustrasi, Anda mungkin tidak akan pernah menulis sebuah program yang sebenarnya. Perhatikan, misalnya:
arang my_string [40]; my_string [0] = 'T'; my_string [1] = 'e'; my_string [2] = 'd': my_string [3] = '';
Sementara satu tidak akan pernah membangun sebuah string seperti ini, hasil akhirnya adalah string dalam hal ini adalah array dari karakter diakhiri dengan karakter nul. Menurut definisi, di C, string adalah sebuah array karakter diakhiri dengan karakter nul. Sadarilah bahwa "nul" adalah tidak sama dengan "NULL". The nul mengacu nol seperti yang didefinisikan oleh "urutan escape '. Itulah menempati satu byte memori. NULL, di sisi lain, adalah nama makro yang digunakan untuk menginisialisasi pointer null. NULL # didefinisikan dalam file header di compiler C, nul mungkin tidak # didefinisikan sama sekali.
Sejak menulis kode di atas akan sangat memakan waktu, C memungkinkan dua cara alternatif untuk mencapai hal yang sama. Pertama, orang mungkin menulis:
arang my_string [40] = {'T', 'e', 'd', '',};
Tapi ini juga membutuhkan lebih dari mengetik yang nyaman. Jadi, C memungkinkan:
arang my_string [40] = "Ted";
Ketika tanda kutip ganda yang digunakan, bukan tanda kutip tunggal seperti yang dilakukan pada contoh sebelumnya, karakter nul ('') secara otomatis ditambahkan ke akhir dari string.
Dalam semua kasus di atas, hal yang sama terjadi. Compiler menyisihkan blok memori yang berdekatan 40 byte panjang untuk memegang karakter dan diinisialisasi seperti bahwa 4 karakter pertama adalah Ted.
Sekarang, perhatikan program berikut:
Program 3,1 ------------------------------ ------------------ ------- / * Program 3.1 dari PTRTUT10.HTM 6/13/97 * / # include arang Stra [80] = "Sebuah string yang akan digunakan untuk tujuan demonstrasi"; strB char [80 ] int main (void) {char * pA; / * pointer untuk mengetik karakter * / char * pB; / * pointer lain untuk mengetik karakter * / puts (Stra); / * tampilkan string * A / pA = Stra; / * titik pA pada string * A / puts (pA); / * menunjukkan apa pA menunjuk ke * / pB = strB; / * titik pB di tali B * / putchar (''); / * bergerak ke bawah satu baris pada layar * / while (* pA = '!') / * jalur A (lihat teks) * / {* pB + + = * pA + +; / * jalur B (lihat teks) * /} * pB = ''; / * baris C (lihat teks) * / puts (strB); / * tampilkan strB di layar * / return 0;} --------- end Program 3,1 -------------- -----------------------
Dalam contoh di atas kita mulai dengan mendefinisikan array karakter dua dari 80 karakter. Karena secara global didefinisikan, mereka telah siap untuk melakukan semua 'pertama. Kemudian, Stra memiliki 42 karakter pertama diinisialisasi ke string dalam tanda kutip.
Sekarang, pindah ke kode, kita mendeklarasikan dua pointer karakter dan menampilkan string di layar. Kami kemudian "titik" pA pointer di Stra. Artinya, melalui pernyataan penugasan kami salin alamat Stra [0] ke variabel pA kami. Kami sekarang menggunakan puts () untuk menunjukkan bahwa yang ditunjuk oleh pA di layar. Pertimbangkan sini bahwa prototipe fungsi untuk puts () adalah:
int puts (const char * s);
Untuk saat ini, mengabaikan const. Parameter dikirimkan ke puts () adalah pointer, yaitu nilai dari pointer (karena semua parameter di C tersebut diteruskan oleh nilai), dan nilai dari pointer adalah alamat yang telah ditunjuk, atau, cukup, alamat . Jadi ketika kita menulis puts (Stra), seperti telah kita lihat, kita mengirimkan alamat Stra [0].
Demikian pula, ketika kita menulis puts (pA); kita mengirimkan alamat yang sama, karena kami telah menetapkan pA = Stra;
Mengingat bahwa, ikuti kode ke pernyataan while () pada Jalur A. Sebuah baris menyatakan:
Sementara karakter yang ditunjukkan oleh pA (yaitu * pA) bukan karakter nul (yaitu 'mengakhiri'), lakukan hal berikut:
Jalur B menyatakan: menyalin karakter yang ditunjukkan oleh pA ke ruang ditunjuk oleh pB, maka kenaikan pA sehingga menunjuk ke karakter berikutnya dan pB sehingga menunjuk ke ruang depan.
Ketika kita telah menyalin karakter terakhir, pA sekarang menunjuk ke karakter nul mengakhiri dan loop berakhir. Namun, kami belum disalin karakter nul. Dan, menurut definisi string dalam C harus nul dihentikan. Jadi, kita tambahkan karakter nul dengan garis C.
Hal ini sangat mendidik untuk menjalankan program ini dengan debugger Anda saat menonton Stra, strB, pA dan pB dan loncatan tunggal melalui program ini. Hal ini bahkan lebih jika pendidikan bukan hanya mendefinisikan strB [] seperti yang telah dilakukan di atas, menginisialisasi itu juga dengan sesuatu seperti:
strB [80] = "12345678901234567890123456789012345678901234567890"
dimana jumlah digit yang digunakan lebih besar dari panjang Stra kemudian ulangi prosedur loncatan tunggal saat menonton variabel di atas. Berikan hal-hal ini mencoba!
Mendapatkan kembali ke prototipe untuk puts () untuk beberapa saat, "const" digunakan sebagai pengubah parameter menginformasikan pengguna bahwa fungsi tidak akan mengubah string ditunjukkan oleh s, yaitu akan memperlakukan string yang sebagai konstan.
Tentu saja, apa program di atas menggambarkan adalah cara sederhana untuk menyalin string. Setelah bermain dengan di atas sampai Anda memiliki pemahaman yang baik tentang apa yang terjadi, kita dapat melanjutkan untuk menciptakan pengganti kita sendiri untuk strcpy standar () yang datang dengan C. Mungkin terlihat seperti:
char * my_strcpy (char * tujuan, char * sumber)
{
char * p = tujuan;
while (* sumber = '!')
{
* P + + = * sumber + +;
}
* P = '';
kembali tujuan;
}
Dalam hal ini, saya telah mengikuti praktek yang digunakan dalam rutin standar untuk kembali pointer ke tujuan.
Sekali lagi, fungsi ini dirancang untuk menerima nilai-nilai dua pointer karakter, seperti alamat-alamat, dan dengan demikian dalam program sebelumnya kita bisa menulis:
int main (void)
{
my_strcpy (strB, Stra);
puts (strB);
}
Aku telah menyimpang sedikit dari formulir yang digunakan dalam C standar yang akan memiliki prototipe:
char * my_strcpy (char * tujuan, const char * sumber);
Di sini "const" pengubah digunakan untuk meyakinkan pengguna bahwa fungsi tidak akan memodifikasi isi ditunjuk oleh pointer sumber. Anda dapat membuktikan ini dengan memodifikasi fungsi di atas, dan prototipe, untuk memasukkan "const" pengubah seperti yang ditunjukkan. Kemudian, dalam fungsi Anda dapat menambahkan pernyataan yang mencoba untuk mengubah isi dari yang ditunjukkan oleh sumber, seperti:
* Sumber = 'X';
yang biasanya akan mengubah karakter pertama dari string ke X. modifier const harus menyebabkan compiler untuk menangkap ini sebagai kesalahan. Cobalah dan lihat.
Sekarang, mari kita pertimbangkan beberapa hal contoh di atas telah menunjukkan kepada kita. Pertama, mempertimbangkan fakta bahwa * ptr + + adalah untuk ditafsirkan sebagai mengembalikan nilai yang ditunjuk oleh ptr dan kemudian incrementing nilai pointer. Hal ini berkaitan dengan didahulukan dari operator. Apakah kita untuk menulis (* ptr) + + kita akan kenaikan, bukan pointer, tetapi pointer yang menunjuk ke! yaitu jika digunakan pada karakter pertama dari string contoh di atas 'T' akan bertambah dengan 'U'. Anda dapat menulis beberapa kode contoh sederhana untuk menggambarkan ini.
Ingat kembali bahwa sebuah string tidak lebih dari sebuah array karakter, dengan karakter terakhir menjadi ''. Apa yang kami lakukan di atas adalah kesepakatan dengan menyalin array. Itu terjadi adalah sebuah array karakter tetapi teknik ini dapat diterapkan pada sebuah array bilangan bulat, ganda, dll Dalam kasus tersebut, namun, kami tidak akan berurusan dengan string dan karenanya akhir array tidak akan ditandai dengan khusus nilai seperti karakter nul. Kita bisa mengimplementasikan versi yang bergantung pada nilai khusus untuk mengidentifikasi akhir. Sebagai contoh, kita bisa menyalin sebuah array bilangan bulat positif dengan menandai akhir dengan bilangan bulat negatif. Di sisi lain, lebih biasa bahwa ketika kita menulis fungsi untuk menyalin berbagai barang selain string kita melewati fungsi jumlah barang yang akan disalin serta alamat dari array, sesuatu misalnya seperti prototipe berikut mungkin menunjukkan:
kekosongan int_copy (int * ptrA, int * ptrB, int nbr);
nbr mana adalah jumlah bilangan bulat yang akan disalin. Anda mungkin ingin bermain dengan ide ini dan membuat sebuah array dari integer dan lihat apakah Anda dapat menulis int_copy fungsi () dan membuatnya bekerja.
Hal ini memungkinkan menggunakan fungsi untuk memanipulasi array besar. Sebagai contoh, jika kita memiliki sebuah array bilangan bulat 5000 bahwa kita ingin memanipulasi dengan fungsi, kita hanya perlu lolos ke fungsi bahwa alamat array (dan setiap informasi tambahan seperti nbr atas, tergantung pada apa yang kita lakukan). Array itu sendiri tidak mendapatkan berlalu, yaitu seluruh array tidak akan disalin dan dimasukkan pada stack sebelum memanggil fungsi tersebut, hanya alamat nya dikirim.
Ini berbeda dengan sambil lalu, mengatakan integer, ke fungsi. Ketika kita mengirimkan integer kita membuat salinan dari integer, yaitu mendapatkan nilai dan meletakkannya di stack. Dalam fungsi setiap manipulasi nilai berlalu bisa di tidak berpengaruh cara integer asli. Tapi, dengan array dan pointer kita dapat melewati alamat variabel dan karenanya memanipulasi nilai-nilai dari variabel asli.
Tidak ada komentar:
Posting Komentar