Salinan Mendalam

Termasuk bagian Pemrograman Berorientasi Objek dalam perjalanan C di Coddy. Pelajaran 15 dari 61.

Saat kamu menetapkan satu struct ke struct lain di C, kamu mendapatkan salinan dangkal: semua field disalin byte demi byte. Ini berfungsi dengan baik untuk nilai sederhana seperti bilangan bulat, tetapi menimbulkan masalah pada pointer: kedua struct akhirnya menunjuk ke memori yang sama.

typedef struct {
    char *name;
    int age;
} Person;

Person alice = {"Alice", 30};
Person copy = alice;  // Salinan dangkal!
// alice.name dan copy.name sama-sama menunjuk ke string yang SAMA

Jika kamu membebaskan salah satunya, yang lain menjadi tidak valid. Jika kamu mengubah string melalui salah satunya, keduanya melihat perubahan itu. Ini jarang sesuai dengan yang kamu inginkan.

Salinan mendalam mengalokasikan memori baru untuk anggota pointer dan menyalin data sebenarnya:

Person *clone_person(const Person *original) {
    Person *copy = malloc(sizeof(Person));
    copy->name = malloc(strlen(original->name) + 1);
    strcpy(copy->name, original->name);
    copy->age = original->age;
    return copy;
}

Sekarang setiap object memiliki string-nya sendiri. Kamu bisa mengubah atau membebaskan salah satunya tanpa memengaruhi yang lain. Polanya sederhana: untuk setiap anggota pointer, alokasikan memori baru dan salin isinya, bukan hanya alamatnya.

Tantangan

Mudah

Mari kita buat module Student yang menunjukkan pola deep copy. Kamu akan membuat fungsi kloning yang menghasilkan salinan object student yang sepenuhnya independen: perubahan pada object asli atau membebaskannya tidak akan memengaruhi clone.

Kamu akan membuat tiga file:

student.h: Deklarasikan struct Student dengan dua anggota: char *name (string yang dialokasikan secara dinamis) dan int grade. Deklarasikan tiga fungsi:
- create_student: konstruktor yang menerima nama dan nilai, lalu mengembalikan pointer ke Student baru
- clone_student: menerima const Student * dan mengembalikan pointer ke salinan baru yang independen
- free_student: destruktor yang membebaskan semua memori yang dialokasikan dengan benar
Gunakan include guard dengan simbol STUDENT_H.
student.c: Implementasikan ketiga fungsi. Fungsi clone_student adalah bagian utama. Fungsi ini harus mengalokasikan memori baru untuk struct dan string name, lalu menyalin data string yang sebenarnya, bukan hanya alamat pointer-nya. Dengan begitu, clone sepenuhnya memiliki memorinya sendiri, terpisah dari object asli.
main.c: Buat student, kloning student tersebut, tampilkan informasi kedua student, lalu bersihkan kedua object dengan benar.

Kamu akan menerima dua input: nama student (string) dan nilai (bilangan bulat).

Di file main, buat student dengan nilai yang diberikan, lalu buat clone dari student tersebut. Cetak informasi student asli dan clone untuk memastikan keduanya berisi data yang sama. Terakhir, bebaskan kedua student dan cetak konfirmasi.

Cetak output dengan format ini:

Original: {name}, Grade: {grade}
Clone: {name}, Grade: {grade}
Both freed

Contohnya, dengan input Alice dan 95, outputnya adalah:

Original: Alice, Grade: 95
Clone: Alice, Grade: 95
Both freed

Pola deep copy memastikan setiap object benar-benar independen: clone memiliki string yang dialokasikan sendiri, bukan pointer bersama ke memori object asli.

Coba sendiri

#include <stdio.h>
#include <stdlib.h>
#include "student.h"

int main() {
    char name[100];
    int grade;
    
    // Baca input
    scanf("%s", name);
    scanf("%d", &grade);
    
    // TODO: Buat siswa dengan nama dan nilai yang diberikan
    
    // TODO: Buat salinan siswa tersebut
    
    // TODO: Cetak informasi siswa asli
    // Format: "Original: {name}, Grade: {grade}"
    
    // TODO: Cetak informasi salinan siswa
    // Format: "Clone: {name}, Grade: {grade}"
    
    // TODO: Bebaskan memori kedua siswa
    
    // Cetak konfirmasi
    printf("Both freed\n");
    
    return 0;
}