Thread: Question regarding pointer, which points to typecasted object of a class

Your code is malformed nor will it have the output you suggest. count is never defined, you write on memory you don't own through a pointer. a::b() is never called. It's a mess.
I know what you were attempting (poorly) to show and that is writing to an a object through a pointer to int. That won't work either. sometimes it might, sometimes it might not, if it does it's largely through luck, it's certainly not defined behaviour.

SORRY I had type the code on a cell phone which lead to few auto-corrects along with some missing parts, here is the complete code:

Code:

#include<iostream>
using namespace std;
 
class a{
int q;
int w;
char e;
 
public:
a(int i, int j, char c): q(i),w(j),e(c)
{
cout<<" i = "<<q<<endl;
cout<<" j = "<<w<<endl;
cout<<" c  = "<<e<<"\n"<<endl;
}
void b()
{
cout<<" i = "<<q<<endl;
cout<<" j = "<<w<<endl;
cout<<" c  = "<<e<<"\n"<<endl;
}
};
int main()
{
a obj(1,2,'c');
int *i ;
i = (int *)&obj;
*(i+0)=90;
*(i+1)=89;
*(i+2)='z';
obj.b();
return 0;
}

OUTPUT:
i = 1
j = 2
C = y

i = 90
j = 89
C = z

As I said before it's purely luck that happened. It's not defined behaviour, it can't be relied on especially when you come to inheritance from non-empty base classes.

It's definitely undefined behavior.

With regards to classes, each member is guaranteed to come after the one before it. _But_ alignment is entirely out of your control. In your case, you have a structure that goes int, int, char. This is cool.

The first int starts at an offset of 0 when you take the address of the struct. The next int is guaranteed to come after the first but it doesn't have to be at an exact 4 bytes. The compiler can decide how to best pad the structure which makes pointer-like accesses incredibly dangerous because there's no guarantees about where data is going to live.

So to answer your question, no, it does not behave like an array at all. In fact, you're just lucky as Hobbit has pointed out.

I'm going to suggest something controversial but if you _must_ do this, use a static_assert to enforce the proper size.

Let's say you have a struct with 3 4 byte types. You want to access it like an array. Given how members are guaranteed to be one after the other, you can static_assert the structure to be of size 12 and then yeah, it is legal to use pointer-like accesses. But at the same time, this is a horrible, horrible red flag and it means you're most likely doing something wrong.