C++ Academy · Pelajaran

std::variant

Union yang selamat dari segi jenis

Pelajaran 3 daripada 413 langkah

std::variant ialah pelajaran C++ Academy percuma di CoddyKit. Ini ialah pelajaran 3 daripada 4. Sebanyak 3 pelajaran dalam laluan pembelajaran ini boleh dibaca sepenuhnya secara percuma — selepas itu, CoddyKit PRO membuka akses kepada semua pelajaran, serta latihan praktikal dengan penyunting kod terbina dalam dan tutor kecerdasan buatan yang tersedia 24/7. Pelajaran ini merupakan sebahagian daripada laluan pembelajaran C++ Academy, dan kemajuan anda disegerakkan merentas web serta aplikasi CoddyKit. Kursus C++ Academy merangkumi sejumlah 4 pelajaran.

Union Selamat Jenis

std::variant menyimpan tepat satu nilai daripada senarai jenis tetap dan mengingati jenis tersebut. Sertakan <variant> untuk menggunakannya.

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

Menetapkan Jenis yang Berbeza

Anda boleh menetapkan semula variant kepada mana-mana jenis alternatifnya. Ia mengemas kini alternatif yang aktif secara automatik.

#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";
}

Menyemak Jenis Aktif

std::holds_alternative<T>(v) memberitahu anda sama ada variant sedang menyimpan jenis 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 kedudukan berasaskan sifar bagi jenis aktif dalam senarai jenis.

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

Akses Selamat dengan std::get

std::get<T> mengembalikan nilai jika T aktif; jika tidak, ia melontar pengecualian std::bad_variant_access. Tiada nilai sampah yang senyap.

#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 Melontar Pengecualian

std::get_if<T>(&v) mengembalikan penuding kepada nilai atau nullptr jika T tidak aktif. Sangat sesuai untuk semakan 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";
}

Pembinaan Lalai

Variant yang dibina secara lalai menyimpan versi jenis pertamanya yang dimulakan dengan nilai. Susun jenis anda supaya jenis pertama memberikan nilai lalai yang munasabah.

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

Menyimpan Rentetan

Berbeza daripada union mentah, variant boleh menyimpan jenis tidak trivial seperti std::string dengan selamat; jangka hayat diuruskan 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";
}

Variant sebagai Jenis Pulangan

Satu fungsi boleh mengembalikan salah satu daripada beberapa jenis dengan mengembalikan variant. Pemanggil kemudiannya memeriksanya untuk mengetahui jenis 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...) membina nilai baharu jenis T secara terus di dalam variant, lalu menukar alternatif 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";
}

Sebab Memilih Variant?

std::variant memberikan kecekapan memori union dengan keselamatan jenis sepenuhnya: ia menjejaki jenis aktif, mengurus jangka hayat, dan menolak akses kepada jenis yang salah. Pelajaran seterusnya menunjukkan cara paling kemas untuk memprosesnya.

Semakan Pantas

Semak pemahaman anda tentang std::variant.

Jawab dalam pelajaran interaktif

Ringkasan

Anda telah mempelajari std::variant:

Menyimpan salah satu daripada beberapa jenis dan menjejaki jenis tersebut.
holds_alternative / index() memeriksa jenis aktif.
std::get melontar pengecualian jika tidak sepadan; get_if mengembalikan penuding atau null.
Menyimpan jenis tidak trivial seperti std::string dengan selamat.

Percuma untuk bermula

Pelajari C++ dengan tutor kecerdasan buatan — percuma

Tulis dan jalankan kod sebenar dalam pelayar anda, dapatkan bantuan segera daripada tutor kecerdasan buatan yang tersedia 24/7, dan sambung semula dari tempat anda berhenti di web atau dalam aplikasi.

Kursus: 51
Pelajaran: 203

Mula belajar secara percuma Lihat kursus penuh

Soalan Lazim

Adakah pelajaran “std::variant” percuma?

Ya — sebanyak 3 pelajaran dalam laluan pembelajaran C++ Academy, termasuk “std::variant”, boleh dibaca sepenuhnya secara percuma di web ini. Selepas itu, CoddyKit PRO membuka akses kepada semua pelajaran, serta latihan interaktif dengan penyunting kod terbina dalam dan tutor kecerdasan buatan yang tersedia 24/7. Kursus C++ Academy merangkumi sejumlah 4 pelajaran.

Apakah yang akan saya pelajari dalam “std::variant”?

Union yang selamat dari segi jenis Anda berlatih C++ Academy menggunakan kod praktikal yang dijalankan terus dalam pelayar, manakala tutor kecerdasan buatan 24/7 menjawab soalan anda semasa anda mengikuti pelajaran.

Adakah saya memerlukan pengalaman untuk memulakan C++ Academy?

Tiada pengalaman terdahulu diperlukan. Pembelajaran C++ Academy di CoddyKit disusun untuk pelajar daripada peringkat pemula hingga lanjutan, jadi anda boleh bermula di sini atau dari awal dan belajar mengikut kadar anda sendiri. Ini ialah pelajaran 3 daripada 4.

Berapa lamakah pelajaran “std::variant” diambil?

Kebanyakan pelajaran CoddyKit mengambil masa kira-kira 5–10 minit. Setiap pelajaran ringkas dan interaktif, jadi anda boleh membuat kemajuan secara berterusan dan menyambung tepat dari tempat anda berhenti di web atau aplikasi.

Bolehkah saya menulis dan menjalankan kod dalam pelajaran C++ Academy ini?

Ya. Setiap pelajaran C++ Academy menyertakan penyunting kod terbina dalam, jadi anda boleh menulis dan menjalankan kod sebenar terus dalam pelayar serta menerima maklum balas kecerdasan buatan serta-merta — tanpa memerlukan persediaan setempat.

Semua pelajaran dalam kursus ini

← Kembali ke C++ Academy