Setelah diskusi di SO, saya sudah membaca beberapa kali komentar bahwa struct yang bisa berubah adalah "jahat" (seperti dalam jawaban untuk pertanyaan ini ).

Apa masalah aktual dengan mutabilitas dan struct di C #?

Structs adalah tipe nilai yang berarti mereka disalin ketika mereka diedarkan.

Jadi, jika Anda mengubah salinan Anda hanya mengubah salinan itu, bukan yang asli dan tidak ada salinan lain yang mungkin ada.

Jika struct Anda tidak dapat diubah maka semua salinan otomatis yang dihasilkan dari diteruskan oleh nilai akan sama.

Jika Anda ingin mengubahnya, Anda harus melakukannya secara sadar dengan membuat instance baru dari struct dengan data yang dimodifikasi. (bukan salinan)

Mulai dari mana ;-p

Blog Eric Lippert selalu baik untuk kutipan:

Ini adalah alasan lain mengapa tipe nilai yang bisa berubah itu jahat. Usahakan untuk selalu membuat tipe nilai tidak berubah.

Pertama, Anda cenderung kehilangan perubahan dengan mudah ... misalnya, mengeluarkan beberapa hal dari daftar:

Foo foo = list[0];
foo.Name = "abc";

apa yang berubah? Tidak ada yang berguna ...

Sama dengan properti:

myObj.SomeProperty.Size = 22; // the compiler spots this one

memaksa Anda untuk melakukan:

Bar bar = myObj.SomeProperty;
bar.Size = 22;
myObj.SomeProperty = bar;

kurang kritis, ada masalah ukuran; objek yang bisa berubah cenderung memiliki banyak properti; namun jika Anda memiliki struct dengan dua ints, a string, a DateTimedan a bool, Anda dapat dengan cepat membakar banyak memori. Dengan kelas, beberapa penelepon dapat membagikan referensi ke instance yang sama (referensi kecil).

Saya tidak akan mengatakan yang jahat, tetapi bisa berubah-ubah sering kali merupakan pertanda kerinduan para programmer untuk memberikan fungsionalitas yang maksimal. Pada kenyataannya, ini seringkali tidak diperlukan dan pada gilirannya, membuat antarmuka lebih kecil, lebih mudah digunakan dan lebih sulit untuk menggunakan yang salah (= lebih kuat).

Salah satu contohnya adalah konflik baca / tulis dan tulis / tulis dalam kondisi lomba. Ini tidak dapat terjadi dalam struktur yang tidak dapat diubah, karena penulisan bukanlah operasi yang valid.

Juga, saya mengklaim bahwa mutabilitas hampir tidak pernah benar-benar diperlukan , programmer hanya berpikir bahwa mungkin di masa depan. Misalnya, tidak masuk akal untuk mengubah tanggal. Sebaliknya, buat tanggal baru berdasarkan tanggal yang lama. Ini adalah operasi yang murah, jadi kinerja bukan pertimbangan.

Struct yang bisa berubah tidak jahat.

Mereka mutlak diperlukan dalam keadaan kinerja tinggi. Misalnya ketika garis cache dan atau pengumpulan sampah menjadi hambatan.

Saya tidak akan menyebut penggunaan struct tidak berubah dalam kasus-kasus penggunaan yang benar-benar valid ini "jahat".

Saya dapat melihat poin bahwa sintaksis C # tidak membantu membedakan akses anggota dari tipe nilai atau tipe referensi, jadi saya semua lebih memilih struct yang tidak dapat diubah, yang menegakkan immutabilitas, lebih dari struct yang bisa berubah.

Namun, alih-alih hanya memberi label struct yang tidak dapat diubah sebagai "jahat", saya akan menyarankan untuk merangkul bahasa dan menganjurkan aturan praktis yang lebih bermanfaat dan konstruktif.

Misalnya: "struct adalah tipe nilai, yang disalin secara default. Anda perlu referensi jika Anda tidak ingin menyalinnya" atau "coba bekerja dengan struct yang hanya dibaca dulu" .

Bangunan dengan bidang atau properti yang bisa berubah publik tidak jahat.

Metode Struct (berbeda dari setter properti) yang bermutasi "ini" agak jahat, hanya karena .net tidak menyediakan cara untuk membedakan mereka dari metode yang tidak. Metode Struct yang tidak bermutasi "ini" harus tidak dapat dimasuki bahkan pada struct read-only tanpa perlu menyalin defensif. Metode yang bermutasi "ini" tidak boleh tidak bisa disangkal sama sekali pada struct read-only. Karena .net tidak ingin melarang metode struct yang tidak mengubah "ini" agar tidak dipanggil pada struct read-only, tetapi tidak ingin memperbolehkan struct read-only dimutasi, defensif menyalin struct di read- hanya konteks, bisa dibilang mendapatkan yang terburuk dari kedua dunia.

