www.digitalmars.com         C & C++   DMDScript  

digitalmars.D.learn - Pointer to Object Questions

reply %u <johnkirollos yahoo.com> writes:
Hello Everybody

I'm trying to understand how to get pointers working in D, so I wrote
this example, and still several questions are without answer. Can
somebody take a look on the code below, and comment on the 3
questions in the output section? My main problem is with expressions
in the form "MyClass* pObj".

Thanks and Happy New Year
John


########################### code ###########################
import std.stdio;

class Point
{
	int m_x;
	int m_y;
	static Point recentPt;
	static Point* pRecent;

	this(int x, int y)
	{
		m_x=x;
		m_y=y;
		recentPt=this;
		pRecent=&this;			//I think incorrect
		//pRecent=cast(Point*)this;		//I think incorrect
too
		//pRecent=this;				//compile error
(cannot cast Point to Point*)
	}

	Point getMe()
	{
		return this;
	}

	Point* getPtrToMe()
	{
		return &this;
	}
}

int main()
{
	Point p1=new Point(5,5);
	writefln("p1: ( %d,%d )", p1.m_x, p1.m_y);
	writefln("recentPt: %d",cast(void*) Point.recentPt);
	writefln("Point referenced by Point.recentPt: ( %d,%d )",
Point.recentPt.m_x, Point.recentPt.m_y);
	writefln("Accessing p1 using getMe(): ( %d,%d
 )",p1.getMe().m_x, p1.getMe().m_y);
	writefln("pRecent contains: %d",cast(void*) Point.pRecent);
	writefln("Point referenced by Point.pRecent: ( %d,%d )",
Point.pRecent.m_x, Point.pRecent.m_y);
	writefln("p1.getPtrToMe() returns: %d",cast(void*)
p1.getPtrToMe());
	writefln("Accessing p1 using getPtrToMe(): ( %d,%d
 )",p1.getPtrToMe().m_x, p1.getPtrToMe().m_y);

	Point p2=new Point(8,8);
	writefln("\np2: ( %d,%d )", p2.m_x, p2.m_y);
	writefln("recentPt: %d",cast(void*) Point.recentPt);
	writefln("Point referenced by Point.recentPt: ( %d,%d )",
Point.recentPt.m_x, Point.recentPt.m_y);
	writefln("Accessing p2 using getMe(): ( %d,%d
 )",p2.getMe().m_x, p2.getMe().m_y);
	writefln("pRecent contains: %d",cast(void*) Point.pRecent);
	writefln("Point referenced by Point.pRecent: ( %d,%d )",
Point.pRecent.m_x, Point.pRecent.m_y);
	writefln("p2.getPtrToMe() returns: %d",cast(void*)
p2.getPtrToMe());
	writefln("Accessing p2 using getPtrToMe(): ( %d,%d
 )",p2.getPtrToMe().m_x, p2.getPtrToMe().m_y);

	return 0;
}

########################### Output ###########################

