Halo, dan selamat datang kembali.
Dalam kuliah ini, saya ingin berbicara tentang sebuah konsep yang disebut pass by reference.
Ketika kita pertama kali mulai berbicara tentang pointer, saya menyebutkan salah satu keuntungannya adalah
Anda tidak perlu terlalu sering menggunakan variabel global.
Karena ketika Anda meneruskan pointer ke
suatu fungsi, fungsi tersebut dapat menggunakan parameter itu. Dan ketika mengubah parameter itu, data akan
dimodifikasi di luar fungsi.
Jadi ini adalah konsep yang berharga dan berharga.
Kita akan membicarakan ini. Ini lebih merupakan konsep. C sebenarnya tidak menggunakan ini.
Dan saya akan menunjukkan kepada Anda bagaimana dan memberi Anda beberapa
contoh pada dasarnya bagaimana ini bekerja.
Jadi ada konsep pass by value. Ini ada hubungannya dengan fungsi.
Kami berbicara tentang meneruskan data ke suatu fungsi, tetapi bagaimana sebenarnya itu
diteruskan dalam hal bahasa di kompiler.
Jadi ada konsep pass by value. Dan inilah yang
telah kita bicarakan sampai sekarang. Setiap kali kami memanggil fungsi
selain fungsi scanf, tetapi setiap kali kami memanggil fungsi tersebut,
ketika Anda mengubah data di dalam fungsi itu tidak
dimodifikasi di luar fungsi.
Jadi kami berbicara tentang variabel lokal yang merupakan konsep yang berbeda.
Tetapi ketika Anda meneruskan data ke suatu fungsi, ada dua cara untuk meneruskannya.
Anda dapat meneruskannya dengan nilai, Anda dapat meneruskannya dengan referensi.
C tidak secara eksklusif melewati nilai dan
begitu juga
Java, semua melewati nilai. Tapi itu mensimulasikan lewat referensi
karena Anda menyalin alamat.
Dan meskipun konsep ini
lewat referensi tidak secara khusus digunakan oleh
c, itu mensimulasikannya. Dan untuk memahami apa yang dimaksud dengan
pass by reference dan mengapa itu penting, kita akan membicarakannya.
Tetapi nilai lewat adalah ketika suatu fungsi menyalin nilai sebenarnya dari suatu argumen
ke dalam parameter formal dari fungsi tersebut.
Dan inilah mengapa jika Anda memiliki integer,
float, atau double dan Anda meneruskannya sebagai argumen ke suatu fungsi,
variabel aktual itu tidak akan dimodifikasi di luar fungsi karena disalin.
Jadi perubahan yang dilakukan pada parameter di dalam fungsi tidak berpengaruh pada argumen.
Argumen yang diteruskan tidak dimodifikasi.
Jadi hampir bertindak seperti variabel lokal karena merupakan salinan.
Bagaimana itu benar-benar terjadi di bawah tenda adalah itu disalin dan diteruskan ke fungsi.
Program C menggunakan panggilan berdasarkan nilai untuk meneruskan argumen.
Semuanya disebut dengan nilai demi nilai.
Ini digunakan secara bergantian istilah-istilah ini.
Jadi sekali lagi ini berarti kode di dalam suatu fungsi tidak dapat mengubah argumen yang digunakan untuk memanggil fungsi tersebut.
Tidak ada perubahan nilai meskipun telah diubah di dalam fungsi.
Sepertinya mereka adalah variabel lokal.
Dan itulah mengapa sebelumnya sampai saat ini
ketika Anda harus membuat data global jika Anda ingin berbagi data dari satu fungsi ke fungsi berikutnya.
Dan beginilah cara c bekerja.
Tetapi apa yang terjadi ketika Anda benar-benar
memberikan salinan alamat. Kemudian bisa meniru lewat referensi.
Tapi inilah contoh bagaimana kami menggunakan nilai pass by, ini ditunjukkan dengan sangat bagus di sini.
Rutinitas swap ini adalah kasus yang sering digunakan untuk menunjukkan
nilai lewat karena apa yang dilakukannya adalah menciptakan temp dan menukar
parameter argumen yang diteruskan.
Jadi jika kita memiliki fungsi bernama swap yang mengambil dua bilangan
bulat, kita membuat variabel lokal temp.
Jika kita menetapkan parameter x ke temp, temp akan
sama dengan x. Jika kita mengatakan x sama dengan y,
y sekarang akan sama dengan x. Jika kita mengatakan y sama dengan temp,
y akan sama dengan temp.
Tetapi ketika memanggil fungsi ini dengan meneruskan nilai-nilai itu, x dan
y akan menjadi lokal untuk fungsi ini.
Variabel tersebut tidak akan dimodifikasi di luar fungsi ini.
Dan fungsi ini menunjukkannya sangat berguna karena kami menetapkan
ke y dan kami menetapkan ke x.
Dan x dan y lokal untuk fungsi ini karena kita melewati nilai,
mereka tidak dimodifikasi di luar fungsi ini dan itulah mengapa kita harus menggunakan variabel global.
Tapi mereka bilangan bulat. Mereka adalah dua bilangan bulat x dan y. Itu bukan alamat,
itu bilangan bulat dan itu signifikan.
Jadi jika kita memanggil
swap dan kita melihat seperti apa ini, Anda
akan melihat bahwa nilainya tidak berubah.
Jadi jika kita membuat variabel yang disebut a 100
b dengan 200 dan kita mencetak variabel sebelum kita menukar,
100 dan 200 kemudian kita sebut
swap, variabel tidak akan berubah
setelah kita mencetaknya lagi.
Jadi mari kita lihat ini di blok kode dan ini akan menunjukkan nilai lewat.
Jadi inilah contoh kita. Kami memiliki rutinitas swap kami.
Kami menukar nilai data yang melewati x dan y.
Kami menyebutnya dengan 100 200.
Kita akan mencetak sebelum kita memanggil fungsi.
Kami akan mencetak setelahnya.
Dan apa yang akan Anda perhatikan adalah variabel a dan b tidak pernah berubah.
Dan alasan untuk ini adalah karena kita melakukan pass by value.
Jadi jika saya menjalankan program
ini, kita dapat melihat bahwa sebelum menukar nilai a adalah 100 setelah Anda menukar nilai a adalah
100 dan sama untuk b 200 dan 200.
Dan alasannya adalah karena kami melewati nilai. Jika kita melewati referensi, variabel
a dan b itu akan berubah setelah panggilan untuk bertukar.
Sekarang bagaimana jika kita menggunakan teknik yang sama ini lewat nilai tetapi
kita menyalin petunjuk, menurut Anda apa yang akan terjadi?
Jadi pointer dan fungsi cukup cocok satu sama lain.
Anda dapat meneruskan pointer sebagai argumen ke
suatu fungsi dan Anda juga dapat meminta fungsi mengembalikan pointer sebagai hasilnya.
Kami akan menunjukkan cara melakukannya juga.
Tapi lewat referensi menyalin alamat argumen ke dalam parameter formal.
Alamat digunakan untuk mengakses argumen aktual yang digunakan dalam panggilan.
Jadi artinya perubahan yang dilakukan pada parameter
di dalam fungsi memengaruhi argumen yang ada dalam panggilan.
Jadi meskipun tidak secara teknis di bawah tenda lewat referensi,
itu meniru atau mensimulasikan lewat referensi.
Kami sedang menyalin alamatnya. Jika Anda menyalin alamat,
Anda memiliki alamat dan memori baru untuk nilai alamat tersebut.
Tetapi jika Anda mencoba menetapkan ke alamat itu, itu akan ditetapkan ke alamat itu.
Jadi meskipun melewati nilai, itu menyalin.
Dan jika Anda menyalin bilangan bulat biasa, Anda tidak membuat perubahan. Jika Anda menyalin sebuah alamat, alamat tersebut ada
di memori, jadi saat Anda membuat perubahan, Anda akan membuat perubahan pada alamat itu.
Jadi untuk meneruskan nilai
dengan referensi, pointer argumen diteruskan ke fungsi sama seperti nilai lainnya.
Anda perlu mendeklarasikan parameter fungsi sebagai tipe pointer dengan tanda bintang.
Perubahan di dalam fungsi juga tercermin di luar fungsi.
Anda tidak perlu terlalu sering menggunakan variabel global.
Tidak seperti panggilan berdasarkan nilai di mana perubahan tidak mencerminkan di luar fungsi.
Kami masih menyalin kami masih melewati nilai itu hanya nilai salinan alamat.
Jadi ini adalah konsep penting untuk dipahami.
Sekarang ketika kita membuat fungsi
swap, kita akan membuatnya dengan deklarasi di dalam
fungsi asterix, star dan star.
Yang mengatakan bahwa fungsi ini membutuhkan pointer.
Sekarang ketika kita menetapkan di dalam fungsi ini,
kita harus benar-benar menggunakan operator tipuan untuk dereferensi karena
kita ingin menetapkan nilai. Kami akan menetapkan nilai
bahwa x yang x menunjuk ke temp.
Kita akan menetapkan nilai x menunjuk ke nilai yang
ditunjuk y dan kemudian kita akan menetapkan nilai yang ditunjuk y, ke temp.
Temp adalah bilangan bulat sehingga kita tidak perlu melakukan dereferensi.
Sekarang ketika kita
memanggilnya dengan a100 dan b200
dengan melewatkan a dan b, a dan b bukan pointer, jadi kita
harus memasukkan alamat karena fungsi mengambil pointer.
Setiap kali Anda memiliki fungsi yang mengambil pointer dan Anda tidak mendeklarasikan
pointer, Anda harus menggunakan alamat operator dan itu sama dengan cara kami menggunakan scanf.
Tapi sekarang Anda akan melihat ketika kita
memanggil ini setelah panggilan untuk menukar variabel a dan b akan
diubah, mereka akan ditukar. A akan menjadi 200 b akan menjadi 100.
Jadi sekarang mari kita lihat contoh ini dengan metode swap kita berubah menjadi pointer di blok kode.
Kami berada di blok kode. Kami memodifikasi fungsi swap untuk mengambil pointer.
Jadi kita harus mendereferensi mereka ketika kita menugaskannya.
Kami juga sekarang meneruskan alamat a dan b karena ini sekarang bilangan bulat,
dan swap sekarang membutuhkan pointer. Jadi ketika kita menjalankan ini, kita
akan melihat bahwa panggilan dan setelahnya sekarang akan diubah.
Jadi sebelum kita sebut swap a sama dengan 100 setelah kita sebut swap adalah 200.
Sebelum kita memanggil swap untuk b, nilainya 200. Setelah itu, menjadi 100.
Jadi kami dapat mengubah nilai variabel di dalam
fungsi karena kami membuat salinan alamatnya. Sangat, sangat penting, dan salah satu
keuntungan besar dari pointer.
Jadi mari kita rangkum sintaksnya. Saya sudah melakukannya tetapi mari kita bahas lebih detail.
Anda dapat mengomunikasikan dua jenis informasi tentang variabel ke suatu fungsi.
Anda dapat mengirimkan nilai x
dan fungsi harus dideklarasikan dengan tipe yang sama dengan x.
Kami tahu itu. Setiap kali kita melewatkan data
ke suatu fungsi, kita harus memiliki tipe yang sama saat kita memanggilnya.
Dan di sini kita memiliki int function1 untuk memanggilnya dan itu didefinisikan sebagai int num.
Jadi ketika kita mengirimkan nilai x dalam fungsi, mereka harus dideklarasikan dengan tipe yang sama.
Dan kemudian jika Anda ingin benar-benar memanggil alamat x, itu
memerlukan definisi fungsi untuk menyertakan pointer ke tipe yang benar.
Jadi, setiap kali Anda menggunakan pointer, Anda harus memastikan bahwa jika
Anda mengirimkan data dan data itu bukan pointer, Anda harus mendapatkan alamatnya.
Apa yang diringkas ini adalah jika Anda mendefinisikan fungsi yang tidak mengambil
pointer, Anda bisa memanggilnya dan meneruskan data.
Pastikan itu bukan pointer.
Jika Anda memiliki fungsi yang menggunakan penunjuk asterisk,
saat Anda menjalankannya,
Anda harus memanggilnya dengan operator add atau sub.
Anda harus memasukkan alamatnya.
Itu sintaksnya.
Sekarang Anda juga dapat memenuhi syarat parameter fungsi menggunakan kata kunci konstan.
Ini menunjukkan bahwa fungsi akan memperlakukan argumen yang diteruskan untuk parameter ini sebagai konstanta.
Ini hanya berguna ketika parameternya adalah pointer.
Karena jika Anda melewati nilai dan Anda tidak meneruskan pointer, itu tidak masalah karena
itu tidak akan mempengaruhi perubahan di luar fungsi jadi
mengapa Anda menjadikannya konstan, siapa yang peduli jika Anda mengubahnya .
Satu-satunya alasan Anda membuat penunjuk konstan adalah karena Anda tidak ingin
nilai fungsi di luar berubah.
Jadi Anda bisa menerapkan kata kunci konstan ke parameter yang merupakan
penunjuk untuk menentukan bahwa fungsi tidak akan mengubah nilai yang ditunjukkan oleh argumen.
Sangat penting.
Jadi dalam contoh ini kita memiliki fungsi kirim pesan. Dibutuhkan pointer pesan
p.
Kami menempatkan kata kunci konstan sebelum bintang char.
Jadi jenis pesan parameter p ini adalah penunjuk ke karakter konstan.
Ini adalah nilai karakter yang konstan, bukan alamatnya.
Jadi dalam hal ini yang kita lakukan adalah pointer yang ditunjuk tidak bisa berubah.
Kami dapat mengubah alamat, tetapi kami tidak dapat mengubah apa yang menunjuk ke nilainya.
Sintaksnya mirip dengan ketika kita membuat konstanta pada pointer lain.
Kata kunci konstan adalah hal pertama yang ditampilkan maka Anda tidak dapat mengubah nilainya.
Sekarang Anda bisa menentukan pointer itu sendiri adalah
konstan, tetapi ini tidak masuk akal karena alamatnya dilewatkan oleh nilai.
Anda tidak dapat mengubah
penunjuk render dalam fungsi pemanggilan. Jadi ini hanya jika Anda mencoba membuatnya agar alamatnya
tidak bisa diubah, apa gunanya karena melewati nilai. Jadi Anda benar-benar
membuat lokasi memori baru
untuk menampung alamat spesifik itu. Jadi jika Anda mengubahnya, siapa peduli itu tidak akan mengubahnya di luar.
Anda hanya ingin dapat membuat parameter menjadi
konstan sehingga Anda tidak mengubah nilai dari apa yang ditunjuknya,
Anda tidak dapat
mengubah penunjuk asli dan fungsi panggilan karena itu diteruskan dengan
nilai yang diteruskan oleh salinan.
Kompiler tahu bahwa argumen yang merupakan penunjuk ke data
konstan akan aman, jadi ada keuntungannya. Anda tidak dapat secara tidak sengaja mengubah apa yang ditunjuk oleh nilai tersebut.
Jadi Anda dapat melakukan ini lagi jika Anda tidak ingin perubahan tercermin di luar fungsi.
Jika Anda meneruskan pointer ke data konstan sebagai argumen untuk
parameter, maka parameter harus digunakan seperti di atas.
Ketika Anda memanggil fungsi dan Anda meneruskannya ke konstan, maka
Anda harus memiliki deklarasi fungsi juga mengambil pointer karakter konstan, seperti
biasa pointer lain yang konstan.
Mereka harus didefinisikan dan definisi harus sesuai dengan prototipe.
Mengembalikan pointer dari suatu fungsi.
Mengembalikan pointer dari suatu fungsi adalah kemampuan kuat tertentu.
Ini memberikan cara bagi Anda untuk mengembalikan bukan hanya satu nilai, tetapi seluruh rangkaian nilai.
Jadi sekali lagi salah satu keuntungan lain yang saya
sebutkan tentang pointer adalah Anda sekarang dapat mengembalikan lebih banyak data dari suatu fungsi.
Di masa lalu, Anda hanya dapat mengembalikan satu nilai.
Tetapi dengan pointer karena pointer dapat menunjuk
ke struktur yang belum kita bicarakan atau bahkan hal lain Anda
dapat mengembalikan beberapa nilai.
Jadi kita tahu cara meneruskan pointer ke fungsi, sekarang kita
ingin berbicara tentang mengembalikan pointer.
Anda harus mendeklarasikan fungsi yang mengembalikan pointer. Jadi deklarasi fungsi harus cocok.
Sangat mudah untuk melakukannya. Anda cukup mengatakan gunakan tanda bintang
ketika Anda mendeklarasikan fungsi atau mendefinisikannya dan memiliki tipe pengembalian untuk penunjuk itu apa yang ditunjuknya.
Jadi berhati-hatilah meskipun ada bahaya khusus yang berkaitan dengan mengembalikan pointer.
Gunakan variabel lokal untuk menghindari campur tangan dengan variabel yang ditunjuk oleh argumen.
Agak bermasalah ketika Anda mengembalikan pointer karena jika Anda memodifikasi pointer itu di dalam
fungsi dan kemudian mengembalikannya, itu
bisa menjadi sesuatu yang tidak Anda inginkan.
Jadi, selalu gunakan variabel lokal jika Anda tidak ingin memengaruhi variabel yang
ditunjuk oleh argumen Anda.
Dan kuliah ini menjelaskan bagaimana Anda
bisa meneruskan pointer ke fungsi
dan bagaimana Anda bisa mengembalikan pointer dari fungsi.
Dan dengan menggunakan mekanisme meneruskan pointer ke
suatu fungsi, ini menunjukkan atau meniru lewat referensi
karena Anda menyalin di sebuah alamat.
Dan ketika Anda menyalin alamat jika Anda menulis ke alamat itu, Anda
akan memperbarui apa pun yang
menunjuk ke alamat itu, yang secara efektif berarti bahwa Anda mengubah
nilai data di dalam fungsi itu akan mencerminkannya di luar fungsi.
Kami menggunakan rutin swap untuk menunjukkan itu.
Ini adalah konsep yang sangat kuat. Dan Anda ingin meniru lewat referensi, Anda
dapat menggunakan pointer untuk melakukan itu dan Anda ingin melakukannya ketika Anda ingin mengubah hal-hal di luar fungsi.
Terima kasih.