Question on the C++ operator ->

[djtraumwelt]

i have some books about programming and they have all example codes in c++ and there is sometimes this -> in the c++ codes. what does this -> mean and how can i do it in programming in masm32?



I changed the title so it was more easily understood.

hutch--

[Tedd]

Code Select Expand

foo = blah->stuff

works as..

Code Select Expand

mov eax,blah
mov edx,[eax].stuff
mov foo,edx

----------------
This requires that the relevant structure pointed to by blah is known, and thus the offset of 'stuff' will be known.
('assume' directives left out of example)

[drhowarddrfine]

...so blah is an object and stuff is a member of that object, per Tedd's example.

[hitchhikr]

so blah is an object

blah is a pointer.

[djtraumwelt]

that's a little complicated. can you convert this c++ code for me in assembler code?

Code Select Expand

lpDD->CreateSurface(&ddsd, &lpDDSPrimary, NULL);

[mnemonic]

If you have a struct called foo with a member called bar and a pointer to the foo struct called pfoo the the two following expressions are the same:

Code Select Expand

pfoo->bar

Code Select Expand

(*pfoo).bar

It is not really complicated to convert the expression if you really know assembler.
So think about it a bit. It will let you gain more experience´if you convert it for yourself.
At lest show up with some code even if you couldn´t get it to work. At least try it.

[djtraumwelt]

maybe i'm a little stupid but i really dont understand! :'(

[Tedd]

so blah is an object

blah is a pointer.

blah is a pointer to an object. But in C++ when you say 'an object' you almost always really mean the pointer to the object.



dj

Code Select Expand

lpDD->CreateSurface(&ddsd, &lpDDSPrimary, NULL);
lpDD is your pointer to the DirectDraw interface.
CreateSurface is the function you want to call, but in this case you need to know the offset of the function's pointer in the interface to be able to get it and then call the function.
So..

Code Select Expand

mov ecx,lpDD                 ;ecx is the pointer to the interface
assume ecx:ptr DirectDraw    ;(or whatever it is)
mov eax,[ecx].CreateSurface  ;eax is now the pointer to the CreateSurface function in the interface pointed to by ecx
push 0                       ;}
push OFFSET lpDDSPrimary     ;} -- push parameters (reverse order)
push OFFSET ddsd             ;}
call eax                     ;now call the actual function!
assume ecx:nothing
{Note: ecx is usually used to hold the interface pointer and 'may' be used internally by the function called - ie. it may not work if you use a different register; I'm not sure of the exact rules -- or sometimes you have to push the object pointer as an 'extra' parameter}

I suggest you look at the COM-in-ASM stuff, as well as finding some directx include files for asm :wink

[hitchhikr]

-> is a C operator and not specific to C++.

So, if you have troubles with such syntax, buy a book about C or browse the web to obtain informations/tutorials about this language (C++ ones usually assume that the reader already knows C), download a C compiler from the web and see how it translates the code in asm. Also directdraw doesn't necessary require C++ even if it was designed with this language in mind.

Code Select Expand


mov ecx,lpDD                 ;ecx is the pointer to the interface
assume ecx:ptr DirectDraw    ;(or whatever it is)
mov eax,[ecx].CreateSurface  ;eax is now the pointer to the CreateSurface function in the interface pointed to by ecx
push 0                       ;}
push OFFSET lpDDSPrimary     ;} -- push parameters (reverse order)
push OFFSET ddsd             ;}
call eax                     ;now call the actual function!
assume ecx:nothing


This won't work because directx requires the calling interface as first argument (this is constant in the dx com interface).

[thomasantony]

so blah is an object

blah is a pointer.

blah is a pointer to an object. But in C++ when you say 'an object' you almost always really mean the pointer to the object.



dj

Code Select Expand

lpDD->CreateSurface(&ddsd, &lpDDSPrimary, NULL);
lpDD is your pointer to the DirectDraw interface.
CreateSurface is the function you want to call, but in this case you need to know the offset of the function's pointer in the interface to be able to get it and then call the function.
So..

Code Select Expand

mov ecx,lpDD                 ;ecx is the pointer to the interface
assume ecx:ptr DirectDraw    ;(or whatever it is)
mov eax,[ecx].CreateSurface  ;eax is now the pointer to the CreateSurface function in the interface pointed to by ecx
push 0                       ;}
push OFFSET lpDDSPrimary     ;} -- push parameters (reverse order)
push OFFSET ddsd             ;}
call eax                     ;now call the actual function!
assume ecx:nothing
{Note: ecx is usually used to hold the interface pointer and 'may' be used internally by the function called - ie. it may not work if you use a different register; I'm not sure of the exact rules -- or sometimes you have to push the object pointer as an 'extra' parameter}

I suggest you look at the COM-in-ASM stuff, as well as finding some directx include files for asm :wink

Hi,
    You don't ahve to use different registers. You can do what you are doing using one register.

Code Select Expand


mov eax,lpDD                 ;ecx is the pointer to the interface
assume eax:ptr DirectDraw    ;(or whatever it is)
mov eax,[eax].CreateSurface  ;
assume eax:nothing
push 0                       ;}
push OFFSET lpDDSPrimary     ;} -- push parameters (reverse order)
push OFFSET ddsd             ;}
call eax                     ;now call the actual function!

No need to use ecx. You can even get rid of the two ASSUMEs. Do

Code Select Expand


mov eax,(DirectDraw ptr[eax]).CreateSurface


Thomas :U

[BogdanOntanu]

Code Select Expand


xor eax,eax
push eax
push offset lp_surface
push offset ddsd_all

mov eax,[lpDD] ; main DD Object
        push     eax
mov eax,[eax]
call [eax + DDO_CreateSurface] ; CreateSurface


ok corected

As you might notice the lpDD must be the last thing pushed ie it is the first (unseen) parameter of all COM method interface calls.
You should have a valid DDSurface_Descriptor in ddsd_all and of course lpDD before calling.


The problem here is that C++ chooses to hide the lpDD-> in order ot "protect" you from yourself and to help you do not make mistakes.
In the process it is also hidding information... a standard procedure for HLL languages.

[Tedd]

Thomas, you 'can' do it like that, but I just typed out the code as I went :P Also, I think it's easier to follow (as should be the point of an example) and possibly more efficient due to register stalls :bg

Thanks boggy, though I did guess at that as an alternative :toothy

..sometimes you have to push the object pointer as an 'extra' parameter..

(-- even though your example is wrong :bdg "mov eax,[eax]" when eax=0 ?? BAADDDD!!)

So... my example, corrected

Code Select Expand

mov ecx,lpDD                 ;ecx is the pointer to the interface
assume ecx:ptr DirectDraw    ;(or whatever it is)
mov eax,[ecx].CreateSurface  ;eax is now the pointer to the CreateSurface function in the interface pointed to by ecx
push 0                       ;}
push OFFSET lpDDSPrimary     ;} -- push parameters (reverse order)
push OFFSET ddsd             ;}
push ecx                     ;push the object pointer!
call eax                     ;now call the actual function!
assume ecx:nothing