Meskipun ada masalah dengan penanganan metode yang bermutasi sendiri dalam konteks baca-saja, namun, struktur yang dapat berubah sering menawarkan semantik yang jauh lebih unggul daripada jenis kelas yang dapat berubah. Pertimbangkan tiga tanda tangan metode berikut:

struct PointyStruct {public int x, y, z;};
kelas PointyClass {public int x, y, z;};

membatalkan Method1 (PointyStruct foo);
membatalkan Method2 (ref PointyStruct foo);
membatalkan Method3 (PointyClass foo);

Untuk setiap metode, jawab pertanyaan berikut:

1. Dengan asumsi metode ini tidak menggunakan kode "tidak aman", mungkinkah itu memodifikasi foo?
2. Jika tidak ada referensi luar ke 'foo' sebelum metode dipanggil, bisakah referensi luar ada setelah?

_Jawaban:

Pertanyaan 1::
  Method1()tidak (maksud jelas)
  Method2() : ya (niat jelas)
  Method3() : ya (niat tidak pasti)
Pertanyaan 2
  Method1():: tidak
  Method2(): tidak (kecuali tidak aman)
  Method3() : ya

Method1 tidak dapat memodifikasi foo, dan tidak pernah mendapatkan referensi. Method2 mendapatkan referensi berumur pendek ke foo, yang dapat digunakan memodifikasi bidang foo beberapa kali, dalam urutan apa pun, sampai kembali, tetapi tidak dapat bertahan referensi itu. Sebelum Method2 kembali, kecuali ia menggunakan kode yang tidak aman, setiap dan semua salinan yang mungkin telah dibuat dari referensi 'foo' akan hilang. Method3, tidak seperti Method2, mendapatkan referensi foo yang bisa dibagi-bagi dengan foo, dan tidak ada yang tahu apa yang mungkin dilakukan dengan itu. Itu mungkin tidak mengubah foo sama sekali, mungkin mengubah foo dan kemudian kembali, atau mungkin memberikan referensi ke foo ke utas lain yang mungkin memutasinya dengan cara yang sewenang-wenang di waktu mendatang yang sewenang-wenang.

Susunan struktur menawarkan semantik yang indah. Diberikan RectArray [500] dari tipe Rectangle, jelas dan jelas bagaimana cara menyalin elemen 123 ke elemen 456 dan kemudian beberapa saat kemudian mengatur lebar elemen 123 hingga 555, tanpa elemen 456. "RectArray [432] = RectArray [321 ]; ...; RectArray [123] .Lebar = 555; ". Mengetahui bahwa Rectangle adalah sebuah struct dengan bidang bilangan bulat yang disebut Width akan memberi tahu semua orang yang perlu tahu tentang pernyataan di atas.

Sekarang misalkan RectClass adalah kelas dengan bidang yang sama dengan Rectangle dan seseorang ingin melakukan operasi yang sama pada RectClassArray [500] dari jenis RectClass. Mungkin array seharusnya menampung 500 referensi yang tidak dapat diinisialisasi untuk objek RectClass yang bisa diubah. dalam kasus itu, kode yang tepat akan menjadi sesuatu seperti "RectClassArray [321] .SetBounds (RectClassArray [456]); ...; RectClassArray [321] .X = 555;". Mungkin array diasumsikan memiliki instance yang tidak akan berubah, sehingga kode yang tepat akan lebih seperti "RectClassArray [321] = RectClassArray [456]; ...; RectClassArray [321] = New RectClass (RectClassArray [321] ]); RectClassArray [321] .X = 555; " Untuk mengetahui apa yang seharusnya dilakukan, kita harus tahu lebih banyak tentang RectClass (mis. Apakah itu mendukung copy constructor, metode copy-from, dll. ) dan tujuan penggunaan array. Tidak ada yang dekat sebersih menggunakan struct.

