Meniu

Tastați conversiile în C ++

type conversions c

Încercați Instrumentul Nostru Pentru Eliminarea Problemelor

Verificați diferitele tipuri de conversii acceptate în C ++.

Sperăm că ar trebui să fiți la curent cu toate tipurile de date disponibile în C ++ din tutorialele noastre anterioare. Uneori, poate apărea o nevoie, astfel încât să avem nevoie să convertim un tip la altul. Aceasta se numește conversie de tip sau turnare de tip.

În acest tutorial, vom discuta diferitele conversii de tip acceptate în C ++.

ce instrument puteți utiliza pentru a reprezenta și analiza vizual o bază de date?

=> Faceți clic aici pentru cursul gratuit C ++.

Tastați conversii în C ++

Ce veți învăța:

Tastați conversii

C ++ acceptă două tipuri de conversii de tip:

  • Conversie tip implicită: Conversia implicită a tipului este automată. Nu există interferențe din partea utilizatorului în acest tip de conversie, iar compilatorul efectuează direct conversia. Conversia se face de obicei atunci când în expresie există mai multe tipuri de date. Dar, în general, în acest tip de conversie, există posibilitatea pierderii de date, pierderii semnelor sau depășirii datelor.
  • Conversie de tip explicit: Conversia explicită de tip este definită de utilizator și se numește în mod normal „tip-turnare”. Aici utilizatorul aruncă sau convertește o valoare de un tip de date la altul, în funcție de cerințe. Acest tip de conversii sunt mai sigure.

Acum vom vedea în detaliu ambele tipuri de conversie de tip.

Conversie implicită

În conversia implicită, compilatorul efectuează conversiile de la un tip de date la altul ori de câte ori o expresie are mai multe tipuri de date. Pentru a preveni pierderea datelor, toate variabilele celorlalte tipuri de date sunt convertite în cel mai mare tip de date. Aceasta se numește promovare.

Să înțelegem conversia implicită folosind un exemplu de cod.

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

Conversia explicită este, de asemenea, cunoscută sub numele de „tip-casting”, întrucât „proiectăm” un tip de date la alt tip de date. Aici, utilizatorii definesc în mod explicit distribuția, spre deosebire de conversia implicită în care compilatorul efectuează conversia intern.

Putem efectua conversii explicite în două moduri:

# 1) Utilizarea Operatorului de atribuire

Conversia explicită sau tipografia folosind operatorul de atribuire într-un mod se efectuează cu forță. Aici proiectăm sau convertim un tip de date în alt tip de date folosind operatorul de atribuire.

Sintaxa generală este:

(data type) expression;

Următorul exemplu explică acest lucru:

#include #include using namespace std; int main() { int sum; double salary = 4563.75; sum = (int)salary + 1000; cout<<'Sum = '<# 2) Utilizarea Cast Operator

În acest tip de turnare, folosim un „operator de turnare” care este un operator unar pentru a trece de la un tip la altul.

Tipuri de casting

În funcție de operatorul de turnare pe care îl folosim, avem următoarele tipuri de turnare:

diferența dintre c c ++ și java

# 1) Distribuție statică

Distribuția statică este cea mai simplă dintre toate tipografiile folosind operatorul de distribuție . Distribuția statică este capabilă să efectueze toate conversiile care sunt efectuate implicit. De asemenea, efectuează conversii între pointeri de clase legate între ele (upcast -> de la derivat la bază sau downcast -> de la bază la derivat).

În afară de conversiile enumerate mai sus, distribuția statică poate converti orice pointer în gol *.

Distribuția statică este distribuirea timpului compilat. Aceasta înseamnă că nu se efectuează nicio verificare în timpul rulării pentru a vedea dacă distribuția efectuată este validă sau nu. Astfel, rămâne responsabilitatea programatorului să se asigure că conversia a fost sigură și validă.

Cu alte cuvinte, utilizatorul trebuie să se asigure că obiectul convertit a fost plin în raport cu tipul de date de destinație.

Specificăm o distribuție statică după cum urmează:

static_cast (expression)

Să înțelegem distribuția statică folosind un exemplu.

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

În exemplul de mai sus, am modificat ușor codul pentru a include o variabilă de caractere cu valoarea „A”. Apoi declarăm un indicator întreg și aplicăm o distribuție statică pentru a converti un caracter într-un indicator întreg.

Când compilăm acest program, obținem următoarea ieșire.

În funcția ‘int main ()’:
10:35: eroare: static_cast nevalid de la tipul „char *” la tipul „int *”

Programul dă o eroare pentru distribuția statică efectuată, deoarece este nevalidă. Astfel, distribuția statică permite numai distribuirea sau conversiile de tip valide și dă o eroare atunci când încercăm să efectuăm unele tipografii nedorite.

