C++ Academy · Pelajaran

Union dan Risikonya

Berbagi memori antar tipe

Union dan Risikonya adalah pelajaran C++ Academy gratis di CoddyKit. Ini adalah pelajaran 2 dari 4. Kamu bisa membaca pelajaran lengkapnya di bawah secara gratis — lalu praktikkan langsung di browser dengan editor kode bawaan dan tutor AI 24/7. Ini adalah bagian dari jalur belajar C++ Academy, dan progresmu tersinkronisasi di web dan aplikasi CoddyKit. Kursus C++ Academy mencakup 4 pelajaran total.

Apa Itu Union?

union memungkinkan beberapa anggota berbagi memori yang sama. Hanya satu anggota yang valid pada satu waktu, dan union hanya sebesar anggotanya yang terbesar.

#include <iostream>
union Number {
    int i;
    float f;
};
int main() {
    Number n;
    n.i = 42;
    std::cout << n.i << "\n";
}

Ukuran Union

Karena para anggotanya saling tumpang tindih, sizeof union sama dengan ukuran anggotanya yang terbesar (ditambah ruang pelengkap untuk penyelarasan), bukan jumlah ukuran semua anggota.

#include <iostream>
union Mix { char c; int i; double d; };
int main() {
    std::cout << sizeof(Mix) << "\n"; // size of double (often 8)
}

Menulis Satu, Membaca yang Lain

Menulis satu anggota lalu membaca anggota yang berbeda merupakan risiko utama. Bit-bitnya ditafsirkan ulang, yang biasanya menghasilkan perilaku tidak terdefinisi atau mengejutkan.

#include <iostream>
union Bits { int i; float f; };
int main() {
    Bits b;
    b.f = 1.0f;
    std::cout << b.i << "\n"; // reads float bits as int
}

Hanya Satu Anggota yang Aktif

Anggota yang terakhir kali Anda tulis adalah satu-satunya anggota yang dapat Anda baca dengan aman. Catat sendiri anggota mana yang "aktif"; gabungan tersebut tidak mengingatnya.

#include <iostream>
union Value { int i; double d; };
int main() {
    Value v;
    v.d = 3.14;        // d is active
    std::cout << v.d << "\n";
}

Pola Tagged Gabungan

Untuk menggunakan gabungan dengan aman, pasangkan dengan sebuah tanda (enum) yang mencatat anggota yang aktif. Ini adalah pendahulu manual dari std::variant.

#include <iostream>
struct Tagged {
    enum { Int, Double } tag;
    union { int i; double d; };
};
int main() {
    Tagged t; t.tag = Tagged::Int; t.i = 7;
    if (t.tag == Tagged::Int) std::cout << t.i << "\n";
}

Membaca Anggota yang Tepat

Selalu lakukan percabangan berdasarkan tanda sebelum membaca. Membaca anggota yang salah menghasilkan nilai sampah.

#include <iostream>
struct Tagged {
    enum { Int, Double } tag;
    union { int i; double d; };
};
void print(const Tagged& t) {
    if (t.tag == Tagged::Int) std::cout << "int " << t.i << "\n";
    else std::cout << "double " << t.d << "\n";
}
int main() { Tagged t{Tagged::Double}; t.d = 2.5; print(t); }

Anggota Nontrivial

Menempatkan anggota yang memiliki konstruktor atau destruktor (seperti std::string) dalam gabungan memerlukan konstruksi dan penghancuran secara manual. Cara ini rentan kesalahan, sehingga menjadi alasan lain untuk memilih std::variant.

Gabungan Anonim

Sebuah gabungan anonim tidak memiliki nama; anggotanya diakses secara langsung. Gabungan ini berguna di dalam struct, tetapi aturan anggota aktif yang sama tetap berlaku.

#include <iostream>
struct Packet {
    int kind;
    union { int code; char letter; };
};
int main() {
    Packet p; p.kind = 1; p.code = 99;
    std::cout << p.code << "\n";
}

Mengapa Gabungan Berisiko

Ringkasan bahayanya:

Tidak ada informasi tentang anggota mana yang aktif.
Membaca anggota yang tidak aktif merupakan perilaku tidak terdefinisi.
Tipe nontrivial memerlukan pengelolaan masa hidup secara manual.

Kapan Gabungan Masih Berguna

Gabungan tetap berguna untuk pekerjaan tingkat rendah: menafsirkan ulang byte, menghemat memori dalam kode tertanam yang ketat, atau menyesuaikan tata letak biner yang tetap. Untuk data sehari-hari yang berupa "salah satu dari beberapa tipe", pilih alternatif yang lebih aman.

Menuju std::variant

std::variant adalah gabungan yang aman terhadap tipe, yang melacak tipe aktif untuk Anda dan melempar pengecualian jika Anda mengakses tipe yang salah. Sisa kursus ini akan membahasnya.

Pemeriksaan Singkat

Periksa pemahaman Anda tentang gabungan.

Rangkuman

Anda telah mempelajari gabungan:

Semua anggota berbagi satu blok memori.
Hanya anggota yang terakhir ditulis yang valid untuk dibaca.
Gunakan tanda (enum) untuk melacak anggota yang aktif.
Untuk keamanan dalam C++ modern, pilih std::variant.

Pertanyaan yang Sering Diajukan

Apakah pelajaran “Union dan Risikonya” gratis?

Ya — teks lengkap “Union dan Risikonya” gratis dibaca di sini di web. Untuk praktiknya secara interaktif (editor kode bawaan dan tutor AI 24/7) dan buka sisa kursus C++ Academy, upgrade ke CoddyKit PRO. Kursus C++ Academy mencakup 4 pelajaran total.

Apa yang akan aku pelajari di “Union dan Risikonya”?

Berbagi memori antar tipe Kamu berlatih C++ Academy dengan kode praktik yang langsung kamu jalankan di browser, dan tutor AI 24/7 menjawab pertanyaanmu saat kamu mengerjakan pelajaran ini.

Apakah aku perlu pengalaman untuk memulai C++ Academy?

Tidak diperlukan pengalaman sebelumnya. C++ Academy di CoddyKit dirancang untuk pemula hingga pelajar tingkat lanjut, jadi kamu bisa memulai di sini atau dari awal dan belajar sesuai kecepatan kamu sendiri. Ini adalah pelajaran 2 dari 4.

Berapa lama pelajaran “Union dan Risikonya” memakan waktu?

Sebagian besar pelajaran CoddyKit memakan waktu sekitar 5–10 menit. Setiap pelajaran ringkas dan interaktif, jadi kamu membuat kemajuan stabil dan melanjutkan dari tempat kamu tinggalkan di web dan aplikasi.

Bisakah aku menulis dan menjalankan kode dalam pelajaran C++ Academy ini?

Ya. Setiap pelajaran C++ Academy menyertakan editor kode bawaan, jadi kamu menulis dan menjalankan kode nyata langsung di browser dan mendapatkan umpan balik AI instan — tidak diperlukan penyiapan lokal.

Semua pelajaran dalam kursus ini

← Kembali ke C++ Academy