reinterpret_cast

Örnek
Elimizde şöyle bir bellek olsun.

char* p = ...;

Şöyle yaparız.

std::int32_t v = *reinterpret_cast<std::int32_t*>(p);

Örnek - binary dosyaya yazma/okuma işlemleri

reinterpret_cast'in en çok işe yaradığı noktalardan birisi, bir POD nesneyi dosyaya yazma. Nesne char*

tipine cast ediliyor. Elimizde şöyle bir sınıf olsun

class PhoneBook
{
public:
   PhoneBook(int=0,const std::string & = "", const
      std::string & = "", const std::string & = "");
 
   void setId(int);
   int getId() const;
 
   void setFirstName(const std::string &);
   std::string getFirstName() const;
 
   void setLastName(const std::string &);
   std::string getLastName() const;
 
   void setPhone(const std::string &);
   std::string getPhone() const;
 
   std::string toString() const;
 
private:
   int id;
   char firstName[10];
   char lastName[10];
   char phone[10];
};

Bu sınıfı dosyaya yazmak için şöyle yaparız

const string fileName = "phonebook.dat";
 
void create(){
  ofstream file(fileName, ios::out|ios::app|ios::binary);
  PhoneBook pb;
  ...
  file.write(reinterpret_cast<const char *>(&pb), sizeof(PhoneBook));
}

Dosyada bulmak için şöyle yaparız

const string fileName = "phonebook.dat";
 
PhoneBook findById(int id){
  ifstream file(fileName, ios::binary);
  
  PhoneBook pb;
  while(file.read(reinterpret_cast<char *>(&pb),sizeof (PhoneBook))){
    if(pb.getId()==id) {
      break;
    }
  }
  return pb;
}   

Örnek

Elimizde şöyle bir kod olsun

class Foo {
public:
  int m_Foo; // Completely vulnerable and dangerous
    
protected:
  int m_Bar; // Possible attack vector from subclasses
    
private:
  int m_FooBar; // Totally secure
};

Public olmayan alanlara erişmek için şöyle yaparız. 

struct PublicFoo {
  int m_Foo;
  int m_Bar;
  int m_FooBar;
};

PublicFoo* attack(Foo* supposedly_secure) {
  return reinterpret_cast<PublicFoo*>(supposedly_secure);
}

Aynı şeyi offset ile de yapabiliriz. Şöyle yaparız. 

int attack_bar(Foo const* supposedly_secure) {
  const auto start_of_the_object = reinterpret_cast<char*>(supposedly_secure);
  const auto offset = sizeof(int);  // skip over m_Foo field
  const auto location = start_of_the_object + offset;
  return *reinterpret_cast<int*>(location);
}