C++ Academy · Lezione

Trasformare i tipi

remove_const, decay e altro

Trasformare i tipi è una lezione C++ Academy gratuita su CoddyKit. Questa è la lezione 2 di 4. Puoi leggere la lezione completa qui gratuitamente — poi esercitati direttamente nel browser con un editor di codice integrato e un tutor IA disponibile 24/7. Fa parte del percorso di apprendimento C++ Academy, e i tuoi progressi si sincronizzano tra il web e l'app CoddyKit. Il corso C++ Academy include 4 lezioni in totale.

Trasformazioni dei tipi

Oltre a interrogare i tipi, <type_traits> può produrre nuovi tipi a partire da quelli esistenti. Questi trait espongono un tipo membro ::type, con la scorciatoia _t disponibile da C++14.

remove_const

std::remove_const_t<const int> restituisce int. È utile quando serve una versione modificabile di un tipo.

#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&> restituisce int. È fondamentale per il perfect forwarding e per la scrittura di codice generico.

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

Le trasformazioni possono anche aggiungere qualificatori.

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> simula le conversioni che avvengono quando si passa un argomento per valore: rimuove riferimenti e qualificatori cv e converte array e funzioni in puntatori.

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

Decadimento degli array

decay trasforma un tipo array in un puntatore, esattamente come quando si passa un array a una funzione.

#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> rimuove sia const sia volatile, restituendo il semplice 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> restituisce il tipo in cui entrambi possono essere convertiti, come il risultato di 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

Per gli enum, std::underlying_type_t<E> rivela il tipo intero sottostante all'enum.

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

Concatenare le trasformazioni

Le trasformazioni sono componibili. Per normalizzare un tipo inoltrato spesso le si combina, ad esempio remove_cv_t<remove_reference_t<T>>, che è essenzialmente il punto di partenza di decay.

Perché le trasformazioni sono importanti

Le funzioni generiche ricevono spesso const T& o T&&, ma hanno bisogno del tipo nudo per dichiarare variabili locali o valori restituiti. I trait di trasformazione forniscono proprio questo tipo pulito.

Verifica rapida

Ricordi cosa fa decay.

Riepilogo

Ha imparato le trasformazioni dei tipi.

I trait espongono ::type con la scorciatoia _t
remove_const, remove_reference, remove_cv
add_pointer, add_const, decay
common_type, underlying_type per ottenere tipi derivati

Domande Frequenti

La lezione «Trasformare i tipi» è gratuita?

Sì — il testo completo di «Trasformare i tipi» è gratuito qui sul web. Per esercitarvi in modo interattivo (un editor di codice integrato e un tutor IA 24/7) e sbloccare il resto del corso C++ Academy, passa a CoddyKit PRO. Il corso C++ Academy include 4 lezioni in totale.

Cosa imparerò in «Trasformare i tipi»?

remove_const, decay e altro Eserciti C++ Academy con codice pratico che esegui direttamente nel browser, e un tutor IA 24/7 risponde alle tue domande mentre lavori sulla lezione.

Ho bisogno di esperienza per iniziare C++ Academy?

Non è richiesta alcuna esperienza precedente. C++ Academy su CoddyKit è strutturato per principianti e studenti avanzati, quindi puoi iniziare da qui o dall'inizio e procedere al tuo ritmo. Questa è la lezione 2 di 4.

Quanto tempo richiede la lezione «Trasformare i tipi»?

La maggior parte delle lezioni CoddyKit richiede circa 5–10 minuti. Ogni lezione è breve e interattiva, quindi fai progressi costanti e riprendi esattamente da dove hai lasciato su web e app.

Posso scrivere ed eseguire codice in questa lezione C++ Academy?

Sì. Ogni lezione C++ Academy include un editor di codice integrato, quindi scrivi ed esegui codice reale direttamente nel tuo browser e ricevi feedback istantaneo dall'IA — nessuna configurazione locale necessaria.

Tutte le lezioni di questo corso

← Torna a C++ Academy