Menu

Conversioni di tipo in C ++

type conversions c

Prova Il Nostro Strumento Per Eliminare I Problemi

Dai un'occhiata alle varie conversioni di tipo supportate in C ++.

Ci auguriamo che tu sia a conoscenza di tutti i tipi di dati disponibili in C ++ dai nostri tutorial precedenti. A volte, può sorgere una necessità tale da dover convertire un tipo in un altro. Questa operazione è chiamata conversione del tipo o casting del tipo.

In questo tutorial, discuteremo le varie conversioni di tipo supportate in C ++.

come aprire i file apk su Windows

=> Fare clic qui per il corso C ++ gratuito.

Conversioni di tipo in C ++

Cosa imparerai:

Conversioni di tipo

C ++ supporta due tipi di conversioni di tipo:

  • Conversione di tipo implicita: La conversione implicita del tipo è automatica. Non ci sono interferenze da parte dell'utente in questo tipo di conversione e il compilatore esegue direttamente la conversione. La conversione viene solitamente eseguita quando nell'espressione è presente più di un tipo di dati. Ma generalmente, in questo tipo di conversione, c'è la possibilità di perdita di dati, perdita di segni o overflow di dati.
  • Conversione di tipo esplicita: La conversione esplicita del tipo è definita dall'utente ed è normalmente chiamata 'casting del tipo'. Qui l'utente esegue il cast o converte un valore di un tipo di dati in un altro a seconda dei requisiti. Questo tipo di conversioni è più sicuro.

Ora vedremo in dettaglio entrambi i tipi di conversione del tipo.

Conversione implicita

Nella conversione implicita, il compilatore esegue le conversioni da un tipo di dati a un altro ogni volta che un'espressione ha più di un tipo di dati. Per evitare la perdita di dati, tutte le variabili degli altri tipi di dati vengono convertite nel tipo di dati più grande. Questa si chiama promozione.

Cerchiamo di capire la conversione implicita utilizzando un esempio di codice.

#include using namespace std; int main() { int num = 10; char ch = 'A'; cout<<'10 + 'A' = '<

float val (10 + 'a') = 107

var_int = 1000

L'esempio di codice precedente mostra la conversione implicita. Abbiamo dichiarato un numero intero e una variabile carattere rispettivamente con i valori 10 e 'A'. Quando sommiamo queste due variabili, avviene una conversione implicita.

Poiché intero è il tipo più grande in questa espressione, il valore della variabile di carattere 'A' viene convertito nel suo equivalente intero, ovvero il valore 65 (valore ASCII). Quindi il risultato dell'espressione è 75.

Nella successiva espressione, aggiungiamo numero intero e carattere ('a' -> 97) e quindi assegniamo il risultato a float. Pertanto il risultato dell'espressione viene convertito implicitamente in float dal compilatore.

Nella terza espressione, una breve variabile int viene convertita implicitamente in intero.

Nota : In caso di conversioni implicite, se il compilatore rileva una potenziale perdita di dati, potrebbe lampeggiare un avviso in tal senso.

Conversione esplicita

La conversione esplicita è anche nota come 'trasmissione del tipo' poiché 'trasmettiamo' un tipo di dati a un altro tipo di dati. Qui, gli utenti definiscono esplicitamente il casting, a differenza della conversione implicita in cui il compilatore esegue internamente la conversione.

Possiamo eseguire la conversione esplicita in due modi:

# 1) Utilizzo dell'operatore di assegnazione

La conversione esplicita o il typecasting utilizzando l'operatore di assegnazione in un modo viene eseguito con forza. Qui eseguiamo il cast o convertiamo un tipo di dati in un altro tipo di dati utilizzando l'operatore di assegnazione.

La sintassi generale è:

(data type) expression;

L'esempio seguente spiega questo:

#include #include using namespace std; int main() { int sum; double salary = 4563.75; sum = (int)salary + 1000; cout<<'Sum = '<
miglior software di riparazione pc per windows 10

Come mostrato nell'output, il tipo a cui eseguiamo il cast indica il tipo finale del risultato dell'espressione.

Ciò è vantaggioso in quanto l'utente può modificare il tipo di espressione secondo i requisiti.

# 2) Utilizzo dell'operatore Cast

In questo tipo di casting, utilizziamo un 'cast operator' che è un operatore unario per passare da un tipo a un altro.

Tipi di casting

Abbiamo i seguenti tipi di casting a seconda dell'operatore di cast che utilizziamo:

# 1) Cast statico

Il cast statico è il più semplice tra tutti i typecast utilizzando l'operatore cast . Il cast statico è in grado di eseguire tutte le conversioni che vengono eseguite implicitamente. Esegue anche conversioni tra puntatori di classi correlate tra loro (upcast -> da derivato a base o downcast -> da base a derivato).

Oltre alle conversioni sopra elencate, il cast statico è anche in grado di convertire qualsiasi puntatore in void *.

Il cast statico è il cast del tempo compilato. Ciò significa che non viene effettuato alcun controllo in fase di esecuzione per vedere se il cast eseguito è valido o meno. Rimane quindi responsabilità del programmatore assicurarsi che la conversione fosse sicura e valida.

In altre parole, l'utente deve assicurarsi che l'oggetto convertito fosse pieno rispetto al tipo di dati di destinazione.

Specifichiamo un cast statico come segue:

static_cast (expression)

Cerchiamo di capire il cast statico usando un esempio.

#include using namespace std; int main() { double df = 3.5 * 3.5 * 3.5; cout<<'Before casting: df = '<

Ora modifichiamo il codice sopra come segue:

#include using namespace std; int main() { double df = 3.5 * 3.5 * 3.5; cout<<'Before casting :df = '<

