C++ Academy · Lekcja

Pisanie własnych traits

Buduj własne cechy typów

Pisanie własnych traits to bezpłatna lekcja C++ Academy na CoddyKit. To lekcja 4 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.

Tworzenie własnych cech typów

Gdy biblioteka standardowa nie udostępnia potrzebnego sprawdzenia, można napisać własną cechę typu. Cecha typu to po prostu szablon udostępniający element ::value lub ::type.

Szablon podstawowy i specjalizacja

Standardowy schemat obejmuje szablon podstawowy z wartością domyślną false oraz specjalizację, która dopasowuje interesujący typ i ustawia wartość true.

#include <iostream>
#include <type_traits>

template <typename T>
struct is_ptr : std::false_type {};

template <typename T>
struct is_ptr<T*> : std::true_type {};

int main() {
    std::cout << is_ptr<int>::value << "\n";
    std::cout << is_ptr<int*>::value << "\n";
    return 0;
}

Dziedziczenie po integral_constant

Dziedzicząc po std::true_type lub std::false_type, cecha typu automatycznie otrzymuje składową value i zachowuje się jak cechy typów ze standardowej biblioteki.

Wykrywanie kontenera

Można sprawdzić, czy typ przypomina kontener, badając obecność zagnieżdżonych składowych. W tym przykładzie specjalizacja zależy od obecności aliasu typu value_type, wykrywanej za pomocą pomocniczego elementu.

#include <iostream>
#include <vector>
#include <type_traits>

template <typename T, typename = void>
struct has_value_type : std::false_type {};

template <typename T>
struct has_value_type<T, std::void_t<typename T::value_type>> : std::true_type {};

int main() {
    std::cout << has_value_type<std::vector<int>>::value << "\n";
    std::cout << has_value_type<int>::value << "\n";
    return 0;
}

Wyjaśnienie std::void_t

std::void_t<...> mapuje dowolną poprawną listę typów na void. Jeśli którykolwiek typ na liście jest niepoprawny, specjalizacja zostaje odrzucona za pomocą SFINAE, więc zastosowanie znajduje podstawowy false_type.

Wykrywanie funkcji składowej

Można wykryć, czy typ ma wywoływalną funkcję size(), sprawdzając wyrażenie w elemencie void_t.

#include <iostream>
#include <string>
#include <type_traits>

template <typename T, typename = void>
struct has_size : std::false_type {};

template <typename T>
struct has_size<T, std::void_t<decltype(std::declval<T>().size())>> : std::true_type {};

int main() {
    std::cout << has_size<std::string>::value << "\n";
    std::cout << has_size<int>::value << "\n";
    return 0;
}

declval

std::declval<T>() tworzy fikcyjną wartość typu T w kontekstach niewartościowanych, dzięki czemu można zapisywać wyrażenia decltype bez tworzenia obiektu.

Cecha transformująca

Własne cechy typów mogą również tworzyć typy. Ta cecha usuwa jedną warstwę wskaźnika.

#include <iostream>
#include <type_traits>

template <typename T>
struct remove_one_pointer { using type = T; };

template <typename T>
struct remove_one_pointer<T*> { using type = T; };

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

Udostępnianie pomocników _v i _t

Aby zachować styl biblioteki standardowej, należy dodać szablony zmiennych i aliasów.

#include <iostream>
#include <type_traits>

template <typename T>
struct is_char : std::false_type {};
template <>
struct is_char<char> : std::true_type {};

template <typename T>
inline constexpr bool is_char_v = is_char<T>::value;

int main() {
    std::cout << is_char_v<char> << "\n";
    std::cout << is_char_v<int> << "\n";
    return 0;
}

Idiom detekcji

Technika void_t uogólnia się do idiomu detekcji, który formalizuje eksperymentalny element std::is_detected. Koncepcje C++20 znacznie upraszczają większość tych zastosowań.

Testowanie własnych cech typów

Należy weryfikować własne cechy typów za pomocą static_assert, aby każda regresja natychmiast przerywała kompilację.

#include <type_traits>

template <typename T>
struct is_void_like : std::false_type {};
template <>
struct is_void_like<void> : std::true_type {};

static_assert(is_void_like<void>::value);
static_assert(!is_void_like<int>::value);

int main() { return 0; }

Szybkie sprawdzenie

Proszę przypomnieć sobie rolę std::void_t.

Podsumowanie

Nauczył(a) się Pan/Pani pisać własne cechy typów.

Szablon podstawowy ma domyślnie wartość false, a specjalizacja ustawia wartość true
Należy dziedziczyć po true_type/false_type
void_t i declval stanowią podstawę idiomu detekcji
Należy dodawać pomocniki _v/_t i testować je za pomocą static_assert

Często zadawane pytania

Czy lekcja „Pisanie własnych traits” jest bezpłatna?

Tak — pełny tekst „Pisanie własnych traits” 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 „Pisanie własnych traits”?

Buduj własne cechy typów Ć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 4 z 4.

Ile czasu zajmuje lekcja „Pisanie własnych traits”?

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