Écrire des traits personnalisés
Créer vos propres traits de types
Écrire des traits personnalisés est une leçon C++ Academy gratuite sur CoddyKit. Ceci est la leçon 4 sur 4. Tu peux lire la leçon complète ci-dessous gratuitement — puis la pratiquer en direct dans le navigateur avec un éditeur de code intégré et un tuteur IA 24/7. Elle fait partie du parcours d'apprentissage C++ Academy, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours C++ Academy comprend 4 leçons au total.
Créer vos propres traits
Lorsque la bibliothèque standard ne propose pas la question dont vous avez besoin, vous pouvez écrire un trait personnalisé. Un trait est simplement un modèle qui expose ::value ou ::type.
Modèle primaire et spécialisation
Le modèle standard consiste à définir un modèle primaire qui vaut par défaut false, puis une spécialisation qui correspond au type recherché et définit 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;
}Hériter de integral_constant
En héritant de std::true_type ou de std::false_type, votre trait obtient automatiquement un membre value et se comporte comme les traits standard.
Détecteur de conteneur
Détectez si un type ressemble à un conteneur en recherchant des membres imbriqués. Ici, nous spécialisons le trait lorsque l’alias de type value_type est présent, au moyen d’un utilitaire.
#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;
}Explication de std::void_t
std::void_t<...> transforme toute liste de types valide en void. Si un type de la liste est mal formé, la spécialisation est écartée via SFINAE, et le false_type du modèle primaire est donc retenu.
Détecter une fonction membre
Vous pouvez détecter si un type possède une fonction size() appelable en testant l’expression dans un 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>() produit une fausse valeur de type T dans des contextes non évalués, ce qui vous permet d’écrire des expressions decltype sans construire d’objet.
Un trait de transformation
Les traits personnalisés peuvent également produire des types. Celui-ci supprime un niveau d’indirection par pointeur.
#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;
}Fournir les utilitaires _v et _t
Reprenez le style de la bibliothèque standard en ajoutant des modèles de variables et des modèles d’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 de détection
La technique void_t se généralise en idiom de détection, que le std::is_detected expérimental formalise. Les concepts de C++20 rendent une grande partie de cette approche plus claire.
Tester vos traits
Vérifiez vos traits personnalisés avec static_assert afin que toute régression interrompe immédiatement la compilation.
#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; }Vérification rapide
Rappelez-vous le rôle de std::void_t.
Récapitulatif
Vous avez appris à écrire des traits personnalisés.
- Le modèle primaire vaut false par défaut ; la spécialisation définit true
- Héritez de
true_type/false_type void_tetdeclvalpermettent l’idiom de détection- Ajoutez les utilitaires
_v/_tet testez avecstatic_assert
Apprends C++ avec un tuteur IA — gratuit
Écris et exécute du vrai code dans ton navigateur, obtiens de l'aide instantanée d'un tuteur IA disponible 24h/24, et reprends là où tu t'es arrêté sur le web ou dans l'app.
- Cours
- 51
- Leçons
- 203
Questions Fréquemment Posées
La leçon « Écrire des traits personnalisés » est-elle gratuite ?
Oui — le texte complet de « Écrire des traits personnalisés » est gratuit à lire ici sur le web. Pour la pratiquer de manière interactive (un éditeur de code intégré et un tuteur IA 24/7) et déverrouiller le reste du cours C++ Academy, passe à CoddyKit PRO. Le cours C++ Academy comprend 4 leçons au total.
Qu'est-ce que j'apprendrai dans « Écrire des traits personnalisés » ?
Créer vos propres traits de types Tu pratiques C++ Academy avec du code pratique que tu exécutes directement dans le navigateur, et un tuteur IA 24/7 répond à tes questions au fur et à mesure que tu avances dans la leçon.
Dois-je avoir de l'expérience pour commencer C++ Academy ?
Aucune expérience préalable n'est requise. C++ Academy sur CoddyKit est structuré pour les débutants jusqu'aux apprenants avancés, donc tu peux commencer ici ou depuis le début et avancer à ton rythme. Ceci est la leçon 4 sur 4.
Combien de temps prend la leçon « Écrire des traits personnalisés » ?
La plupart des leçons CoddyKit prennent environ 5–10 minutes. Chacune est courte et interactive, tu progresses régulièrement et tu repiques exactement où tu t'es arrêté sur le web et l'app.
Peux-tu écrire et exécuter du code dans cette leçon C++ Academy ?
Oui. Chaque leçon C++ Academy inclut un éditeur de code intégré, tu écris et exécutes du vrai code directement dans ton navigateur et tu reçois des retours IA instantanés — aucune configuration locale requise.
Toutes les leçons de ce cours
- Interroger les types
- Transformer les types
- Logique conditionnelle
- Écrire des traits personnalisés