C++ Academy · Lekcja

Przekształcanie typów

remove_const, decay i inne

Lekcja 2 z 413 kroki

Przekształcanie typów to bezpłatna lekcja C++ Academy na CoddyKit. To lekcja 2 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.

Transformacje typów

Oprócz odpytywania nagłówek <type_traits> może tworzyć nowe typy na podstawie istniejących. Cechy te udostępniają typ składowy ::type, a w C++14 i nowszych także skrót _t.

remove_const

std::remove_const_t<const int> daje w wyniku int. Jest to przydatne, gdy potrzebują Państwo zmiennej wersji typu.

#include <iostream>
#include <type_traits>

int main() {
    using T = std::remove_const_t<const int>;
    std::cout << std::is_same_v<T, int> << "\n";
    return 0;
}

remove_reference

std::remove_reference_t<int&> daje int. Jest to kluczowe dla doskonałego przekazywania i pisania kodu ogólnego.

#include <iostream>
#include <type_traits>

int main() {
    using T = std::remove_reference_t<int&>;
    std::cout << std::is_same_v<T, int> << "\n";
    return 0;
}

add_pointer i add_const

Transformacje mogą również dodawać kwalifikatory.

add_const_t<int> = const int
add_pointer_t<int> = int*

#include <iostream>
#include <type_traits>

int main() {
    using P = std::add_pointer_t<int>;
    std::cout << std::is_same_v<P, int*> << "\n";
    return 0;
}

std::decay

std::decay_t<T> odwzorowuje konwersje zachodzące podczas przekazywania przez wartość: usuwa referencje i kwalifikatory cv oraz konwertuje tablice i funkcje na wskaźniki.

#include <iostream>
#include <type_traits>

int main() {
    using T = std::decay_t<const int&>;
    std::cout << std::is_same_v<T, int> << "\n";
    return 0;
}

Zanik tablicy

decay zamienia typ tablicowy na wskaźnik, dokładnie tak jak podczas przekazywania tablicy do funkcji.

#include <iostream>
#include <type_traits>

int main() {
    using T = std::decay_t<int[5]>;
    std::cout << std::is_same_v<T, int*> << "\n";
    return 0;
}

remove_cv

std::remove_cv_t<const volatile int> usuwa zarówno const, jak i volatile, dając w wyniku zwykły typ int.

#include <iostream>
#include <type_traits>

int main() {
    using T = std::remove_cv_t<const volatile int>;
    std::cout << std::is_same_v<T, int> << "\n";
    return 0;
}

common_type

std::common_type_t<A,B> daje typ, na który można przekonwertować oba typy, podobnie jak w przypadku wyniku wyrażenia a + b.

#include <iostream>
#include <type_traits>

int main() {
    using T = std::common_type_t<int, double>;
    std::cout << std::is_same_v<T, double> << "\n";
    return 0;
}

underlying_type

W przypadku wyliczeń std::underlying_type_t<E> ujawnia typ całkowity stanowiący podstawę wyliczenia.

#include <iostream>
#include <type_traits>

enum class Color : unsigned char { Red, Green };

int main() {
    using U = std::underlying_type_t<Color>;
    std::cout << std::is_same_v<U, unsigned char> << "\n";
    return 0;
}

Łączenie transformacji

Transformacje można komponować. Aby znormalizować przekazany typ, często łączy się je w sposób taki jak remove_cv_t<remove_reference_t<T>>, co zasadniczo stanowi początek działania decay.

Znaczenie transformacji

Funkcje ogólne często otrzymują const T& lub T&&, ale potrzebują czystego typu do deklarowania zmiennych lokalnych lub wartości zwracanych. Cechy transformacji zapewniają właśnie taki przejrzysty typ.

Szybkie sprawdzenie

Proszę przypomnieć sobie działanie decay.

Odpowiedz w interaktywnej lekcji

Podsumowanie

Nauczyli się Państwo transformować typy.

Cechy udostępniają ::type wraz ze skrótem _t
remove_const, remove_reference, remove_cv
add_pointer, add_const, decay
common_type, underlying_type do uzyskiwania pochodnych wyników

Bezpłatny start

Ucz się C++ dzięki korepetycjom AI — za darmo

Pisz i uruchamiaj kod w przeglądarce, otrzymuj natychmiastową pomoc od korepetytora AI dostępnego 24/7 i kontynuuj naukę w sieci lub w aplikacji.

Kursy: 51
Lekcje: 203

Zacznij naukę bezpłatnie Wyświetl pełny kurs

Często zadawane pytania

Czy lekcja „Przekształcanie typów” jest bezpłatna?

Tak — pełny tekst „Przekształcanie typów” 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 „Przekształcanie typów”?

remove_const, decay i inne Ć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 2 z 4.

Ile czasu zajmuje lekcja „Przekształcanie typów”?

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.

Wszystkie lekcje w tym kursie

← Powrót do C++ Academy