Hoe gegevenstypen in C++ te converteren
In C++ zijn er twee manieren om gegevenstypen te wijzigen:
Impliciete typeconversie
Volgens de vooraf gedefinieerde regels van de C++-codecompiler is impliciete typeconversie de typeconversie die automatisch door de compiler wordt uitgevoerd zonder dat er een externe trigger van de gebruiker nodig is. Dit type conversie vindt meestal plaats in een programma als er meer dan één gegevenstype is en het gegevenstype van de expressie niet overeenkomt met het gegevenstype van de variabele die bij deze expressie betrokken is.
Om gegevensverlies tijdens de conversie te voorkomen, verandert de compiler standaard het gegevenstype met lage nauwkeurigheid door het gegevenstype met hogere precisie. Het zal bijvoorbeeld een geheel getal in een float omzetten in plaats van de float in een geheel getal te veranderen om gegevensverlies te voorkomen. Dit heet promotie. Hieronder volgt het prioriteitsdiagram voor de verschillende gegevenstypen.
Bestelling voor typeconversie
De juiste volgorde voor typeconversie wordt gegeven als:
bool -- > teken -- > korte int -- > int -- > niet-ondertekende int -- > lang -- > niet ondertekend lang -- > lang Lang -- > vlot -- > dubbel -- > lange dubbele
De variabele van het type met lage precisie wordt geconverteerd naar het gegevenstype met hoge precisie om gegevensverlies te voorkomen.
voorbeeld 1
In dit voorbeeld wordt de optelling uitgevoerd op de variabele van verschillende gegevenstypen met behulp van de impliciete typeconversie.
#include
gebruik makend van naamruimte soa ;
int voornaamst ( ) {
int nummer = 100 ;
verkoold karakter = 'C' ;
uit << '100 + 'C' = ' << nummer + karakter << eindl ;
vlot val = nummer + 'C' ;
uit << 'floatwaarde(100 + 'c') = ' << val << eindl ;
int was = 7890 ;
lang was niet = was ;
uit << 'var_int = ' << was niet ;
opbrengst 0 ;
}
Hier worden een geheel getal en een teken uit de ASCII-tabel, en een float-nummer en teken ‘c’ toegevoegd. Het gehele getal wordt in het derde segment bewaard als een lang gegevenstype en de gegevenstypen worden door de compiler zelf gewijzigd op basis van de vooraf gedefinieerde regels.
De som van 100 en ‘C’ retourneert 167, aangezien de ‘C’ gelijk is aan 67 in getallen, en 100+’c’ retourneert 199, aangezien kleine letters ‘c’ gelijk zijn aan 99. De int-variabele wordt opgeslagen in een lang gegevenstype.
Voorbeeld 2
In dit voorbeeld wordt het teken D omgezet in een float om de delingsbewerking uit te voeren.
#includegebruik makend van naamruimte soa ;
int voornaamst ( ) {
verkoold X = 'D' ;
vlot float_var ;
float_var = vlot ( X ) / 'C' ;
// Expliciet een int omzetten in een float.
uit << 'De waarde van float_var is: ' << float_var << eindl ;
opbrengst 0 ;
}
De invoerwaarde heeft de vorm van teken D, dat is opgeslagen in het gegevenstype float en verder wordt gedeeld door teken C. Deze tekens worden veranderd in numerieke waarden en er wordt een delingsbewerking op uitgevoerd, waarbij de waarde in float wordt geretourneerd.
Expliciete typeconversie
De gebruiker moet het gegevenstype handmatig wijzigen met de expliciete typeconversie van C++, ook wel bekend als typecasting. Dit type casting wordt gedaan om de impliciete typeconversie te voorkomen. Er zijn twee methoden om Explicit Type Casting uit te voeren in C++:
- Conversie met behulp van de toewijzingsoperator
- Conversie met behulp van de Cast-operator
Typ conversie met behulp van de toewijzingsoperator in C++
Typeconversie met behulp van de Assignment Operator wordt krachtig uitgevoerd, dat wil zeggen dat het ene gegevenstype handmatig naar het andere wordt geconverteerd. Dit wordt bereikt door de toewijzingsoperator “=” te gebruiken, die de waarde van de rechter operand toewijst aan de variabele aan de linkerkant.
Voorbeeld
Dit programma berekent de oppervlakte van de cirkel met behulp van typecasting.
#include
gebruik makend van naamruimte soa ;
int voornaamst ( )
{
int straal ;
uit <> straal ;
vlot gebied = M_PI * straal * straal ;
uit << 'Oppervlak van cirkel met straal' << straal << ' = ' << gebied ;
}
De toewijzingsoperator wordt gebruikt om de float-waarde aan het gebied toe te wijzen, die bestaat uit de waarde van de straal in het gegevenstype geheel getal.
Het gebied van de cirkel wordt geretourneerd in het float-gegevenstype, terwijl de straal wordt ingevoerd in het integer-gegevenstype. Het gegevenstype van de variabele wordt dus gewijzigd via typecasting met behulp van de toewijzingsoperator.
Typeconversie met behulp van de Cast-operator in C++
Typeconversie wordt uitgevoerd met behulp van een cast-operator, die het ene gegevenstype dwingt om in een ander type te veranderen, afhankelijk van de behoeften van het programma.
Er zijn vier verschillende Cast-operators:
- statische_cast
- const_cast
- dynamische_cast
- herinterpreteer_cast
1: statische_cast
De static_cast is de castingoperator die wordt gebruikt om floats en tekens expliciet om te zetten in gehele getallen, enzovoort. Dit is de meest elementaire cast-operator. Het kan gegevenstypen casten die vergelijkbaar van aard zijn. Het kan verwijzingen van de ene vorm naar de andere omzetten, dus het kan ook worden gebruikt voor geheugenbeheer.
Syntaxis
statische_cast ( uitdrukking ) Voorbeeld
Dit programma is gebouwd om een dubbele variabele naar een int-gegevenstype te converteren met behulp van static_cast. Het zal elk decimaal gedeelte in de uitvoer afsnijden.
gebruik makend van naamruimte soa ;
int voornaamst ( )
{
// declareer een variabele
dubbele P ;
P = 2.905 * 1.235 * 24.675 ;
vlot resultaat ;
uit << ' Voordat u de statische cast gebruikt:' << eindl ;
uit << ' De waarde van p = ' << P << eindl ;
// gebruik de static_cast om het gegevenstype te converteren
resultaat = statische_cast ( P ) ;
uit << ' Na gebruik van de statische cast: ' << eindl ;
uit << ' De waarde van resultaat = ' << resultaat << eindl ;
opbrengst 0 ;
}
In eerste instantie wordt een dubbele variabele p geladen met waarden die met elkaar worden vermenigvuldigd en in het resultaat worden opgeslagen. Het resultaat bevat het resultaat vóór en na de static_cast-operator:
Voordat u de operator static_cast gebruikt, wordt het resultaat weergegeven in decimalen, terwijl het na gebruik van deze operator wordt weergegeven in het gegevenstype geheel getal.
2: const_cast
De operator const_cast wordt gebruikt om een constante waarde van een object naar het niet-constante type te converteren. Het wordt gebruikt wanneer een constant object wordt gedeclareerd en we de waarde ervan af en toe moeten wijzigen.
Syntaxis
const_cast ( uitdrukking ) Voorbeeld
In dit voorbeeld wordt de operator const_cast gebruikt om de constante kwalificatie tijdelijk te verwijderen en maakt het mogelijk om naar behoefte wijzigingen in de variabele aan te brengen:
gebruik makend van naamruimte soa ;
int voornaamst ( ) {
const int X = 70 ;
const int * En = & X ;
uit << 'Oude waarde is' << * En << ' \N ' ;
int * Met = const_cast ( En ) ;
* Met = 90 ;
uit << 'Nieuwe waarde is' << * En ;
opbrengst 0 ;
}
De constante kwalificatie wordt toegewezen aan een int variabele x, wat betekent dat deze variabele niet rechtstreeks kan worden gewijzigd. Daarna wordt int *y, een pointer, gebruikt om toegang te krijgen tot de x, maar deze kan nog steeds niet worden gewijzigd en de oorspronkelijke waarde wordt weergegeven met behulp van cout. Met behulp van de const_cast-operator wordt een pointer z gemaakt die niet-constant is. Deze wordt gebruikt om toegang te krijgen tot de waarde van x, waardoor deze bewerkbaar wordt. Het verandert de waarde die aan z is toegewezen met 90, wat indirect de waarde in x verandert.
Aanvankelijk is de waarde van constante variabele x 70, die wordt gewijzigd door de const_cast-operator te gebruiken, waardoor deze 90 wordt.
3: dynamische_cast
met de hiërarchie van overerving, ook wel type-safe downcast genoemd. Downcasting is het proces waarbij een referentie of pointer wordt geconverteerd naar een afgeleide klasse vanuit een basisklassereferentie of pointer.
Syntaxis
dynamische_cast ( uitdrukking ) Voorbeeld
In dit voorbeeld wordt de operator dynamic_cast gebruikt om het type polymorfe klasse te controleren, en deze biedt toegang tot zowel basis- als afgeleide klasseleden.
#include
gebruik makend van naamruimte soa ;
klas TBase
{
openbaar :
vlot basis_g = 9.81 ;
virtueel leegte dummy ( )
{
} ;
} ;
klas Afgeleid : openbaar TBase
{
openbaar :
int lokaal_g = 9,78 ;
} ;
int voornaamst ( )
{
TBase * baseren = nieuw Afgeleid ;
Afgeleid * afgeleid van ;
afgeleid van = dynamische_cast ( baseren ) ;
uit < basis_g << eindl ;
uit < lokaal_g << eindl ;
haal ( ) ;
opbrengst 0 ;
}
Er worden twee klassen gedefinieerd als basisklassen en afgeleide klassen. Er wordt een pointerbase van het type TBase* gemaakt en toegewezen aan een dynamisch toegewezen object van het type TDerived. In dit geval van polymorfisme kan een afgeleid klasseobject worden toegewezen aan een basisklasse-pointer. De dynamic_cast controleert of de pointer toegang heeft tot het geldige object van TDerived. Als de cast een succesvol resultaat krijgt, krijgt de afgeleide klasse een geldig resultaat, anders retourneert deze een nulwaarde.
4: herinterpreteer_cast
De reinterpret_cast transformeert een pointer van het ene datatype in een pointer van een ander datatype. Er wordt niet gecontroleerd of de gegevenstypen van pointers hetzelfde zijn of niet. Deze gietoperator moet zorgvuldig worden gebruikt en behandeld.
Voorbeeld
In deze illustratie wordt de pointer van het ene gegevenstype opnieuw geïnterpreteerd in een pointer van een ander gegevenstype met behulp van de reinterpret_cast:
gebruik makend van naamruimte soa ;
int voornaamst ( )
{
int * Q = nieuw int ( 70 ) ;
verkoold * ch = herinterpreteer_cast ( Q ) ;
uit << * Q << eindl ;
uit << * ch << eindl ;
uit << Q << eindl ;
uit << ch << eindl ;
opbrengst 0 ;
}
Aanvankelijk wordt een geheel getal toegekend met de waarde 70. De pointer q wijst naar dit dynamisch toegewezen gehele getal. De reinterpret_cast wordt gebruikt om de pointer q opnieuw te interpreteren als een karakterpointer ch, wat betekent dat het geheugen dat oorspronkelijk aan q was toegewezen nu wordt behandeld alsof het een karakter is. Met behulp van het cout-commando wordt de waarde afgedrukt die is toegewezen aan q en ch. Omdat ch wordt behandeld als een tekenaanwijzer, retourneert het een tekenwaarde.
Het drukt de waarde af die naar ch verwijst met behulp van *ch. Omdat ch echter wordt behandeld als een tekenaanwijzer, interpreteert deze regel het geheugen als een teken. Het drukt het geheugenadres af dat is opgeslagen in de pointer ch met behulp van ch. Dit is hetzelfde geheugenadres als q, omdat het slechts een herinterpretatie is van hetzelfde geheugen.
Aanvankelijk slaat het gehele getal 70 op. Later wordt dit gemanipuleerd tussen de pointer q en pointer ch. Uitgangen 2 en 4 zijn hetzelfde omdat de tweede waarde opnieuw wordt geïnterpreteerd met behulp van reinterpret_cast.
Opmerking : Er wordt aangeraden deze cast-operator niet te gebruiken totdat en tenzij dit echt nodig is, omdat het object hierdoor een niet-draagbaar product wordt
Conclusie
Het proces waarbij het gegevenstype van de ene variabele in de andere verandert, staat in C++ bekend als typeconversie of typecasting. Dit wordt gedaan om wiskundige bewerkingen uit te voeren op de variabelen van verschillende gegevenstypen, door hun gegevenstypen met elkaar compatibel te maken. Typeconversie optimaliseert de code. Er zijn impliciete en expliciete typeconversies in C++. Impliciete typeconversie wordt uitgevoerd door de compiler zelf met behulp van een vooraf gedefinieerde set regels, terwijl expliciete typeconversie wordt uitgevoerd door de programmeur met behulp van toewijzingsoperatoren en cast-operatoren.