# 2) Distribuție dinamică

Distribuția dinamică este o distribuție executată pentru a verifica validitatea distribuției. Distribuția dinamică se efectuează numai pe indicatori și referințe de clasă. Expresia returnează o valoare NULL dacă distribuția eșuează.

Distribuția dinamică folosește un mecanism cunoscut sub numele de RTTI (identificare tip runtime) . RTTI face disponibile toate informațiile despre tipul de date al obiectului în timpul rulării și este disponibilă numai pentru clasele care au cel puțin o funcție virtuală (tip polimorf). RTTI permite determinarea tipului de obiect în timpul rulării sau în momentul execuției.

Să încercăm un exemplu pentru a înțelege distribuția dinamică.

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

În acest program, am definit două clase, bază cu o funcție virtuală și derivate având o clasă de bază, bază.

În funcția principală, creăm un obiect de clasă derivat arătat de indicatorul clasei de bază. Apoi executăm dynamic_cast pe pointerul de bază care indică o clasă derivată pentru a o arunca într-un pointer de clasă derivată.

La fel ca în clasa de bază, baza este polimorfă (conține funcție virtuală), dynamic_cast are succes.

Notă: Dacă eliminăm funcția virtuală din clasa de mai sus, atunci dynamic_cast va eșua, deoarece informațiile RTTI pentru obiecte nu vor fi disponibile.

Distribuția dinamică are o siguranță generală a tipului de siguranță la rulare.

# 3) Reinterpretează distribuția

Acest tip de distribuție este cel mai periculos de utilizat, deoarece funcționează pe orice tip de obiect fără ca clasele să fie legate între ele.

Reintepret_cast funcționează pe orice pointer și convertește un pointer de orice tip în orice alt tip, indiferent dacă pointerele sunt sau nu legate între ele. Nu verifică dacă indicatorul sau datele arătate de acesta sunt sau nu aceleași.

Operatorul de distribuție ia un singur parametru, indicatorul sursă pentru a converti în și nu returnează nicio valoare. Pur și simplu convertește tipul indicatorului.

Nu ar trebui să folosim decât dacă este necesar. De obicei, tipografim indicatorul sursă la tipul său original.

cel mai bun registru de curățare pentru Windows 7 pe 64 de biți

Folosim mai ales pentru a lucra cu biți. Când este utilizat pentru valorile booleene, valorile booleene sunt convertite în valori întregi, adică 1 pentru adevărat și 0 pentru fals.

Să vedem un exemplu de distribuție Reinterpret:

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

Ieșire:

0x3ef3090
la
97
la

În exemplul de mai sus, am declarat un indicator întreg ptr care indică valoarea 97. Apoi, declarăm un indicator de caractere ch și îi aruncăm ptr folosind.

Apoi, imprimăm diferite valori. Primul pe care îl imprimăm este ptr care indică o locație întreagă. Prin urmare, imprimă o adresă.

Următoarea valoare ch conține valoarea 97 și astfel imprimă „a” care este echivalentul ASCII al lui 97. Următoarea valoare „* ptr” deține valoarea 97 în timp ce „* ch” deține echivalentul ASCII al lui 97 adică „a” așa cum a aruncat folosind reinterpret_cast.

# 4) Const Cast

Operatorul de distribuție este utilizat pentru a modifica sau manipula constanța indicatorului sursă. Prin manipulare, înțelegem că poate fi fie setarea constanței la un pointer non-const, fie eliminarea constanței dintr-un pointer const.

Condiția pentru a arunca cu succes operatorul este ca indicatorul și sursa care este aruncată să fie de același tip.

Să luăm un exemplu pentru a înțelege acest lucru.

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

În acest exemplu, vedem că funcția „printVal” acceptă un pointer non-const. În funcția principală, avem o variabilă const „valoare” atribuită indicatorului const ptr.

Pentru a trece acest pointer const la funcția printVal, îl aruncăm aplicând pentru a elimina constanța. Apoi trecem indicatorul ptr_cast la funcție pentru a obține rezultatele dorite.

Concluzie

Cu aceasta, vom încheia acest subiect al conversiei de tip în C ++. Am văzut totul despre conversiile implicite și explicite care sunt utilizate în C ++.

Cu toate acestea, trebuie să fim conștienți de faptul că, pentru a preveni pierderea de date și alte astfel de dificultăți, conversiile sau tipografierea trebuie aplicate cu înțelepciune numai dacă situația necesită utilizarea.

=> Fii atent la Ghidul de instruire pentru începători C ++ aici.

Lectură recomandată

^