C++ Academy · Lezione

Interrogare i tipi

Ispezionare i tipi in fase di compilazione

Interrogare i tipi è una lezione C++ Academy gratuita su CoddyKit. Questa è la lezione 1 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.

Che cosa sono i type trait?

L'header <type_traits> consente di porre domande sui tipi in fase di compilazione. Ogni trait è un template che espone una costante ::value o un tipo membro.

is_integral

std::is_integral<T>::value è true per i tipi interi come int e char, e false negli altri casi.

#include <iostream>
#include <type_traits>

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

La scorciatoia _v

C++17 ha aggiunto i variable template _v, così può scrivere std::is_integral_v<T> invece di ::value.

#include <iostream>
#include <type_traits>

int main() {
    std::cout << std::is_integral_v<long> << "\n";
    std::cout << std::is_floating_point_v<float> << "\n";
    return 0;
}

Trait di classificazione

Molti trait classificano i tipi.

is_pointer
is_reference
is_array
is_class
is_enum

#include <iostream>
#include <type_traits>

struct S {};

int main() {
    std::cout << std::is_pointer_v<int*> << "\n";
    std::cout << std::is_class_v<S> << "\n";
    std::cout << std::is_reference_v<int&> << "\n";
    return 0;
}

Trait di relazione

Alcuni trait confrontano due tipi.

is_same<A,B>
is_base_of<Base,Derived>
is_convertible<From,To>

#include <iostream>
#include <type_traits>

struct Base {};
struct Derived : Base {};

int main() {
    std::cout << std::is_same_v<int, int> << "\n";
    std::cout << std::is_base_of_v<Base, Derived> << "\n";
    return 0;
}

Trait delle proprietà

I trait delle proprietà indicano qualificatori e capacità.

is_const
is_signed
is_trivially_copyable
is_default_constructible

#include <iostream>
#include <type_traits>

int main() {
    std::cout << std::is_const_v<const int> << "\n";
    std::cout << std::is_signed_v<unsigned> << "\n";
    return 0;
}

Usare i trait in static_assert

I trait si combinano perfettamente con static_assert per imporre requisiti in fase di compilazione.

#include <type_traits>
#include <iostream>

template <typename T>
T add(T a, T b) {
    static_assert(std::is_arithmetic_v<T>, "T must be a number");
    return a + b;
}

int main() {
    std::cout << add(2, 3) << "\n";
    return 0;
}

Come funzionano i trait

Un trait è semplicemente un template di struct. Il template generico eredita da false_type; una specializzazione per il tipo corrispondente eredita da true_type. Il compilatore seleziona la corrispondenza migliore.

integral_constant

Tutti i trait booleani derivano da std::integral_constant. true_type e false_type sono semplicemente alias di questo tipo con value impostato rispettivamente su true o false.

#include <iostream>
#include <type_traits>

int main() {
    std::cout << std::true_type::value << "\n";
    std::cout << std::false_type::value << "\n";
    return 0;
}

Interrogare i tipi nei template

I trait consentono ai template di scegliere un ramo in base al tipo ricevuto, permettendo al codice generico di adattarsi diversamente a tipi int, float, puntatore o classe.

Solo in fase di compilazione

Le interrogazioni dei trait non hanno alcun costo in fase di esecuzione: vengono valutate durante la compilazione. Il risultato viene incorporato nel codice generato.

Verifica rapida

Ricordi la sintassi pratica introdotta in C++17.

Riepilogo

Ha imparato a interrogare i tipi.

<type_traits> risponde a domande in fase di compilazione
::value o la scorciatoia _v restituisce un bool
Trait di classificazione, relazione e proprietà
Li combini con static_assert per imporre vincoli

Domande Frequenti

La lezione «Interrogare i tipi» è gratuita?

Sì — il testo completo di «Interrogare 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 «Interrogare i tipi»?

Ispezionare i tipi in fase di compilazione 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 1 di 4.

Quanto tempo richiede la lezione «Interrogare 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