C++ Academy · Pelajaran

Menulis Trait Kustom

Buat trait tipe Anda sendiri

Menulis Trait Kustom 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.

Membangun Trait Anda Sendiri

Jika pustaka standar tidak menyediakan pertanyaan yang Anda perlukan, Anda dapat menulis trait khusus. Trait pada dasarnya adalah templat yang mengekspos ::value atau ::type.

Templat Utama + Spesialisasi

Pola standarnya adalah templat utama dengan nilai bawaan false, ditambah spesialisasi yang cocok dengan tipe yang diinginkan dan menetapkan nilai 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;
}

Mewarisi dari integral_constant

Dengan mewarisi dari std::true_type atau std::false_type, trait Anda secara otomatis memperoleh anggota value dan berperilaku seperti trait standar.

Pendeteksi Kontainer

Deteksi apakah suatu tipe terlihat seperti kontainer dengan memeriksa anggota bersarangnya. Di sini, kita membuat spesialisasi berdasarkan keberadaan alias tipe value_type melalui pembantu.

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

Penjelasan std::void_t

std::void_t<...> memetakan daftar tipe valid apa pun menjadi void. Jika ada tipe di dalamnya yang tidak terbentuk dengan benar, spesialisasi tersebut dibuang melalui SFINAE, sehingga false_type pada templat utama yang digunakan.

Mendeteksi Fungsi Anggota

Anda dapat mendeteksi apakah suatu tipe memiliki size() yang dapat dipanggil dengan menguji ekspresi tersebut di dalam 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>() menghasilkan nilai semu bertipe T dalam konteks yang tidak dievaluasi, sehingga Anda dapat menulis ekspresi decltype tanpa membuat objek.

Trait Transformasi

Trait khusus juga dapat menghasilkan tipe. Trait ini menghapus satu lapisan pointer.

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

Menyediakan Pembantu _v dan _t

Ikuti gaya standar dengan menambahkan templat variabel dan templat alias.

#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 Deteksi

Teknik void_t dapat digeneralisasi menjadi idiom deteksi, yang diformalkan oleh std::is_detected eksperimental. Konsep C++20 membuat sebagian besar proses ini lebih sederhana.

Menguji Trait Anda

Verifikasi trait khusus dengan static_assert agar setiap regresi langsung menggagalkan build.

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

Pemeriksaan Singkat

Ingat kembali peran std::void_t.

Rangkuman

Anda telah mempelajari cara menulis trait khusus.

Templat utama secara bawaan bernilai false; spesialisasi menetapkan nilai true
Mewarisi dari true_type/false_type
void_t + declval menjadi dasar idiom deteksi
Tambahkan pembantu _v/_t dan uji dengan static_assert

Pertanyaan yang Sering Diajukan

Apakah pelajaran “Menulis Trait Kustom” gratis?

Ya — teks lengkap “Menulis Trait Kustom” 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 “Menulis Trait Kustom”?

Buat trait tipe Anda sendiri 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 “Menulis Trait Kustom” 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.

Semua pelajaran dalam kursus ini

← Kembali ke C++ Academy