Nell'esempio precedente, abbiamo leggermente modificato il codice per includere una variabile carattere con valore 'A'. Quindi dichiariamo un puntatore intero e applichiamo un cast statico per convertire un carattere in un puntatore intero.

Quando compiliamo questo programma otteniamo il seguente output.

Nella funzione 'int main ()':
10:35: errore: static_cast non valido dal tipo 'char *' al tipo 'int *'

Il programma restituisce un errore per il cast statico eseguito in quanto non valido. Pertanto, il cast statico consente solo il casting o le conversioni di tipi validi e restituisce un errore quando si tenta di eseguire un typecasting indesiderato.

# 2) Cast dinamico

Il cast dinamico è un cast di runtime eseguito per verificare la validità del cast. Il cast dinamico viene eseguito solo su puntatori e riferimenti di classe. L'espressione restituisce un valore NULL se il cast non riesce.

Il cast dinamico utilizza un meccanismo noto come RTTI (Runtime Type Identification) . RTTI rende disponibili tutte le informazioni sul tipo di dati dell'oggetto in fase di esecuzione ed è disponibile solo per le classi che hanno almeno una funzione virtuale (tipo polimorfico). RTTI consente di determinare il tipo di oggetto in fase di esecuzione o al momento dell'esecuzione.

Proviamo un esempio per comprendere il cast dinamico.

#include #include using namespace std; class base {public: virtual void print(){}}; class derived:public base{}; int main() { base* b = new derived; derived* d = dynamic_cast(b); if(d != NULL) cout<<'Dynamic_cast done successfully'; else cout<<'Dynamic_cast not successful'; }

In questo programma abbiamo definito due classi, base con una funzione virtuale e derivata avente una classe base, base.

Nella funzione principale, creiamo un oggetto di classe derivato puntato dal puntatore della classe base. Quindi eseguiamo dynamic_cast sul puntatore di base che punta a una classe derivata per eseguirne il cast a un puntatore di classe derivata.

Come nella classe base, la base è polimorfica (contiene la funzione virtuale), il dynamic_cast ha successo.

Nota: Se rimuoviamo la funzione virtuale dalla classe precedente, dynamic_cast fallirà poiché le informazioni RTTI per gli oggetti non saranno disponibili.

Il cast dinamico ha un sovraccarico di indipendenza dai tipi in fase di esecuzione.

# 3) Reinterpreta il cast

Questo tipo di cast è molto pericoloso da usare in quanto funziona su qualsiasi tipo di oggetto senza che le classi siano correlate tra loro.

Reintepret_cast funziona su qualsiasi puntatore e converte un puntatore di qualsiasi tipo in qualsiasi altro tipo indipendentemente dal fatto che i puntatori siano correlati o meno. Non controlla se il puntatore oi dati puntati dal puntatore sono uguali o meno.

quali sono le migliori app vr per Android

L'operatore cast accetta un solo parametro, il puntatore sorgente in cui convertire e non restituisce alcun valore. Converte semplicemente il tipo di puntatore.

Non dovremmo usare se non richiesto. Di solito facciamo il typecast il puntatore della sorgente al suo tipo originale.

Usiamo principalmente per lavorare con i bit. Quando viene utilizzato su valori booleani, i valori booleani vengono convertiti in valori interi, ad esempio 1 per vero e 0 per falso.

Vediamo un esempio di reinterpretazione del cast:

#include using namespace std; int main() { int* ptr = new int(97); char* ch = reinterpret_cast(ptr); cout << ptr << endl; cout << ch << endl; cout << *ptr << endl; cout << *ch << endl; return 0; }

Produzione:

0x3ef3090
per
97
per

Nell'esempio precedente, abbiamo dichiarato un puntatore intero ptr che punta al valore 97. Successivamente, dichiariamo un puntatore a carattere ch e vi castiamo ptr usando.

Successivamente, stampiamo vari valori. Il primo che stampiamo è ptr che punta a una posizione intera. Quindi stampa un indirizzo.

Il valore successivo ch contiene il valore 97 e quindi stampa 'a' che è equivalente ASCII di 97. Il valore successivo '* ptr' contiene il valore 97 mentre '* ch' contiene l'equivalente ASCII di 97 cioè 'a' mentre viene lanciato usando il reinterpret_cast.

# 4) Const Cast

L'operatore cast viene utilizzato per modificare o manipolare la costanza del puntatore di origine. Per manipolazione, intendiamo che può essere impostare constness su un puntatore non const o rimuovere constness da un puntatore const.

La condizione per eseguire correttamente il cast dell'operatore è che il puntatore e la sorgente di cui viene eseguito il cast devono essere dello stesso tipo.

Facciamo un esempio per capirlo.

#include using namespace std; int printVal(int* ptr) { return(*ptr*10); } int main(void) { const int value = 10; const int *ptr = &value; int *ptr_cast = const_cast (ptr); cout <<'printVal returned = '<< printVal(ptr_cast); return 0; }

In questo esempio, vediamo che la funzione 'printVal' accetta un puntatore non const. Nella funzione principale, abbiamo una variabile const 'valore' assegnata al puntatore const ptr.

Per passare questo puntatore const alla funzione printVal, lo eseguiamo applicandolo per rimuovere constness. Quindi passiamo il puntatore ptr_cast alla funzione per ottenere i risultati desiderati.

Conclusione

Con questo, concluderemo questo argomento della conversione del tipo in C ++. Abbiamo visto tutto sulle conversioni implicite ed esplicite utilizzate in C ++.

Tuttavia, si dovrebbe essere consapevoli che per prevenire la perdita di dati e altre difficoltà simili, le conversioni o il typecasting dovrebbero essere applicati saggiamente solo se la situazione ne richiede l'uso.

=> Guarda qui la guida di formazione per principianti C ++.

Lettura consigliata

^