Yang pasti, sayangnya tidak ada cara yang bagus untuk kelas kontainer selain array untuk menawarkan semantik bersih dari array struct. Yang terbaik bisa dilakukan, jika seseorang ingin koleksi diindeks dengan misalnya string, mungkin akan menawarkan metode "ActOnItem" generik yang akan menerima string untuk indeks, parameter generik, dan delegasi yang akan diteruskan dengan referensi parameter generik dan item koleksi. Itu akan memungkinkan semantik yang hampir sama dengan array array, tetapi kecuali orang-orang vb.net dan C # dapat dikejar untuk menawarkan sintaks yang bagus, kode tersebut akan terlihat kikuk bahkan jika itu adalah kinerja yang wajar (melewati parameter generik akan memungkinkan untuk menggunakan delegasi statis dan akan menghindari kebutuhan untuk membuat instance kelas sementara)

Secara pribadi, saya kesal pada Eric Lippert dkk. memuntahkan tentang jenis nilai yang bisa berubah. Mereka menawarkan semantik yang lebih bersih daripada jenis referensi promiscuous yang digunakan di semua tempat. Meskipun ada beberapa batasan dengan dukungan .net untuk tipe nilai, ada banyak kasus di mana tipe nilai yang dapat berubah lebih cocok daripada jenis entitas lainnya.

Jenis nilai pada dasarnya mewakili konsep yang tidak berubah. Fx, tidak masuk akal untuk memiliki nilai matematika seperti integer, vektor dll dan kemudian dapat memodifikasinya. Itu akan seperti mendefinisikan kembali makna suatu nilai. Alih-alih mengubah tipe nilai, lebih masuk akal untuk menetapkan nilai unik lainnya. Pikirkan fakta bahwa tipe nilai dibandingkan dengan membandingkan semua nilai propertinya. Intinya adalah bahwa jika sifat-sifatnya sama maka itu adalah representasi universal yang sama dari nilai itu.

Seperti yang Konrad katakan, tidak masuk akal untuk mengubah tanggal juga, karena nilainya mewakili titik waktu yang unik dan bukan turunan dari objek waktu yang memiliki keadaan atau ketergantungan konteks apa pun.

Semoga ini masuk akal bagi Anda. Ini lebih tentang konsep yang Anda coba tangkap dengan tipe nilai daripada detail praktis, untuk memastikan.

Ada beberapa kasus sudut lain yang dapat menyebabkan perilaku yang tidak terduga dari sudut pandang programmer.

Jenis nilai yang tidak dapat diubah dan bidang yang hanya dapat dibaca

    // Simple mutable structure. 
    // Method IncrementI mutates current state.
    struct Mutable
    {
        public Mutable(int i) : this() 
        {
            I = i;
        }

        public void IncrementI() { I++; }

        public int I { get; private set; }
    }

    // Simple class that contains Mutable structure
    // as readonly field
    class SomeClass 
    {
        public readonly Mutable mutable = new Mutable(5);
    }

    // Simple class that contains Mutable structure
    // as ordinary (non-readonly) field
    class AnotherClass 
    {
        public Mutable mutable = new Mutable(5);
    }

    class Program
    {
        void Main()
        {
            // Case 1. Mutable readonly field
            var someClass = new SomeClass();
            someClass.mutable.IncrementI();
            // still 5, not 6, because SomeClass.mutable field is readonly
            // and compiler creates temporary copy every time when you trying to
            // access this field
            Console.WriteLine(someClass.mutable.I);

            // Case 2. Mutable ordinary field
            var anotherClass = new AnotherClass();
            anotherClass.mutable.IncrementI();

            // Prints 6, because AnotherClass.mutable field is not readonly
            Console.WriteLine(anotherClass.mutable.I);
        }
    }

Jenis dan array nilai yang dapat diubah

Misalkan kita memiliki array Mutablestruct kita dan kita memanggil IncrementImetode untuk elemen pertama array itu. Perilaku apa yang Anda harapkan dari panggilan ini? Haruskah itu mengubah nilai array atau hanya salinan?

    Mutable[] arrayOfMutables = new Mutable[1];
    arrayOfMutables[0] = new Mutable(5);

    // Now we actually accessing reference to the first element
    // without making any additional copy
    arrayOfMutables[0].IncrementI();

    // Prints 6!!
    Console.WriteLine(arrayOfMutables[0].I);

    // Every array implements IList<T> interface
    IList<Mutable> listOfMutables = arrayOfMutables;

    // But accessing values through this interface lead
    // to different behavior: IList indexer returns a copy
    // instead of an managed reference
    listOfMutables[0].IncrementI(); // Should change I to 7

    // Nope! we still have 6, because previous line of code
    // mutate a copy instead of a list value
    Console.WriteLine(listOfMutables[0].I);

