std::visit
Proses alternatif variant
std::visit adalah pelajaran C++ Academy gratis di CoddyKit. Ini adalah pelajaran 4 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.
Mengapa Menggunakan std::visit?
Memeriksa setiap alternatif secara manual dengan get_if menjadi panjang. std::visit menerapkan objek yang dapat dipanggil ke tipe apa pun yang saat ini disimpan varian dan menangani pemilihan pemanggilan untuk Anda.
#include <iostream>
#include <variant>
int main() {
std::variant<int, double> v = 4;
std::visit([](auto x){ std::cout << x << "\n"; }, v);
}Pengunjung Lambda Generik
Lambda yang menerima auto dapat digunakan untuk setiap alternatif jika isi badannya dapat dikompilasi untuk semuanya. Di sini kita mencetak tipe apa pun yang sedang aktif.
#include <iostream>
#include <string>
#include <variant>
int main() {
std::variant<int, std::string> v = std::string("hi");
std::visit([](const auto& x){ std::cout << x << "\n"; }, v);
}Mengembalikan Nilai
std::visit dapat mengembalikan nilai. Setiap cabang harus mengembalikan tipe yang sama.
#include <iostream>
#include <variant>
int main() {
std::variant<int, double> v = 2.5;
double d = std::visit([](auto x){ return x * 2.0; }, v);
std::cout << d << "\n";
}Perilaku per Tipe dengan if constexpr
Untuk bertindak secara berbeda berdasarkan tipe di dalam satu lambda generik, gabungkan if constexpr dengan std::decay_t dan std::is_same_v.
#include <iostream>
#include <string>
#include <variant>
#include <type_traits>
int main() {
std::variant<int, std::string> v = 5;
std::visit([](const auto& x){
using T = std::decay_t<decltype(x)>;
if constexpr (std::is_same_v<T, int>) std::cout << "int " << x << "\n";
else std::cout << "str " << x << "\n";
}, v);
}Pengunjung Struct
Anda juga dapat menulis struct dengan beberapa kelebihan beban operator(), satu untuk setiap tipe. Kompilator memilih kelebihan beban yang cocok.
#include <iostream>
#include <string>
#include <variant>
struct Printer {
void operator()(int i) const { std::cout << "int " << i << "\n"; }
void operator()(const std::string& s) const { std::cout << "str " << s << "\n"; }
};
int main() {
std::variant<int, std::string> v = std::string("yo");
std::visit(Printer{}, v);
}Idiom overloaded
Pembantu yang populer menggabungkan beberapa lambda menjadi satu pengunjung. Setiap lambda menangani tipe tertentu.
#include <iostream>
#include <string>
#include <variant>
template<class... Ts> struct overloaded : Ts... { using Ts::operator()...; };
template<class... Ts> overloaded(Ts...) -> overloaded<Ts...>;
int main() {
std::variant<int, std::string> v = 8;
std::visit(overloaded{
[](int i){ std::cout << "i=" << i << "\n"; },
[](const std::string& s){ std::cout << "s=" << s << "\n"; }
}, v);
}Kelengkapan Kasus
Pengunjung harus menangani setiap alternatif, atau kode gagal dikompilasi. Pemeriksaan saat kompilasi ini mencegah Anda melupakan suatu kasus.
Mengunjungi dan Memodifikasi
Jika Anda meneruskan varian sebagai referensi non-const, pengunjung dapat mengubah nilai yang disimpan langsung di tempatnya.
#include <iostream>
#include <variant>
int main() {
std::variant<int, double> v = 10;
std::visit([](auto& x){ x += 1; }, v);
std::cout << std::get<int>(v) << "\n";
}Beberapa Varian
std::visit dapat menerima beberapa varian sekaligus; pengunjung kemudian menerima satu argumen untuk setiap varian.
#include <iostream>
#include <variant>
int main() {
std::variant<int, double> a = 2;
std::variant<int, double> b = 3.0;
auto sum = std::visit([](auto x, auto y){ return x + y; }, a, b);
std::cout << sum << "\n";
}Memilih Gaya Pengunjung
Gunakan lambda auto generik untuk penanganan yang seragam, idiom overloaded untuk logika per tipe yang rapi, dan pengunjung struct jika perilakunya dapat digunakan kembali di berbagai lokasi pemanggilan.
Visit dibandingkan dengan get_if
get_if cocok untuk satu pemeriksaan singkat, tetapi std::visit lebih mudah diperluas: fitur ini mewajibkan semua alternatif ditangani dan menyimpan seluruh logika per tipe di satu tempat.
Pemeriksaan Singkat
Periksa pemahaman Anda tentang std::visit.
Rangkuman
Anda telah mempelajari std::visit:
- Meneruskan objek yang dapat dipanggil ke alternatif yang aktif.
- Gunakan lambda generik,
if constexpr, pengunjung struct, atau idiom overloaded. - Pengunjung harus menangani semua kasus (pemeriksaan saat kompilasi).
- Dapat mengembalikan nilai dan mengunjungi beberapa varian sekaligus.
Pertanyaan yang Sering Diajukan
Apakah pelajaran “std::visit” gratis?
Ya — teks lengkap “std::visit” 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::visit”?
Proses alternatif variant 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 4 dari 4.
Berapa lama pelajaran “std::visit” 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.