C++ Academy · Leçon

Transformer les types

remove_const, decay et autres outils

Transformer les types est une leçon C++ Academy gratuite sur CoddyKit. Ceci est la leçon 2 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.

Transformations de types

En plus de les interroger, <type_traits> peut produire de nouveaux types à partir de types existants. Ces caractéristiques exposent un type membre ::type, avec un raccourci _t depuis C++14.

remove_const

std::remove_const_t<const int> produit int. C’est utile lorsque vous avez besoin d’une version modifiable d’un type.

#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&> donne int. Cette opération est essentielle au transfert parfait et à l’écriture de code générique.

#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 et add_const

Les transformations ajoutent également des qualificatifs.

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> reproduit les conversions qui se produisent lors d’un passage par valeur : il supprime les références et les qualificatifs cv, et convertit les tableaux et les fonctions en pointeurs.

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

Décroissance des tableaux

decay transforme un type tableau en pointeur, exactement comme lorsqu’un tableau est transmis à une fonction.

#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> supprime à la fois const et volatile, pour obtenir un int ordinaire.

#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> donne le type vers lequel les deux types peuvent être convertis, comme le type du résultat de 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

Pour les énumérations, std::underlying_type_t<E> révèle le type entier qui sert de support à l’énumération.

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

Enchaîner les transformations

Les transformations se composent. Pour normaliser un type transféré, vous les combinez souvent, par exemple remove_cv_t<remove_reference_t<T>>, qui constitue essentiellement le début de decay.

Pourquoi les transformations sont importantes

Les fonctions génériques reçoivent fréquemment const T& ou T&&, mais ont besoin du type nu pour déclarer des variables locales ou des valeurs de retour. Les caractéristiques de transformation vous fournissent ce type propre.

Vérification rapide

Rappelez-vous ce que fait decay.

Récapitulatif

Vous avez appris les transformations de types.

Les caractéristiques exposent ::type avec un raccourci _t
remove_const, remove_reference, remove_cv
add_pointer, add_const, decay
common_type, underlying_type pour obtenir des résultats dérivés

Questions Fréquemment Posées

La leçon « Transformer les types » est-elle gratuite ?

Oui — le texte complet de « Transformer les types » 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 « Transformer les types » ?

remove_const, decay et autres outils 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 2 sur 4.

Combien de temps prend la leçon « Transformer les types » ?

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

← Retour à C++ Academy