Tato část se bude zabývat přetypováním proměnných v programovacím jazyce C++. Přetypování typu odkazuje na převod jednoho datového typu na jiný v programu. Přetypování lze provést dvěma způsoby: automaticky kompilátorem a ručně programátorem nebo uživatelem. Type Casting je také známý jako Type Conversion.
Předpokládejme například, že daná data jsou celočíselného typu a chceme je převést na typ float. Potřebujeme tedy ručně přetypovat data int na typ float a tento typ přetypování se v C++ nazývá Type Casting.
int num = 5; float x; x = float(num); x = 5.0
2ndpříklad:
float num = 5.25; int x; x = int(num); Output: 5
Typ Casting se dělí na dva typy: Implicitní konverze nebo Implicitní Typ Casting a Explicitní Typová konverze nebo Explicitní Typ Casting.
Implicitní přetypování nebo implicitní převod typu
java řetězec porovnat
- Je známé jako automatické lití typu.
- Automaticky se převádí z jednoho datového typu na jiný bez jakéhokoli vnějšího zásahu, jako je programátor nebo uživatel. To znamená, že kompilátor automaticky převádí jeden datový typ na jiný.
- Všechny datové typy jsou automaticky upgradovány na největší typ bez ztráty jakýchkoli informací.
- V programu lze použít pouze tehdy, jsou-li obě proměnné vzájemně kompatibilní.
char - sort int -> int -> unsigned int -> long int -> float -> double -> long double, etc.
Poznámka: Přetypování implicitního typu by se mělo provádět z nižších na vyšší datové typy. V opačném případě to ovlivní základní datový typ, který může ztratit přesnost nebo data a kompilátor může blikat varováním v tomto smyslu.
Program pro použití implicitního přetypování v C++
Vytvořme příklad, který demonstruje přetypování jedné proměnné na jinou pomocí implicitního přetypování v C++.
#include using namespace std; int main () { short x = 200; int y; y = x; cout << ' Implicit Type Casting ' << endl; cout << ' The value of x: ' << x << endl; cout << ' The value of y: ' << y << endl; int num = 20; char ch = 'a'; int res = 20 + 'a'; cout << ' Type casting char to int data type ('a' to 20): ' << res << endl; float val = num + 'A'; cout << ' Type casting from int data to float type: ' << val << endl; return 0; } Výstup:
Implicit Type Casting The value of x: 200 The value of y: 200 Type casting char to int data type ('a' to 20): 117 Type casting from int data to float type: 85
Ve výše uvedeném programu jsme deklarovali krátkou proměnnou datového typu x je 200 a celočíselnou proměnnou y. Poté y přiřadíme hodnotu x a kompilátor automaticky převede krátkou datovou hodnotu x na y, která vrátí y je 200.
V dalších výrazech jsme deklarovali proměnnou typu int num je 20 a proměnnou typu znaku ch je 'a', což je ekvivalentní celočíselné hodnotě 97. A pak přidáme tyto dvě proměnné, abychom provedli implicitní převod, což vrátí výsledek výrazu je 117.
Podobně ve třetím výrazu přidáme celočíselnou proměnnou num je 20 a znakovou proměnnou ch je 65 a výsledek pak přiřadíme plovoucí proměnné val. Výsledek výrazu je tedy překladačem automaticky převeden na typ float.
Explicitní typové obsazení nebo Explicitní typová konverze
- To je také známé jako ruční typ odlévání v programu.
- Je ručně přetypován programátorem nebo uživatelem pro změnu z jednoho datového typu na jiný typ v programu. To znamená, že uživatel může snadno přenášet data do jiných podle požadavků v programu.
- Nevyžaduje kontrolu kompatibility proměnných.
- V tomto přetypování můžeme upgradovat nebo downgradovat datový typ jedné proměnné na jinou v programu.
- Ke změně typu proměnné používá operátor cast ().
Syntaxe přetypování explicitního typu
xor v c++
(type) expression;
typ: Představuje uživatelem definovaná data, která převádějí daný výraz.
výraz: Představuje konstantní hodnotu, proměnnou nebo výraz, jehož datový typ je převeden.
Například máme plovoucí číslo 4,534 a pro převod celočíselné hodnoty příkaz jako:
int num; num = (int) 4.534; // cast into int data type cout << num;
Po provedení výše uvedených příkazů bude hodnota s plovoucí desetinnou čárkou přetypována do datového typu typu celé číslo pomocí operátoru cast (). A plovoucí hodnota je přiřazena k celému číslu, které zkrátí desetinnou část a zobrazí pouze 4 jako celočíselnou hodnotu.
Program pro demonstraci použití explicitního přetypování v C++
Vytvořme jednoduchý program pro přetypování jedné proměnné typu do jiného typu pomocí explicitního přetypování v programovacím jazyce C++.
#include using namespace std; int main () { // declaration of the variables int a, b; float res; a = 21; b = 5; cout << ' Implicit Type Casting: ' << endl; cout << ' Result: ' << a / b << endl; // it loses some information cout << '
Explicit Type Casting: ' << endl; // use cast () operator to convert int data to float res = (float) 21 / 5; cout << ' The value of float variable (res): ' << res << endl; return 0; } Výstup:
Implicit Type Casting: Result: 4 Explicit Type Casting: The value of float variable (res): 4.2
Ve výše uvedeném programu vezmeme dvě celočíselné proměnné a a b, jejichž hodnoty jsou 21 a 2. A pak vydělte a b (21/2), což vrátí hodnotu typu 4 int.
Ve druhém výrazu deklarujeme proměnnou typu float res, která ukládá výsledky aab bez ztráty jakýchkoli dat pomocí operátoru cast v metodě cast explicitního typu.
Program pro přetypování double dat do typu int a float pomocí operátoru cast
Podívejme se na příklad, jak získat plochu obdélníku přetypováním double dat do typu float a int v programování v C++.
převést int na dvojitou javu
#include using namespace std; int main () { // declaration of the variables double l, b; int area; // convert double data type to int type cout << ' The length of the rectangle is: ' <> l; cout << ' The breadth of the rectangle is: ' <> b; area = (int) l * b; // cast into int type cout << ' The area of the rectangle is: ' << area << endl; float res; // convert double data type to float type cout << '
The length of the rectangle is: ' << l << endl; cout << ' The breadth of the rectangle is: ' << b << endl; res = (float) l * b; // cast into float type cout << ' The area of the rectangle is: ' << res; return 0; } Výstup:
The length of the rectangle is: 57.3456 The breadth of the rectangle is: 12.9874 The area of the rectangle is: 740 The length of the rectangle is: 57.3456 The breadth of the rectangle is: 12.9874 The area of the rectangle is: 744.77
Některé různé typy typového odlitku
V přetypování typu existuje operátor přetypování, který nutí jeden datový typ převést na jiný datový typ podle potřeb programu. C++ má čtyři různé typy operátorů casting:
- Statické_cast
- dynamic_cast
- const_cast
- reinterpret_cast
Statické obsazení:
static_cast je jednoduché přetypování v době kompilace, které převádí nebo přetypovává jeden datový typ na jiný. To znamená, že za běhu nekontroluje datový typ, zda je provedené přetypování platné nebo ne. Programátor nebo uživatel tedy nese odpovědnost za to, že převod byl bezpečný a platný.
static_cast je dostatečně schopný, aby mohl provádět všechny převody prováděné implicitním přetypováním. A také provádí převody mezi ukazateli tříd navzájem souvisejících (upcast - > z odvozené do základní třídy nebo downcast - > ze základní na odvozenou třídu).
Syntaxe statického obsazení
static_cast (expression);
Program pro demonstraci použití statického obsazení
Vytvořme jednoduchý příklad pro použití statického přetypování typu casting v programování v C++.
binární vyhledávání
#include using namespace std; int main () { // declare a variable double l; l = 2.5 * 3.5 * 4.5; int tot; cout << ' Before using the static cast:' << endl; cout << ' The value of l = ' << l << endl; // use the static_cast to convert the data type tot = static_cast (l); cout << ' After using the static cast: ' << endl; cout << ' The value of tot = ' << tot << endl; return 0; } Výstup:
Before using the static cast: The value of l = 39.375 After using the static cast: The value of tot = 39
Dynamické obsazení
Dynamic_cast je operátor přetypování za běhu, který se používá k převodu jedné proměnné typu na jinou pouze na ukazatelích třídy a odkazech. To znamená, že kontroluje platné přetypování proměnných za běhu, a pokud se přetypování nezdaří, vrátí hodnotu NULL. Dynamické lití je založeno na mechanismu RTTI (Runtime Type Identification).
Program pro demonstraci použití Dynamic Cast v C++
Vytvořme jednoduchý program pro provádění dynamic_cast v programovacím jazyce C++.
#include using namespace std; class parent { public: virtual void print() { } }; class derived: public parent { }; int main () { // create an object ptr parent *ptr = new derived; // use the dynamic cast to convert class data derived* d = dynamic_cast (ptr); // check whether the dynamic cast is performed or not if ( d != NULL) { cout << ' Dynamic casting is done successfully'; } else { cout << ' Dynamic casting is not done successfully'; } } Výstup:
Dynamic casting is done successfully.
Reinterpretovat typ obsazení
Přetypování typu reinterpret_cast se používá k přetypování ukazatele na jakýkoli jiný typ ukazatele, ať už daný ukazatel patří k sobě nebo ne. To znamená, že nekontroluje, zda ukazatel nebo data, na která ukazatel ukazuje, jsou stejná nebo ne. A také vrhá ukazatel na celočíselný typ nebo naopak.
Syntaxe typu reinterpret_cast
reinterpret_cast expression;
Program pro použití Reinterpret Cast v C++
Pojďme napsat program, který demonstruje převod ukazatele pomocí reinterpretu v jazyce C++.
#include using namespace std; int main () { // declaration of the pointer variables int *pt = new int (65); // use reinterpre_cast operator to type cast the pointer variables char *ch = reinterpret_cast (pt); cout << ' The value of pt: ' << pt << endl; cout << ' The value of ch: ' << ch << endl; // get value of the defined variable using pointer cout << ' The value of *ptr: ' << *pt << endl; cout << ' The value of *ch: ' << *ch << endl; return 0; } Výstup:
The value of pt: 0x5cfed0 The value of ch: A The value of *ptr: 65 The value of *ch: A
Const Cast
relační algebra v rdbms
Const_cast se používá ke změně nebo manipulaci s chováním const zdrojového ukazatele. To znamená, že můžeme provést const dvěma způsoby: nastavením ukazatele const na ukazatel bez konst nebo odstraněním nebo odstraněním ukazatele const z ukazatele const.
Syntaxe typu Const Cast
const_cast exp;
Program pro použití Const Cast v C++
Pojďme napsat program pro přetypování zdrojového ukazatele na nepřetypovaný ukazatel pomocí const_cast v C++.
#include using namespace std; // define a function int disp(int *pt) { return (*pt * 10); } int main () { // declare a const variable const int num = 50; const int *pt = # // get the address of num // use const_cast to chnage the constness of the source pointer int *ptr = const_cast (pt); cout << ' The value of ptr cast: ' << disp(ptr); return 0; } Výstup:
The value of ptr cast: 500