Valuoperaattoreita käytetään tyyppivalussa C++:ssa. Niitä käytetään muuntamaan tietotyyppi toiseksi. C++ tukee neljää tyyppiä:

1. static_cast
2. dynaaminen_cast
3. const_cast
4. tulkita uudelleen

1. staattinen_lähetys

The static_cast operaattori on C++:n yleisimmin käytetty valuoperaattori. Se suorittaa käännösajan tyyppimuunnoksen ja sitä käytetään pääasiassa eksplisiittisiin muunnoksiin, jotka kääntäjä pitää turvallisina.

Static_cast syntaksi

  static_cast   <  new_type>(ilmaisu);>>
missä,
 
    ilmaisu:    Muunnettavat tiedot.
    new_type:    Haluttu ilmaisutyyppi
Static_cast-funktiota voidaan käyttää muuntamaan toisiinsa liittyvien tyyppien välillä, kuten numeeristen tyyppien tai osoittimien välillä samassa perintöhierarkiassa.
 
    Esimerkki arvosta static_cast    
C++ 
// C++ program to illustrate the static_cast #include  #include  using namespace std; int main() { int num = 10; // converting int to double double numDouble = static_cast(numero); // tulostetaan datatyyppi cout<< typeid(num).name() << endl; // typecasting cout << typeid(static_cast(luku)).nimi()<< endl; // printing double type t cout << typeid(numDouble).name() << endl; return 0; }>
   
  Lähtö  Tässä esimerkissä olemme sisällyttäneet    tyyppitiedot    kirjasto, jotta voimme käyttää sitä    typeid()    toiminto tarkistaa tietotyypin. Olemme määrittäneet kokonaislukumuuttujan 'num' ja muuntaneet sen tuplamääräksi käyttämällä static_castia. Tämän jälkeen tulostamme muuttujien tietotyypit ja hyväksymme    static_cast(num)    sisään    typeid()    toiminto tarkistaa sen tietotyypin. voimme nähdä tulosteen i, d, d tulostetaan missä    'minä'    tarkoittaa    kokonaisluku    ja    'd'    tarkoittaa    kaksinkertainen    .
 
 

 
2. dynaaminen_cast
The dynaaminen_cast operaattoria käytetään pääasiassa alaslähetyksen suorittamiseen (perusluokan osoittimen/viittauksen muuntamiseen johdetuksi luokaksi). Se varmistaa tyyppiturvallisuuden suorittamalla ajonaikaisen tarkistuksen varmistaakseen muunnoksen oikeellisuuden.
 
Dynaamisen_lähetyksen syntaksi
  dynamic_cast   <  new_type>(ilmaisu);>>
Jos muuntaminen ei ole mahdollista,    dynaaminen_cast    palauttaa a    nolla osoitin    (osoittimen muunnoksia varten) tai heittää a    bad_cast poikkeus    (viitemuunnoksia varten).
 
    Esimerkki dynamiikasta_cast    
C++ 
// C++ program to illustrate the dynamic_cast #include  using namespace std; // Base Class class Animal { public: virtual void speak() const { cout << 'Animal speaks.' << endl; } }; // Derived Class class Dog : public Animal { public: void speak() const override { cout << 'Dog barks.' << endl; } }; // Derived Class class Cat : public Animal { public: void speak() const override { cout << 'Cat meows.' << endl; } }; int main() { // base class pointer to derived class object Animal* animalPtr = new Dog(); // downcasting Dog* dogPtr = dynamic_cast(eläinPtr); // tyyppilähetyksen onnistumisen tarkistaminen if (dogPtr) { dogPtr->speak(); } else { cout<< 'Failed to cast to Dog.' << endl; } // typecasting to other dervied class Cat* catPtr = dynamic_cast(eläinPtr); if (catPtr) { catPtr->puhu(); } else { cout<< 'Failed to cast to Cat.' << endl; } delete animalPtr; return 0; }>
   
  Lähtö      Selitys:    Tulosteen ensimmäinen rivi tulostetaan, koska    'animalPtr'    -lta    'Eläin'    tyyppi on lähetetty onnistuneesti    'Koira'    tyyppi ja    puhua()    Koira-luokan toimintoa vedotaan, mutta    'Eläin'    kirjoita kohtaan    'Kissa'    tyyppi epäonnistui, koska    'animalPtr'    osoittaa a    'Koira'    Näin ollen dynaaminen heitto epäonnistuu, koska tyyppilähetys ei ole turvallista.
 
 

 
3. const_cast
The     const_cast     -operaattoria käytetään muuttujan const- tai volatile-tunnisteen muokkaamiseen. Sen avulla ohjelmoijat voivat väliaikaisesti poistaa objektin pysyvyyden ja tehdä muutoksia. Varovaisuutta on noudatettava käytettäessä const_castia, koska const-objektin muokkaaminen voi johtaa määrittelemättömään toimintaan.
 
    Const_castin syntaksi    
  const_cast   <  new_type>(ilmaisu);>>
    Esimerkki const_castista    
C++ 
// C++ program to illustrate the const_cast #include  using namespace std; int main() { const int number = 5; // Pointer to a const int const int* ptr = &number; // int* nonConstPtr = ptr; if we use this // instead of without using const_cast // we will get error of invalid conversion int* nonConstPtr = const_cast (ptr); *eiConstPtr = 10; cout<< 'Modified number: ' << *nonConstPtr; return 0; }>
   
  Lähtö  Yllä olevassa esimerkissä olemme muuttaneet arvoa    const tyyppi    osoitinta muuttamalla sen tarkennetta    konst    to    ei-vakio    ja tulostaa sitten muokattu arvo.
 
4. tulkita uudelleen
The reinterpret_cast-operaattori käytetään osoittimen muuntamiseen minkä tahansa muun tyyppiseksi osoittimeksi. Se ei tarkista, onko muunnettu osoitin samaa tyyppiä vai ei.
 
    Reinterpret_cast syntaksi    
  reinterpret_cast   <  new_type>(ilmaisu);>>
    Esimerkki    
C++ 
// C++ program to illustrate the reinterpret_cast #include  using namespace std; int main() { int number = 10; // Store the address of number in numberPointer int* numberPointer = &number; // Reinterpreting the pointer as a char pointer char* charPointer = reinterpret_cast(numeroosoitin); // Muistiosoitteiden ja arvojen tulostaminen cout<< 'Integer Address: ' << numberPointer << endl; cout << 'Char Address: ' << reinterpret_cast(charPointer)<< endl; return 0; }>
   
  Lähtö  Yllä olevassa esimerkissä olemme määrittäneet int-muuttujan    'määrä'    ja tallenna sitten numeron osoite    'numeroosoitin'    int-tyypin jälkeen olemme muuntaneet    'numeroosoitin'    int-tyypin char-osoittimeen ja tallenna se sitten kohtaan    'charPointer'    muuttuja. Varmistaaksemme, että olemme tulostaneet sekä numberPointer- että charPointer-osoitteen. charPointeriin tallennetun osoitteen tulostaminen    tulkita uudelleen    käytetään ohittamaan C++:n tyypintarkistusmekanismi ja sallimaan osoittimen tulostamisen yleisenä muistiosoitteena ilman tyyppikohtaista tulkintaa.
  
    Huomautus:    const_cast ja reinterpret_cast eivät yleensä ole suositeltavia, koska ne ovat alttiita erilaisille virheille.