Ok, so I've just start using Angelscript recently and absolutely love it. Have a question on something i'm confused about

I've registered an object like this:

The difference between a reference and handle in AngelScript is pretty much the same as the difference between a reference and a pointer in C++.

You already stated one of the differences: "I also understand that a reference cannot be null and a object handle can be".

Another difference is that a reference cannot be reassigned to point to a different object while an handle can be.

When registering functions with AngelScript you'll have to be careful with the choice of reference versus handle due to the reference counting. When registering the function as returning a reference, the C++ function must not increment the ref counter of the object, but when registering the function as returning a handle, the C++ function must increment the ref counter of the object (or use auto handles to tell AngelScript to do that for you). If you don't do this correctly you may end up with memory leaks, or crashes due to the objects being freed too early.

Thank you for the reply.

I registered a callback like this:

r = scriptEngine->RegisterFuncdef("void CTimerCallback(CTimer@)");

In a script I made this function:

void DoRandomStuff(CTimer@ timer)
{
Print("Well this is great\n");
}

CTimer timer;
CTimer@ timer_handle = @timer;


void DoRandomStuff(CTimer@ timer)
{
Print("Well this is great\n");
}

that all makes sense, but if you need to pass that handle (timer_handle) which was declared to be a handle onto another function do you need to use @?

so should it be:

DoRandomStuff(timer_handle);

or

DoRandomStuff(@timer_handle);

They both work and script runs fine but I'm wondering if there is any different between the two?

Earlier I said "I'm assuming refCount is supposed to be reduced by the function caller and not the function called?"

I decided to test this out in a script, I added logging AddRef() ReleaseRef() and Constructor functions in the CTimer class

I tested it with this script:

void main()
{
	CTimer Timer;
	Timer.start();
	Sleep(50);
	Timer.stop();
	Print("Stopped timer\n");

	CTimer@ timer_handle = @Timer;
	PrintElapsedTime(timer_handle);
	Print("Returned to main()\n");
}

void PrintElapsedTime(CTimer@ timer)
{
	Print("PrintElapsedTime() called\n");
	Print("Time elapsed: " + timer.milliseconds() + "\n");
}

As you can see ReleaseRef() was called in PrintElapsedTime() for then handle passed in parameter

But this doesn't happen when you call a script function which takes in a handle as parameter from C++ application

Actually, script not calling ReleaseRef() might be an error from my part, doing some more testing, will update post

EDIT: it appears the script calls AddRef() and also ReleaseRef() when it is called from C++ that would explain why from my earlier test memory was never freed and so I thought ReleaseRef() wasn't called.

Create object in C++ (ref=1) -> call script function (ref += 1 -> ref = 2) -> finish script function (ref -=1 -> ref = 1)

I'd have to initliase the object with ref=0 from C++ and then that way it would delete in script, but it is supposed to be initliased to ref=1

Ah okay thanks. I was using SetArgObject(), that would explain the increment of ref counter. I've switched it to SetArgAddress and it works fine now