C++ Academy · Pelajaran

std::variant

Union yang aman secara tipe

std::variant adalah pelajaran C++ Academy gratis di CoddyKit. Ini adalah pelajaran 3 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.

Gabungan yang Aman terhadap Tipe

std::variant menyimpan tepat satu nilai dari daftar tipe yang tetap dan mengingat tipe yang sedang disimpan. Sertakan <variant> untuk menggunakannya.

#include <iostream>
#include <variant>
int main() {
    std::variant<int, double> v = 10;
    std::cout << std::get<int>(v) << "\n";
}

Menetapkan Tipe yang Berbeda

Anda dapat menetapkan ulang varian ke tipe alternatif mana pun yang dimilikinya. Varian tersebut secara otomatis memperbarui alternatif yang aktif.

#include <iostream>
#include <variant>
int main() {
    std::variant<int, double> v = 5;
    v = 3.14; // now holds a double
    std::cout << std::get<double>(v) << "\n";
}

Memeriksa Tipe Aktif

std::holds_alternative<T>(v) memberi tahu Anda apakah varian saat ini menyimpan tipe T.

#include <iostream>
#include <variant>
int main() {
    std::variant<int, double> v = 2.0;
    std::cout << std::holds_alternative<double>(v) << "\n";
    std::cout << std::holds_alternative<int>(v) << "\n";
}

Fungsi index()

v.index() mengembalikan posisi berbasis nol dari tipe aktif dalam daftar tipe.

#include <iostream>
#include <variant>
int main() {
    std::variant<int, double, char> v = (char)65;
    std::cout << v.index() << "\n"; // 2
}

Akses Aman dengan std::get

std::get<T> mengembalikan nilai jika T aktif; jika tidak, fungsi tersebut melempar pengecualian std::bad_variant_access. Tidak ada nilai sampah yang muncul diam-diam.

#include <iostream>
#include <variant>
int main() {
    std::variant<int, double> v = 7;
    try {
        std::cout << std::get<double>(v) << "\n";
    } catch (const std::bad_variant_access& e) {
        std::cout << "wrong type!\n";
    }
}

get_if Tanpa Pengecualian

std::get_if<T>(&v) mengembalikan penunjuk ke nilai, atau nullptr jika T tidak aktif. Sangat cocok untuk pemeriksaan tanpa percabangan.

#include <iostream>
#include <variant>
int main() {
    std::variant<int, double> v = 9;
    if (auto p = std::get_if<int>(&v))
        std::cout << "int " << *p << "\n";
}

Konstruksi Bawaan

Varian yang dikonstruksi secara bawaan menyimpan versi yang diinisialisasi nilainya dari tipe pertama. Urutkan tipe Anda sehingga tipe pertama menghasilkan nilai bawaan yang masuk akal.

#include <iostream>
#include <variant>
int main() {
    std::variant<int, double> v; // holds int 0
    std::cout << std::get<int>(v) << "\n";
}

Menyimpan String

Berbeda dari gabungan mentah, varian dapat menyimpan tipe nontrivial seperti std::string dengan aman; masa hidupnya dikelola untuk Anda.

#include <iostream>
#include <string>
#include <variant>
int main() {
    std::variant<int, std::string> v = std::string("hello");
    std::cout << std::get<std::string>(v) << "\n";
}

Varian sebagai Tipe Pengembalian

Sebuah fungsi dapat mengembalikan salah satu dari beberapa tipe dengan mengembalikan varian. Pemanggil kemudian memeriksanya untuk mengetahui tipe mana yang dikembalikan.

#include <iostream>
#include <string>
#include <variant>
std::variant<int, std::string> parse(bool ok) {
    if (ok) return 42;
    return std::string("error");
}
int main() {
    auto r = parse(false);
    if (auto s = std::get_if<std::string>(&r)) std::cout << *s << "\n";
}

emplace untuk Perubahan di Tempat

v.emplace<T>(args...) mengonstruksi nilai baru bertipe T langsung di dalam varian dan mengubah alternatif yang aktif.

#include <iostream>
#include <string>
#include <variant>
int main() {
    std::variant<int, std::string> v = 1;
    v.emplace<std::string>("switched");
    std::cout << std::get<std::string>(v) << "\n";
}

Mengapa Memilih Variant?

std::variant memberi Anda efisiensi memori gabungan dengan keamanan tipe penuh: fitur ini melacak tipe aktif, mengelola masa hidup, dan menolak akses dengan tipe yang salah. Pelajaran berikutnya menunjukkan cara paling bersih untuk memprosesnya.

Pemeriksaan Singkat

Periksa pemahaman Anda tentang std::variant.

Rangkuman

Anda telah mempelajari std::variant:

Menyimpan salah satu dari beberapa tipe dan melacak tipe yang sedang disimpan.
holds_alternative / index() memeriksa tipe aktif.
std::get melempar pengecualian jika tidak cocok; get_if mengembalikan penunjuk atau null.
Menyimpan tipe nontrivial seperti std::string dengan aman.

Pertanyaan yang Sering Diajukan

Apakah pelajaran “std::variant” gratis?

Ya — teks lengkap “std::variant” 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 “std::variant”?

Union yang aman secara 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 3 dari 4.

Berapa lama pelajaran “std::variant” 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