std::variant
Bezpieczna typowo unia
std::variant to bezpłatna lekcja C++ Academy na CoddyKit. To lekcja 3 z 4. Możesz przeczytać całą lekcję poniżej za darmo — a potem ćwiczyć ją interaktywnie w przeglądarce z wbudowanym edytorem kodu i tutorem AI dostępnym 24/7. To część ścieżki edukacyjnej C++ Academy, a Twój postęp synchronizuje się między webem a aplikacją CoddyKit. Kurs C++ Academy zawiera 4 lekcji w sumie.
Unia bezpieczna typowo
std::variant przechowuje dokładnie jedną wartość spośród ustalonej listy typów i pamięta, który z nich jest aktywny. Aby go używać, należy dołączyć <variant>.
#include <iostream>
#include <variant>
int main() {
std::variant<int, double> v = 10;
std::cout << std::get<int>(v) << "\n";
}Przypisywanie różnych typów
Można ponownie przypisać wariantowi wartość dowolnego z jego typów alternatywnych. Automatycznie aktualizuje on informację o tym, która alternatywa jest aktywna.
#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";
}Sprawdzanie aktywnego typu
std::holds_alternative<T>(v) informuje, czy wariant przechowuje obecnie typ 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";
}Funkcja index()
v.index() zwraca numer pozycji aktywnego typu na liście typów, licząc od zera.
#include <iostream>
#include <variant>
int main() {
std::variant<int, double, char> v = (char)65;
std::cout << v.index() << "\n"; // 2
}Bezpieczny dostęp za pomocą std::get
std::get<T> zwraca wartość, jeśli aktywny jest typ T; w przeciwnym razie zgłasza wyjątek std::bad_variant_access. Nie pojawiają się żadne ciche, bezwartościowe dane.
#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";
}
}Niezgłaszający wyjątków get_if
std::get_if<T>(&v) zwraca wskaźnik do wartości albo nullptr, jeśli typ T nie jest aktywny. To świetne rozwiązanie do sprawdzania bez rozgałęzień.
#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";
}Konstrukcja domyślna
Wariant utworzony domyślnie przechowuje zainicjalizowaną wartość swojego pierwszego typu. Należy uporządkować typy tak, aby pierwszy z nich był sensowną wartością domyślną.
#include <iostream>
#include <variant>
int main() {
std::variant<int, double> v; // holds int 0
std::cout << std::get<int>(v) << "\n";
}Przechowywanie napisów
W przeciwieństwie do surowych unii wariant może bezpiecznie przechowywać typy nietrywialne, takie jak std::string; zarządzanie czasem ich życia odbywa się automatycznie.
#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";
}Wariant jako typ zwracany
Funkcja może zwracać jedną z kilku typów, zwracając wariant. Następnie kod wywołujący sprawdza go, aby ustalić, który typ został zwrócony.
#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 do zmiany w miejscu
v.emplace<T>(args...) konstruuje nową wartość typu T bezpośrednio wewnątrz wariantu, przełączając aktywną alternatywę.
#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";
}Dlaczego warto wybrać wariant
std::variant zapewnia efektywność pamięci unii wraz z pełnym bezpieczeństwem typów: śledzi aktywny typ, zarządza czasem życia obiektów i odrzuca dostęp do niewłaściwego typu. W następnej lekcji poznasz najczystszy sposób przetwarzania wariantu.
Szybkie sprawdzenie
Sprawdź swoją wiedzę na temat std::variant.
Podsumowanie
Poznałeś/Poznałaś std::variant:
- Przechowuje jeden z kilku typów i śledzi, który z nich jest aktywny.
holds_alternative/index()umożliwiają sprawdzanie aktywnego typu.std::getzgłasza wyjątek przy niezgodności;get_ifzwraca wskaźnik albo wartość null.- Bezpiecznie przechowuje typy nietrywialne, takie jak
std::string.
Często zadawane pytania
Czy lekcja „std::variant” jest bezpłatna?
Tak — pełny tekst „std::variant” jest dostępny za darmo tutaj w sieci. Aby ćwiczyć ją interaktywnie (wbudowany edytor kodu i tutor AI dostępny 24/7) i odblokować resztę kursu C++ Academy, przejdź na CoddyKit PRO. Kurs C++ Academy zawiera 4 lekcji w sumie.
Co nauczysz się w „std::variant”?
Bezpieczna typowo unia Ćwiczysz C++ Academy z praktycznym kodem, który uruchamiasz bezpośrednio w przeglądarce, a tutor AI dostępny 24/7 odpowiada na Twoje pytania podczas pracy nad lekcją.
Czy potrzebuję doświadczenia, aby zacząć C++ Academy?
Nie wymagamy żadnego doświadczenia. C++ Academy w CoddyKit jest strukturyzowany dla początkujących i zaawansowanych użytkowników, więc możesz zacząć tutaj lub od początku i uczyć się w swoim tempie. To lekcja 3 z 4.
Ile czasu zajmuje lekcja „std::variant”?
Większość lekcji CoddyKit trwa około 5–10 minut. Każda lekcja to mały, interaktywny krok, dzięki czemu robisz systematyczne postępy i zawsze wracasz dokładnie do tego samego miejsca — na webie i w aplikacji.
Czy mogę pisać i uruchamiać kod w tej lekcji C++ Academy?
Tak. Każda lekcja C++ Academy zawiera wbudowany edytor kodu, więc piszesz i uruchamiasz prawdziwy kod bezpośrednio w przeglądarce i od razu otrzymujesz sprzężenie zwrotne od AI — bez konfiguracji na komputerze.