Thread: reinterpreting variables etc

Code:

#include <iostream>

using namespace std;

int main(int argc, char *argv[])
{
      //undefined behaviour?
      int i = 100;
      *(char *)&i = 25;
      cout << i << endl;
      
      int &r = *new int;
      r = 5;
  
      return 0;
}

Is the first part of the code undefined behaviour?

It seems like it works for any type smaller then an int, but when i try

Code:

int i = 100;
*(float *)&i = 25;
cout << i << endl;

That wont work (compiles but the value is changed to a trash val).

For the second part of the code, with references, what happens?

A compiler creates a temporary variable in which he stores the new int and reference "points" to the temporary variable which is unnamed?

What is the point of such references?


One more thing: is casting away constness undefined behaviour?

With const_cast i mean.

And... why is ~ operator when used on for example int, implementation defined? Is it because it depends if the system it's being used on uses 2s complement system to represent variables?

*(float *)&i = 25;
simply tells the compiler to take the address of i, convert it to a float and assign 25.0f to that float. Float representation is not the same as integers; therefore you see "garbage". How data is stored depends on the type and the compiler uses this type to know how to interpret the data stored at some address. It so happens that a char is stored the same way as an int.

The reference points to the storage area. An alias for that storage area. What is your question, exactly? A reference is an alias.

Casting away const can lead to undefined behavior since the compiler may assume its value may never change. But in C++ there are two different types of const--constant expressions (do absolutely not cast away the const here), and regular variables whose values mustn't change (ie variables passed to a function who promises not to change them). In the second case, it should be possible to cast away the const if you have a very good reason. For example, a legacy API.

~ simply inverts all bits in a variable, but the layout of the variable in memory is implementation defined because not all systems use 2's complement. This is to the best of my knowledge.