Pseudopointers

sorry for the delayed answer.. I was on my vacations XD

well thanks for making a point @ovidiucucu

let me tell you that I already noticed that some people that participated here
are experienced somehow. For example Paul, he started not demostrating it by
making some subjetive comments but later he shown he is experienced enough.
It was really not my intention to disrespect him. so I apologize if that was the case.

for example this guy @laserlight

he doesn't seem to be experienced, since he only says useless things, mostly
subjetive to me, but he wasn't capable of reading a source code still. he
didn't read my code.

@laserlight I don't really care if you are having breakfast or taking a ride, I would mostly
care if you can read a source code and make objective comments on it.

Let me tell you that now you have 3 working examples in my first post,
I say it again, you have 3 codes and not 1.
so you can't just say "your code doesn't work" because you would need to specify
which one of the three.

I know the 3 codes are working, let me explain to you the 3 codes.

the first code was already discussed, it takes advantage or is exploiting the fact
that some compilers, maybe all, maybe some, or whatever, are arranging 10 static global (and initialized)
variables in a contiguous position, one next to the other.

I know this behaviour is not specified in the C/C++ specifications, that was already
discussed.

For that reason, I dediced to follow your suggestions and went to make the other 2
codes, which are using a 10-var struct and a 10-element array respectively, so you can be sure
that the internal elements are stored contiguously.

The code is portable (examples 2 and 3) since it takes into account the data size type and the pointer
size type.

Anyways, all this doesn't mean to be a library or something, is just a demostration
on the pseudopointers.

I understand now that this is maybe not for beginners , if so, it looks more like a "hack sytle" of coding, which doesn't characterize me.

Regards

surprisingly (?), you not only insist on ignoring others' advice, you also keep saying wrong things proving poor understanding of basic programming facts:

Quote:

---

Originally Posted by eightyfive

For that reason, I dediced to follow your suggestions and went to make the other 2
codes, which are using a 10-var struct and a 10-element array respectively, so you can be sure
that the internal elements are stored contiguously.

The code is portable (examples 2 and 3) since it takes into account the data size type and the pointer
size type.

---

neither example "2" nor "3" is portable, the former mainly due to possible padding breaking the alleged contiguity of those ints, the latter due to the non portability of the assumption that arithmetic operations on integers are equivalent to the corresponding operations on pointers. BTW, note that both these observations have been already suggested to you many posts ago ...

Quote:

---

Originally Posted by superbonzo

surprisingly (?), you not only insist on ignoring others' advice, you also keep saying wrong things proving poor understanding of basic programming facts:



neither example "2" nor "3" is portable, the former mainly due to possible padding breaking the alleged contiguity of those ints, the latter due to the non portability of the assumption that arithmetic operations on integers are equivalent to the corresponding operations on pointers. BTW, note that both these observations have been already suggested to you many posts ago ...

---

ignoring what? I don't insist or prove anything, I just said I followed his suggestions.. didn't you see that part? I used an array instead those 10 static global variables. so why you say I am ignoring something?

and nobody did mention "padding" in a structure or an array so stop lying, or give me link to the comment since I don't want to loop through all those messages XD

padding in an array? well that is new to me, but considering I'm a student I don't have to know everything at start, sure you are ignorant at some point if I ask you a couple of things...
http://stackoverflow.com/questions/1...tween-elements
http://www.daniweb.com/software-deve...dding-an-array
http://computer-programming-forum.co...28164a3d8d.htm
http://www.cplusplus.com/forum/beginner/50479/
http://postimg.org/image/qsun6ojo/
http://bytes.com/topic/c/answers/217456-array-padding

Quote:

---

the assumption that arithmetic operations on integers are equivalent to the corresponding operations on pointers

---

?? explain it better, maybe you can quote my code and explain it all better, I really don't want to figure it all out what you are saying because it could be nothing relevant after all.

seriously, if you can quote here line by line, my examples 2 or 3, and tell me line by line what is this doing and remarking your point, that would be professional enough from your part.

I won't be insisting in the portability of this, since you came with a concept that I didn't know

Regards

you said

Quote:

---

Originally Posted by eightyfive

I dediced to follow your suggestions and went to make the other 2
codes, which are using a 10-var struct and a 10-element array respectively

---

now, apparently the two examples appear reversed in post#1; obviously, the padding I referred to is of the struct example.

Quote:

---

Originally Posted by eightyfive

explain it better

---

given a pointer "T* p" and an integer type I with sizeof(I) >= sizeof(T*) then it's guaranteed that

Code:

---

reinterpret_cast<T*>( reinterpret_cast<I>( p ) ) == p

---

always holds true. In other words, one can store a pointer in an integer and then convert back the integer to the pointer obtaining the original value.

But, code like

Code:

---

reinterpret_cast<T*>( reinterpret_cast<I>( p ) + sizeof(T) ) == p + 1

---

is NOT guaranteed to work on all platforms/compilers. In other words, in order to operate on integers as if they were pointers you need to make assumptions on the bit-representation of the pointer type; the latter is not fixed by the standard.

Quote:

---

Originally Posted by eightyfive

give me link to the comment since I don't want to loop through all those messages XD

---

struct binary layout has been mentioned in post#10 by OReubens, and the non-portability of integer arithmetic operations with pointer conversions has been mentioned by myself in post#38.

Quote:

---

Originally Posted by eightyfive

ignoring what?

---

please, reread carefully ovidiucucu's last post, especially the first point ...

alright, I will

ex.2

Code:

---

#define XPOINTERTYPE unsigned long
#define XVARTYPE int

        unsigned char OFFS = (unsigned char)sizeof(XVARTYPE);// Up to 255
        XPOINTERTYPE entradaX=(XPOINTERTYPE)&entradas[0];// Una especie de puntero THIS
        XPOINTERTYPE inicio_bloque=(XPOINTERTYPE)&entradas[0];
        XPOINTERTYPE fin_bloque=(XPOINTERTYPE)&entradas[9];

---

ex.3

Code:

---

#define XPOINTERTYPE unsigned long
#define XVARTYPE int

        unsigned char OFFS = (unsigned char)sizeof(XVARTYPE);// Up to 255
        XPOINTERTYPE entradaX=(XPOINTERTYPE)&entradas.a;// Una especie de puntero THIS
        XPOINTERTYPE inicio_bloque=(XPOINTERTYPE)&entradas.a;
        XPOINTERTYPE fin_bloque=(XPOINTERTYPE)&entradas.j;

---

I wanted to arrange for portability issues using 2 datatypes for VALUE operations and for POINTER operations, you see those definitions (XVARTYPE and XPOINTERTYPE) for each situation.
and definition 'OFFS' will hold the correct offset to displace along every entry of the structure in memory. (it uses sizeof to enforce the correct value in different platforms). I'm just telling you what was my workaround for the compatibility issue.
but I didn't consider the padding in a struct, and not even know that of padding in arrays (you gave that information).
So, that was just my attempt, but as I told you, I won't insist defending the portability of my examples.
thanks for your time.
Regards

Quote:

---

Originally Posted by eightyfive

but I didn't consider the padding in a struct, and not even know that of padding in arrays (you gave that information)

---

just to clarify, as I pointed out in the beginning of my last post above, I never said that arrays can have padding, only structs can have padding.