Jadi, struct yang bisa berubah tidak jahat selama Anda dan anggota tim lainnya memahami dengan jelas apa yang Anda lakukan. Tetapi ada terlalu banyak kasus sudut ketika perilaku program akan berbeda dari apa yang diharapkan, yang dapat menyebabkan sulit untuk diproduksi dan sulit untuk memahami kesalahan.

Jika Anda pernah memprogram dalam bahasa seperti C / C ++, struct boleh digunakan sebagai bisa berubah. Cukup berikan mereka dengan referensi, sekitar dan tidak ada yang salah. Satu-satunya masalah yang saya temukan adalah pembatasan dari kompiler C # dan bahwa, dalam beberapa kasus, saya tidak dapat memaksa hal bodoh untuk menggunakan referensi ke struct, bukan Salin (seperti ketika sebuah struct adalah bagian dari kelas C # ).

Jadi, struct yang bisa berubah tidak jahat, C # telah membuatnya jahat. Saya menggunakan struct bisa berubah dalam C ++ sepanjang waktu dan mereka sangat nyaman dan intuitif. Sebaliknya, C # membuat saya untuk sepenuhnya meninggalkan struct sebagai anggota kelas karena cara mereka menangani objek. Kenyamanan mereka telah merugikan kita.

Jika Anda berpegang pada apa yang dimaksudkan untuk struct (dalam C #, Visual Basic 6, Pascal / Delphi, tipe C ++ struct (atau kelas) ketika mereka tidak digunakan sebagai pointer), Anda akan menemukan bahwa struktur tidak lebih dari variabel gabungan . Ini berarti: Anda akan memperlakukan mereka sebagai satu set variabel yang dikemas, dengan nama umum (variabel rekaman yang Anda referensikan dari anggota).

Saya tahu itu akan membingungkan banyak orang yang terbiasa dengan OOP, tetapi itu tidak cukup alasan untuk mengatakan hal-hal seperti itu pada dasarnya jahat, jika digunakan dengan benar. Beberapa struktur tidak dapat diubah karena mereka berniat (ini adalah kasus Python namedtuple), tetapi ini adalah paradigma lain yang perlu dipertimbangkan.

Ya: struct melibatkan banyak memori, tetapi itu tidak akan menjadi lebih banyak memori dengan melakukan:

point.x = point.x + 1

dibandingkan dengan:

point = Point(point.x + 1, point.y)

Konsumsi memori akan setidaknya sama, atau bahkan lebih dalam kasus yang tidak dapat diputuskan (meskipun kasus itu akan bersifat sementara, untuk tumpukan saat ini, tergantung pada bahasa).

Tetapi, akhirnya, struktur adalah struktur , bukan objek. Dalam POO, properti utama suatu objek adalah identitas mereka , yang sebagian besar waktunya tidak lebih dari alamat ingatannya. Struct adalah singkatan dari struktur data (bukan objek yang tepat, dan karenanya mereka tidak memiliki identitas), dan data dapat dimodifikasi. Dalam bahasa lain, catatan (bukan struct , seperti halnya untuk Pascal) adalah kata dan memiliki tujuan yang sama: hanya variabel catatan data, dimaksudkan untuk dibaca dari file, dimodifikasi, dan dibuang ke file (itu adalah utama gunakan dan, dalam banyak bahasa, Anda bahkan dapat mendefinisikan penyelarasan data dalam catatan, sementara itu tidak selalu berarti untuk Objek yang disebut dengan benar).

Ingin contoh yang bagus? Structs digunakan untuk membaca file dengan mudah. Python memiliki pustaka ini karena, karena berorientasi objek dan tidak memiliki dukungan untuk struct, ia harus mengimplementasikannya dengan cara lain, yang agak jelek. Bahasa yang menerapkan struct memiliki fitur itu ... bawaan. Cobalah membaca header bitmap dengan struct yang sesuai dalam bahasa seperti Pascal atau C. Akan mudah (jika struct dibangun dan disejajarkan dengan benar; di Pascal Anda tidak akan menggunakan akses berbasis catatan tetapi berfungsi untuk membaca data biner acak). Jadi, untuk file dan akses memori (lokal) langsung, struct lebih baik daripada objek. Seperti untuk hari ini, kita terbiasa dengan JSON dan XML, jadi kita lupa penggunaan file biner (dan sebagai efek samping, penggunaan struct). Tapi ya: mereka ada, dan punya tujuan.

Mereka tidak jahat. Cukup gunakan untuk tujuan yang benar.

Jika Anda berpikir tentang palu, Anda akan ingin memperlakukan sekrup sebagai paku, untuk menemukan sekrup lebih sulit untuk dipasang di dinding, dan itu akan menjadi kesalahan sekrup, dan mereka akan menjadi yang jahat.

Bayangkan Anda memiliki array 1.000.000 struct. Setiap struct mewakili ekuitas dengan hal-hal seperti bid_price, offer_price (mungkin desimal) dan seterusnya, ini dibuat oleh C # / VB.

Bayangkan bahwa array dibuat dalam blok memori yang dialokasikan dalam heap yang tidak dikelola sehingga beberapa thread kode asli lainnya dapat secara bersamaan mengakses array (mungkin beberapa kode perf-tinggi melakukan matematika).

Bayangkan kode C # / VB sedang mendengarkan umpan pasar dari perubahan harga, kode itu mungkin harus mengakses beberapa elemen array (untuk keamanan apa pun) dan kemudian memodifikasi beberapa bidang harga.

Bayangkan ini dilakukan puluhan atau bahkan ratusan ribu kali per detik.

Yah mari kita hadapi fakta, dalam hal ini kita benar-benar ingin struct ini bisa berubah, mereka harus karena mereka sedang dibagikan oleh beberapa kode asli lain sehingga membuat salinan tidak akan membantu; mereka perlu karena membuat salinan dari beberapa struct 120 byte pada tingkat ini adalah kegilaan, terutama ketika pembaruan sebenarnya dapat berdampak hanya satu atau dua byte.

Hugo

Ketika sesuatu dapat bermutasi, ia memperoleh rasa identitas.

struct Person {
    public string name; // mutable
    public Point position = new Point(0, 0); // mutable

    public Person(string name, Point position) { ... }
}

Person eric = new Person("Eric Lippert", new Point(4, 2));

Karena Personbisa berubah, lebih alami untuk berpikir tentang mengubah posisi Eric daripada mengkloning Eric, memindahkan klon, dan menghancurkan yang asli . Kedua operasi akan berhasil mengubah konten eric.position, tetapi yang satu lebih intuitif daripada yang lain. Demikian juga, lebih intuitif untuk memberikan Eric sekitar (sebagai referensi) untuk metode untuk memodifikasinya. Memberikan metode klon Eric hampir selalu akan mengejutkan. Siapa pun yang ingin bermutasi Personharus ingat untuk meminta referensi Personatau mereka akan melakukan hal yang salah.

Jika Anda membuat jenisnya tidak dapat diubah, masalahnya hilang; jika saya tidak dapat memodifikasi eric, tidak ada bedanya bagi saya apakah saya menerima ericatau tiruan dari eric. Secara lebih umum, suatu jenis aman untuk dilewati oleh nilai jika semua negara yang dapat diamati dimiliki oleh anggota yang:

• abadi
• jenis referensi
• aman untuk melewati nilai

Jika kondisi tersebut terpenuhi maka tipe nilai yang dapat berubah berperilaku seperti tipe referensi karena salinan yang dangkal masih akan memungkinkan penerima untuk memodifikasi data asli.

Intuisi kekekalan Persontergantung pada apa yang Anda coba lakukan. Jika Personhanya mewakili sekumpulan data tentang seseorang, tidak ada yang tidak intuitif tentangnya; Personvariabel benar-benar mewakili nilai abstrak , bukan objek. (Dalam hal itu, mungkin akan lebih tepat untuk mengubah nama menjadi PersonData.) Jika Personsebenarnya memodelkan seseorang itu sendiri, ide untuk terus-menerus membuat dan memindahkan klon adalah konyol bahkan jika Anda telah menghindari perangkap berpikir Anda memodifikasi asli. Dalam hal itu mungkin akan lebih alami untuk hanya membuat Persontipe referensi (yaitu, kelas.)

Memang, seperti pemrograman fungsional telah mengajarkan kepada kita ada manfaat untuk membuat semuanya berubah (tidak ada yang dapat diam-diam berpegang pada referensi ericdan memutasinya), tetapi karena itu bukan idiomatik dalam OOP itu masih akan menjadi tidak intuitif untuk orang lain yang bekerja dengan Anda kode.

Itu tidak ada hubungannya dengan struct (dan tidak dengan C #, baik) tetapi di Jawa Anda mungkin mendapatkan masalah dengan objek yang bisa berubah ketika mereka misalnya kunci dalam peta hash. Jika Anda mengubahnya setelah menambahkannya ke peta dan itu mengubah kode hash , hal-hal jahat mungkin terjadi.

Secara pribadi ketika saya melihat kode berikut ini terlihat cukup kikuk bagi saya:

data.value.set (data.value.get () + 1);

bukan hanya

data.value ++; atau data.value = data.value + 1;

Enkapsulasi data berguna ketika melewati kelas di sekitar dan Anda ingin memastikan nilai dimodifikasi secara terkendali. Namun ketika Anda memiliki set publik dan mendapatkan fungsi yang tidak lebih dari menetapkan nilai pada apa yang pernah diteruskan, bagaimana ini merupakan peningkatan dari sekadar meneruskan struktur data publik?

Ketika saya membuat struktur pribadi di dalam kelas, saya membuat struktur itu untuk mengatur satu set variabel menjadi satu kelompok. Saya ingin dapat memodifikasi struktur itu dalam ruang lingkup kelas, tidak mendapatkan salinan dari struktur itu dan membuat contoh baru.

Bagi saya ini mencegah penggunaan yang valid dari struktur yang digunakan untuk mengatur variabel publik, jika saya ingin kontrol akses saya akan menggunakan kelas.

Ada beberapa masalah dengan contoh Mr. Eric Lippert. Ini dibuat untuk menggambarkan titik bahwa struct disalin dan bagaimana itu bisa menjadi masalah jika Anda tidak hati-hati. Melihat contoh saya melihatnya sebagai hasil dari kebiasaan pemrograman yang buruk dan tidak benar-benar masalah dengan struct atau kelas.

1. Seorang struct seharusnya hanya memiliki anggota publik dan tidak perlu enkapsulasi. Jika ya maka itu benar-benar harus tipe / kelas. Anda benar-benar tidak perlu dua konstruksi untuk mengatakan hal yang sama.

2. Jika Anda memiliki kelas yang menyertakan struct, Anda akan memanggil metode di kelas untuk memutasi struct member. Inilah yang akan saya lakukan sebagai kebiasaan pemrograman yang baik.

Implementasi yang tepat adalah sebagai berikut.

struct Mutable {
public int x;
}

class Test {
    private Mutable m = new Mutable();
    public int mutate()
    { 
        m.x = m.x + 1;
        return m.x;
    }
  }
  static void Main(string[] args) {
        Test t = new Test();
        System.Console.WriteLine(t.mutate());
        System.Console.WriteLine(t.mutate());
        System.Console.WriteLine(t.mutate());
    }

Sepertinya itu adalah masalah dengan kebiasaan pemrograman yang bertentangan dengan masalah dengan struct itu sendiri. Structs seharusnya bisa berubah, itulah ide dan maksudnya.

Hasil dari perubahan voila berlaku seperti yang diharapkan:

1 2 3 Tekan tombol apa saja untuk melanjutkan. . .

Ada banyak keuntungan dan kerugian dari data yang bisa berubah. Kerugian jutaan dolar adalah aliasing. Jika nilai yang sama digunakan di banyak tempat, dan salah satunya mengubahnya, maka secara ajaib akan berubah menjadi tempat lain yang menggunakannya. Ini terkait dengan, tetapi tidak identik dengan, kondisi lomba.

Keuntungan jutaan dolar adalah modularitas, kadang-kadang. Status yang dapat diubah dapat memungkinkan Anda untuk menyembunyikan informasi yang berubah dari kode yang tidak perlu diketahui tentang hal itu.

Art of the Interpreter membahas trade off ini secara rinci, dan memberikan beberapa contoh.

Saya tidak percaya mereka jahat jika digunakan dengan benar. Saya tidak akan memasukkannya ke dalam kode produksi saya, tetapi saya akan melakukan sesuatu seperti mengolok-olok pengujian unit terstruktur, di mana umur sebuah struct relatif kecil.

Menggunakan contoh Eric, mungkin Anda ingin membuat contoh kedua dari Eric itu, tetapi buat penyesuaian, karena itulah sifat pengujian Anda (yaitu duplikasi, lalu modifikasi). Tidak masalah apa yang terjadi dengan instance pertama Eric jika kita hanya menggunakan Eric2 untuk sisa skrip pengujian, kecuali jika Anda berencana menggunakannya sebagai perbandingan pengujian.

Ini akan sangat berguna untuk menguji atau memodifikasi kode legacy yang dangkal mendefinisikan objek tertentu (titik struct), tetapi dengan memiliki struct yang tidak dapat diubah, ini mencegah penggunaannya secara mengganggu.