p1: ( 5,5 )
recentPt: 8A0FE0							--> I guess it
should be the address of p1
Point referenced by Point.recentPt: ( 5,5 )
Accessing p1 using getMe(): ( 5,5 )
pRecent contains: 12FF04
Point referenced by Point.pRecent: ( 3,4277824 )	--> what's
wrong here?
p1.getPtrToMe() returns: 12FE9C				--> why it's
not equal to pRecent (they both should be "&this"?
Accessing p1 using getPtrToMe(): ( 5,5 )	--> how come it works,
while using "Point.pRecent" does not?

p2: ( 8,8 )
recentPt: 8A0FD0							--> OK, this
shows that each point is 16-byte long ( &p1 + 16 )
Point referenced by Point.recentPt: ( 8,8 )
Accessing p2 using getMe(): ( 8,8 )
pRecent contains: 12FE6C
Point referenced by Point.pRecent: ( 3,4277824 )
p2.getPtrToMe() returns: 12FE04
Accessing p2 using getPtrToMe(): ( 8,8 )
Dec 30 2006
next sibling parent reply "Jarrett Billingsley" <kb3ctd2 yahoo.com> writes:
"%u" <johnkirollos yahoo.com> wrote in message 
news:en5lkb$v4r$1 digitaldaemon.com...
 Hello Everybody

 I'm trying to understand how to get pointers working in D, so I wrote
 this example, and still several questions are without answer. Can
 somebody take a look on the code below, and comment on the 3
 questions in the output section? My main problem is with expressions
 in the form "MyClass* pObj".

 Thanks and Happy New Year
 John

Class variables are references to begin with. You shouldn't have to use Class* types except under odd circumstances. When you initialize pRecent, you are giving it the address of a variable on the stack (the "this" pointer is just a parameter to the class method). So when you access it later, it gives garbage. Same thing with getPtrToMe -- since the 'this' pointer will probably end up at a different location on the stack, it won't give the same address as pRecent. Accessing through getPtrToMe is working, but probably only through sheer luck of the 'this' variable on the stack not being clobbered.
Dec 30 2006
parent John Kiro <johnkirollos yahoo.com> writes:
== Quote from Jarrett Billingsley (kb3ctd2 yahoo.com)'s article
 "%u" <johnkirollos yahoo.com> wrote in message
 news:en5lkb$v4r$1 digitaldaemon.com...
 Hello Everybody

 I'm trying to understand how to get pointers working in D, so I


 this example, and still several questions are without answer. Can
 somebody take a look on the code below, and comment on the 3
 questions in the output section? My main problem is with


 in the form "MyClass* pObj".

 Thanks and Happy New Year
 John


 Class* types except under odd circumstances.
 When you initialize pRecent, you are giving it the address of a

 the stack (the "this" pointer is just a parameter to the class

 when you access it later, it gives garbage.  Same thing with

 since the 'this' pointer will probably end up at a different

 stack, it won't give the same address as pRecent.  Accessing through
 getPtrToMe is working, but probably only through sheer luck of the

 variable on the stack not being clobbered.

So, as BCS said, "&this" is the address of the reference to the object (I have a comment on this, and I'll post it in a separate reply), and the reference is passed to the member function on the stack. So in conclusion, I was using the address of a temp stack variable. Thanks for your useful comment John
Dec 30 2006
prev sibling parent reply BCS <nothing pathlink.com> writes:
%u wrote:
 Hello Everybody
 
 I'm trying to understand how to get pointers working in D, so I wrote
 this example, and still several questions are without answer. Can
 somebody take a look on the code below, and comment on the 3
 questions in the output section? My main problem is with expressions
 in the form "MyClass* pObj".
 
 Thanks and Happy New Year
 John
 

by reference. class Foo{} Foo* f; // this is a pointer to a reference (pointer) to an object Foo g; // this is a reference to an object regular types are not int* p; //pointer to int
Dec 30 2006
parent reply John Kiro <johnkirollos yahoo.com> writes:
== Quote from BCS (nothing pathlink.com)'s article
 %u wrote:
 Hello Everybody

 I'm trying to understand how to get pointers working in D, so I


 this example, and still several questions are without answer. Can
 somebody take a look on the code below, and comment on the 3
 questions in the output section? My main problem is with


 in the form "MyClass* pObj".

 Thanks and Happy New Year
 John


 by reference.
 class Foo{}
 Foo* f;	// this is a pointer to a reference (pointer) to an object
 Foo g; // this is a reference to an object
 regular types are not
 int* p; //pointer to int

OK, but why does the compiler accepts something like: Point* pp1 = &p1; writefln("Accessing p1 using pp1: ( %d,%d )", pp1.m_x, pp1.m_y); I mean it seems that the leftside of "." can be either an object reference (p1) or a pointer to an object reference (pp1). Is this indeed the case? BTW, I tested the above 2 statements in main(), and the result was correct. Anyway, I guess I have to give up using pointers to objects. (may be it's OK in structs, not classes??) Regards John
Dec 30 2006
parent reply Kirk McDonald <kirklin.mcdonald gmail.com> writes:
John Kiro wrote:
 OK, but why does the compiler accepts something like:
 
   Point* pp1 = &p1;
   writefln("Accessing p1 using pp1: ( %d,%d )", pp1.m_x, pp1.m_y);
 
 I mean it seems that the leftside of "." can be either an object
 reference (p1) or a pointer to an object reference (pp1). Is this
 indeed the case?
 

Correct. D has no member indirection operator (->) as C and C++ do. You just use . for everything. (The compiler knows if you're talking about a pointer or not, and is smart enough to figure it out.)
 BTW, I tested the above 2 statements in main(), and the result was
 correct.
 
 Anyway, I guess I have to give up using pointers to objects. (may be
 it's OK in structs, not classes??)
 

Since classes are by reference, anyway, there's no good reason to throw around pointers to objects. If you /really/ want a pointer to a class instance, you can cast the reference to a void*: Foo f = new Foo; void* ptr = cast(void*)f; (This should reinforce the fact that class references are just pointers.) However, this is pretty darned hackish, and usually serves little purpose. (Once cast to void*, you can't use that void* to access members of the class without casting it back.) The only use I can think of for this is when keeping references to GC-controlled objects. -- Kirk McDonald Pyd: Wrapping Python with D http://pyd.dsource.org
Dec 30 2006
next sibling parent reply John Kiro <johnkirollos yahoo.com> writes:
== Quote from Kirk McDonald (kirklin.mcdonald gmail.com)'s article

 Correct. D has no member indirection operator (->) as C and C++ do. You
 just use . for everything. (The compiler knows if you're talking about a
 pointer or not, and is smart enough to figure it out.)

hmmm.. thanks for clarifying this point.
 Since classes are by reference, anyway, there's no good reason to throw
 around pointers to objects.
 If you /really/ want a pointer to a class instance, you can cast the
 reference to a void*:
      Foo f = new Foo;
      void* ptr = cast(void*)f;
 (This should reinforce the fact that class references are just
 pointers.) However, this is pretty darned hackish, and usually serves
 little purpose. (Once cast to void*, you can't use that void* to access
 members of the class without casting it back.) The only use I can think
 of for this is when keeping references to GC-controlled objects.

Speaking about casting, there is usually a need to cast a reference to an integer & vice-versa; I'm specifically pointing to the case of using a function like the Win32 API function SetWindowLong(), in order to link a window with a corresponding object. Here is how I did it: //Linking view window to view obj: SetWindowLong(hwndView,0,cast(uint)(cast(CView*)this)); //retrieve the object given the window handle: cast(CView)cast(CView*)GetWindowLong(hwndView,0); Casting to void* instead of CView* also compiled without errors. So is this the usual way of doing such thing? I mean double casting? Because casting an object to int or vice-versa is rejected by the compiler. Regards John
Dec 30 2006
parent reply "Jarrett Billingsley" <kb3ctd2 yahoo.com> writes:
"John Kiro" <johnkirollos yahoo.com> wrote in message 
news:en6pvm$23fk$1 digitaldaemon.com...
 Speaking about casting, there is usually a need to cast a reference to an
 integer & vice-versa; I'm specifically pointing to the case of using a 
 function
 like the Win32 API function SetWindowLong(), in order to link a window 
 with a
 corresponding object. Here is how I did it:

  //Linking view window to view obj:
  SetWindowLong(hwndView,0,cast(uint)(cast(CView*)this));

  //retrieve the object given the window handle:
  cast(CView)cast(CView*)GetWindowLong(hwndView,0);

 Casting to void* instead of CView* also compiled without errors.

 So is this the usual way of doing such thing? I mean double casting?
 Because casting an object to int or vice-versa is rejected by the 
 compiler.

Yes. Though you should use the cast(uint)cast(void*)this form, as this is the more generally accepted way. It makes it obvious that you're getting the pointer value of the reference, compared to cast(uint)cast(CView*)this Since 'this' is of type CView, casting CView to CView* doesn't really make sense, but casting to void* does -- it says "I want a raw pointer."
Dec 30 2006
parent reply John Kiro <johnkirollos yahoo.com> writes:
Thanks guys for all your comments.. I've found them invaluable in
this tricky part of my D language exploration :-)

As a summary:

- CObj obj2=obj1;

    obj2 is a reference to obj1 (both obj1 & obj2 refer to the same
object). So no new object is created.

- CObj* pRefObj1=&obj1;

    pRefObj1 is the address of the reference of the object, not a
pointer to the object itself.. TAKE CARE!

- void* pObj1=cast(void*)obj1;

    pObj1 is a pointer to the object itself (as object pointers in
C++)


Happy New Year
John
Jan 01 2007
parent "Jarrett Billingsley" <kb3ctd2 yahoo.com> writes:
"John Kiro" <johnkirollos yahoo.com> wrote in message 
news:enavsd$49l$1 digitaldaemon.com...

 As a summary:

 - CObj obj2=obj1;

    obj2 is a reference to obj1 (both obj1 & obj2 refer to the same
 object). So no new object is created.

 - CObj* pRefObj1=&obj1;

    pRefObj1 is the address of the reference of the object, not a
 pointer to the object itself.. TAKE CARE!

 - void* pObj1=cast(void*)obj1;

    pObj1 is a pointer to the object itself (as object pointers in
 C++)

Right on all counts.
Jan 01 2007
prev sibling next sibling parent "Frank Benoit (keinfarbton)" <benoit tionex.removethispart.de> writes:
I want to add this pitfalls (3) and (5):

interface I {}
class O : I {}
void main(){
  O o = new O;
  O[] oa;
  I[] ia;

  // (1)
  I i1 = o;
  // downcast: This is ok.
  // The compiler does apply a pointer adjustement.

  // (2)
  O o2 = cast(O)i1;
  // upcast: Needs explicit cast. This is ok.
  // The compiler does apply a pointer adjustement.

  // (3)
  void* ptr = cast(void*)o;
  I i2 = cast(I)ptr; // error!
  // The compiler cannot apply the pointer adjustement.
  // will result in undefined behaviour.

  // (4)
  ia.length = oa.length;
  for( int idx = 0; idx < oa.length; idx++ ){
    ia[idx] = oa[idx];
  }
  // and array cannot be casted in one step.
  // this can be done with a templated "arraycast"

  // (5)
  ia = cast(I[])oa;
  // error, this is something like (3). "reinterpret_cast"
  // again undevined behaviour

}
Dec 30 2006
prev sibling parent reply Thomas Kuehne <thomas-dloop kuehne.cn> writes:
-----BEGIN PGP SIGNED MESSAGE-----
Hash: SHA1

Kirk McDonald schrieb am 2006-12-30:

<snip>

 Since classes are by reference, anyway, there's no good reason to throw 
 around pointers to objects.

There is at least one valid use case for pointers to objects: # # ClassType[IndexType] aa; # //... # ClassType* c = index in aa; # Thomas -----BEGIN PGP SIGNATURE----- iD8DBQFFlv+lLK5blCcjpWoRArMqAJwK3ylM4s/2PGsiHp38n1dKUIAKIgCcCig3 CU554YE1xrzlEAb1bycOqFM= =vTmJ -----END PGP SIGNATURE-----
Dec 30 2006
parent Kirk McDonald <kirklin.mcdonald gmail.com> writes:
Thomas Kuehne wrote:
 Kirk McDonald schrieb am 2006-12-30:
 
 <snip>
 
 Since classes are by reference, anyway, there's no good reason to throw 
 around pointers to objects.

There is at least one valid use case for pointers to objects: # # ClassType[IndexType] aa; # //... # ClassType* c = index in aa; # Thomas

But what you have there isn't a pointer to an object, it's a pointer to a reference. This is an important distinction. import std.stdio; class Foo{} void main() { Foo f = new Foo; void* ptr = cast(void*)f; Foo* fptr = &f; writefln("ptr: %s", ptr); writefln("fptr: %s", fptr); writefln("*fptr: %s", *cast(void**)fptr); } $ ./test ptr: B7CBAFE0 fptr: BF96E110 *fptr: B7CBAFE0 In this example, ptr is a pointer to the actual object. fptr is a pointer to the /reference/. Because variables of type 'Foo' are actually pointers, variables of type Foo* are pointers to pointers. The following, therefore, is a very bad idea: Foo* func() { Foo f = new Foo; return &f; } This returns a pointer to a stack variable (the Foo reference f). This is a bad idea for the same reason returning a pointer to any stack variable is a bad idea. -- Kirk McDonald Pyd: Wrapping Python with D http://pyd.dsource.org
Dec 30 2006