Halo, dan selamat datang kembali. Hal terakhir yang ingin saya
bicarakan tentang struktur adalah bagaimana mereka terkait dengan fungsi, bagaimana
Anda dapat meneruskan struktur sebagai argumen ke parameter dan fungsi dan bagaimana
ini juga lebih efisien.
Jadi struktur sebagai argumen untuk fungsi.
Setelah mendeklarasikan struktur
bernama Family. Dalam contoh ini kita akan membuat
keluarga bernama, bagaimana kita meneruskan struktur ini sebagai argumen ke suatu fungsi.
Jadi kami memiliki struktur yang disebut Keluarga.
Kami memiliki banyak array karakter di
sini nama, ayah dan ibu dan kemudian kami memiliki usia int.
Itu definisi struktur kami.
Kita tahu itu struktur karena kata kunci struct ada diikuti dengan nama tag
kita memiliki kurung kurawal dan sebagainya.
Sekarang bagaimana kita benar-benar meneruskan struktur itu ke
fungsi yang disebut saudara kandung?
Nah, Anda akan melakukannya seperti Anda mendeklarasikan strukturnya, Anda
akan mengatakan tipe sebagai nama parameter.
Ini benar-benar mudah. Jadi dalam hal ini, kami memiliki saudara kandung Boolean.
Saudara kandung mengembalikan Boolean.
Dan itu mengambil dua parameter, dua parameter struct.
Anda harus mengidentifikasi tipe struct yang merupakan tipe struct family.
Sekarang di c yang lebih maju, Anda sebenarnya
bisa melakukan typedf pada struct ini dan menamainya sesuatu yang lain dan Anda bisa
mempersingkat namanya di sini, tapi kita belum membicarakan tentang typeds.
Itu mungkin akan lebih baik.
Tapi ini benar-benar bagaimana Anda perlu melakukannya. Anda harus mendefinisikan seluruh tipe,
yaitu keluarga struct dan kemudian nama variabel, sama seperti parameter lainnya.
Jadi di sini kita melewati dua parameter, anggota satu dan anggota dua.
Mereka berdua adalah keluarga tipe struct.
Kemudian di dalam fungsi kita, jika kita ingin mengakses anggota, kita
mengakses anggota seperti biasa.
Anggota satu dan anggota dua, mereka bukan penunjuk jadi kami tidak menggunakan tanda hubung lalu lebih besar dari,
kami hanya melakukannya pada penunjuk karena kami perlu mereferensikan mereka untuk melihat apa yang mereka tunjuk.
Karena mereka bukan pointer, kita bisa melakukan dot. Jadi anggota satu titik ibu, anggota dua titik ibu.
Anggota satu titik ibu dan ibu dua
titik ibu adalah array karakter, dan array karakter pada dasarnya adalah pointer.
Jadi kita bisa meneruskannya ke str compare. Str membandingkan akan kembali sama jika mereka sama, Jadi
yang kami lakukan di sini adalah kami memeriksa anggota
satu ibu dan anggota dua ibu adalah sama. Dan jika ya, kita akan kembali benar.
Karena jika mereka berdua memiliki nama yang
sama dan itu benar-benar nama belakang maka mereka bersaudara.
Cukup mudah.
Mudah untuk meneruskan argumen
ke fungsi selama deklarasi fungsi memiliki tipe struct di sana.
Jadi fungsi ini, sekali lagi, dua parameter yang masing-masing merupakan struktur dari
keluarga tipe.
Bagaimana jika kita ingin memiliki pointer ke struktur sebagai argumen fungsi.
Dan saya sebutkan sebelumnya, ini lebih baik dilakukan karena kita melakukan
pass by value dan c.
Ketika Anda melewati nilai, Anda menyalin.
Jika Anda memiliki struktur yang berisi banyak data,
banyak struktur besar sebagai argumen, Anda
harus menyalin semua yang ada di struktur
itu ke fungsi sebenarnya.
Jadi itu bisa memakan waktu
untuk menyalin struktur besar itu.
Nah, jika Anda memiliki pointer, yang harus Anda lakukan adalah menyalin
alamat yang jauh lebih cepat. Jadi pointer ke
struktur digunakan sebagai parameter dan fungsi untuk menghindari konsumsi
memori dan waktu yang diperlukan untuk menyalin semua struktur.
Sekarang jika Anda memiliki struktur kecil, bukan
masalah besar, tetapi pasti ingin menggunakan pointer dan struktur yang besar.
Jadi dalam hal ini, apa yang Anda lakukan, Anda tetap menentukan nama jenis struktur,
Anda hanya meletakkan tanda bintang terlebih
dahulu, sangat sederhana. Dan jika Anda tidak
ingin data apa pun di dalam struktur berubah, Anda dapat menggunakan konstanta sebelum tipe struktur.
Jika Anda tidak ingin alamatnya berubah, Anda akan meletakkan konstanta setelah penunjuk keluarga struct.
Tapi di sini, kami melakukan hal yang sama. Tetapi sekarang kita akan
mengaksesnya secara berbeda karena sekarang ini adalah pointer, kita dapat menggunakan tanda
hubung lebih besar dari, simbol baru untuk mengakses daripada menggunakan titik.
Kita tidak harus menggunakan titik di sini. Karena ingat, pointer
yang harus Anda de-referensi terlebih dahulu sehingga Anda harus memasukkannya ke dalam tanda kurung, lebih
banyak sintaks untuk menghilangkan referensi pointer maka Anda harus meletakkan titik di luar tanda kurung karena memiliki
prioritas yang lebih tinggi, jauh lebih mudah untuk menggunakan tanda hubung daripada lebih besar dari.
Tanda hubung dan lebih besar dari ibu,
tanda hubung dan lebih besar dari ibu keduanya adalah pointer, mereka dapat diteruskan dalam str compare.
Jika mereka sama, kembalikan true. Jika tidak, kembalikan false, cukup mudah.
Anda juga dapat menggunakan pengubah const seperti yang saya
sebutkan jika Anda tidak ingin mengizinkan modifikasi apa pun dari anggota struct.
Apa yang ditunjuk oleh struct kemudian Anda meletakkan const sebelum pointer.
Anda bisa menempatkan const sebenarnya sebelum keluarga juga.
Dalam hal ini, keluarga memiliki typef.
Jadi di sini
benar-benar akan menjadi pointer const keluarga atau struct keluarga.
Dan sekali lagi akses dengan cara yang sama, Anda tidak mengubah apa pun. Jadi Anda baik untuk pergi.
Kompiler tidak akan mengeluh.
Anda juga dapat menggunakan pengubah konstan jika Anda tidak ingin mengizinkan
modifikasi alamat itu sendiri.
Setiap upaya untuk mengubah struktur ini akan menyebabkan pesan kesalahan selama kompilasi.
Jadi di sini Anda akan
mengatakan bintang keluarga dan Anda menempatkan konstanta setelah bintang.
Dan apa yang dikatakannya adalah Anda
tidak dapat mengubah nilai p-member, nilai pointer, yang merupakan alamat.
Tetapi sekali lagi, ini tidak terlalu berguna
karena ketika Anda melewati nilai, Anda sebenarnya mengirimkan salinan alamatnya.
Jadi ini berlebihan, Anda tidak perlu melakukan ini, tetapi Anda bisa.
Dan di sini, sekali lagi, Anda ingin dapat mengubah alamat anggota p itu.
Dan dalam hal ini, Anda hanya mengakses data untuk melihat apakah mereka sama.
Operator tipuan di setiap definisi parameter sekarang berada di
depan kata kunci konstan.
Tanda bintang itu, tidak di depan nama parameter.
Anda tidak dapat mengubah alamat yang disimpan dalam pointer karena letaknya setelah tanda bintang.
Jika itu di depan jenis nama parameter,
maka Anda ingin dapat mengubah apa yang sebenarnya ditunjuknya.
Jika kami memiliki operator tipuan di depan nama parameter, apa yang akan
ada di konstanta sebelumnya, itu
berarti Anda ingin dapat mengubah apa yang ditunjuknya. Ini hanya mengatakan alamat.
Jadi Anda tidak dapat mengubah alamat yang disimpan dalam pointer.
Ini adalah pointer yang dilindungi di sini bukan struktur
yang mereka tunjuk, seperti konstanta dan parameter pointer lainnya, tidak ada perbedaan dengan struct.
Jika Anda ingin mengembalikan struktur dari fungsi yang berupa
pointer, prototipe fungsi harus menunjukkan nilai pengembalian ini dengan cara
biasa dalam deklarasi.
Jadi di sini Anda harus mengatakan hit to
date pointer menyenangkan saya
atau bukan pointer, tidak masalah. Ini adalah prototipe untuk suatu fungsi yang tidak mengambil argumen yang
mengembalikan struktur bertipe tanggal, sangat mudah untuk mengembalikan struktur dari suatu fungsi. Dan apa nilai dari ini.
Nah, sekarang kita bisa mengembalikan lebih
dari satu elemen atau satu item data dari suatu fungsi.
Jika Anda mengembalikan struct, Anda bisa mengembalikan 10 nilai, 10 item data yang berbeda.
Betapa kerennya itu. Struktur memungkinkan Anda untuk mengembalikan lebih dari satu dari suatu fungsi.
Sangat, sangat berharga.
Jadi seringkali lebih mudah untuk mengembalikan pointer ke struktur daripada hanya struktur.
Saat Anda mengembalikan pointer ke struktur, itu dibuat di heap karena
semua pointer dibuat di heap.
Ini berarti itu akan menjadi sekitar sedikit lebih lama.
Dan ini berarti Anda dapat menghapus dan mengelolanya pada waktu yang sewenang-wenang.
Jadi dalam contoh ini, kami membuat struct bernama dana.
Ini berisi array
karakter bernama bank, berisi ganda, karakter lain
bernama disimpan dengan panjang tertentu. Anggap saja panjang kesenangan sama dengan 50.
Dan kemudian memiliki simpanan ganda.
Kami memiliki fungsi yang disebut jumlah yang mengambil struktur itu sebagai parameter.
Dan semua yang kami lakukan adalah di dalamnya adalah
kami mengembalikan - dana bank dari struktur pertama ditambah dana simpanan, dan itu
akan mengembalikan jumlah yang mereka miliki di bank mereka.
Dalam contoh ini, jumlah hanya ganda.
Kami tidak mengembalikan pointer. Kami hanya mengambil pointer sebagai parameter.
Jadi dalam fungsi utama kami, kami membuat variabel struktur yang
disebut stan of type struct fund.
Kami menginisialisasi dengan beberapa nilai, dan kemudian kami mencetak
total jumlah panggilan. Dan kami hanya melewati struktur ini seperti kami melewati variabel apa pun.
Kita tidak perlu melakukan de-referensi itu bukan pointer. Kita tidak perlu melakukan sesuatu yang istimewa.
Kami hanya memastikan bahwa dalam deklarasi fungsi kami memiliki tipe struct di sana,
tetapi yang lainnya terlihat normal.
Beberapa pengingat.
Saya sebutkan sebelumnya bahwa Anda harus selalu menggunakan pointer saat meneruskan struktur ke suatu fungsi.
Mengapa? Karena ingat, versi c yang
lebih lama
tidak mengizinkan struktur untuk dilewati, tetapi mereka mengizinkan pointer.
Jadi, Anda dapat menghindari segala jenis kompatibilitas mundur.
Jika Anda menggunakan versi c yang lebih lama, program Anda akan berfungsi.
Jadi hanya melewati satu alamat
itu juga lebih efisien karena waktu penyalinan.
Tetapi jika Anda melakukan ini, jika Anda memasukkan parameter yang merupakan penunjuk ke
struct di dalam suatu fungsi, itu memiliki perlindungan yang lebih sedikit untuk data Anda.
Jadi beberapa operasi dalam fungsi yang dipanggil dapat secara tidak sengaja mempengaruhi
data dalam struktur aslinya.
Dan di sinilah Anda ingin menggunakan const qualifier.
Dan Anda akan menggunakan const sebelum
tipe sebenarnya, bukan setelah tanda bintang dan sebelum
nama parameter, sebelum tipe.
Keuntungan dari melewati struktur adalah argumen, fungsi
bekerja dengan salinan dari data asli.
Ini lebih aman daripada bekerja dengan data asli.
Jadi itu benar-benar satu-satunya saat Anda ingin melewatkan struktur sebagai argumen yang bukan pointer.
Dan gaya pemrograman cenderung sedikit lebih jelas.
Kerugian utama dari melewatkan struktur sebagai argumen dibandingkan dengan melewatkan pointer
terstruktur sebagai argumen adalah implementasi yang
lebih lama mungkin tidak menangani kode, membuang
waktu dan ruang dan terutama boros
ketika Anda memiliki struktur besar, kami harus melakukan banyak penyalinan
untuk masing-masing anggota. Jadi ingatlah ini.
Untuk sebagian besar Anda ingin meneruskan
pointer ke struktur, jauh lebih efisien dan menghemat waktu.
Pemrogram menggunakan penunjuk struktur sebagai argumen fungsi untuk alasan efisiensi dan mereka
menggunakan konstanta bila diperlukan. Dan ini adalah kombinasi yang ingin Anda lakukan.
Jika Anda khawatir tentang perlindungan, cukup gunakan pointer fungsi
untuk efisiensi dan kemudian gunakan
const const sehingga tidak ada yang kacau di
dalam fungsi, seperti pointer yang benar-benar normal
kurang lebih, tetapi dengan pointer itu bahkan lebih penting dengan efisiensi
karena dari struktur besar.
Melewati struktur berdasarkan nilai paling sering dilakukan untuk struktur yang kecil, dan itu
adalah jenis aturan yang ingin Anda pikirkan.
Oke untuk melewati struktur yang bukan pointer asalkan kecil.
Sekali lagi, beberapa konsep penting terkait dengan struktur
dan pointer yang lewat sebagai parameter, argumen,
dan juga pointer kembali. Sekarang, kita benar-benar dapat mulai menerapkan
beberapa di antaranya. Kami memberikan banyak contoh. Kami memahami konsep-konsepnya. Kami memahami sintaksnya.
Sekarang saya ingin memberi Anda beberapa tantangan yang membuat Anda benar-benar melakukan ini, apakah Anda
sudah hafal dalam sintaks bahwa sekarang jika Anda ingin membuat struktur dalam program, Anda tahu
bagaimana melakukannya seperti punggung tangan Anda.
Jadi kita akan memiliki beberapa tantangan dalam kuliah pasangan
berikutnya untuk membuat Anda terbiasa dengan semua hal yang kita bicarakan tentang struktur.
Terima kasih.