Okay, it's me again.
Most likely my question is easy to solve again, but i got hung there for 2 days now. Maybe i searched google and the forum for the wrong key words?
Well: The alst few days i was wrapping my head around AngelScript as good as possible. Now i have the problem that i want a generic method to receive return Values from Angelscript.
It looks like that:
template<class T> T getReturnG() {
asIScriptObject* sObj=*(asIScriptObject**)scriptContext->GetReturnObject();
T ent=(T)sObj;
return ent;
}
//Some specis for it.
template<> int getReturnG() {
return (int)scriptContext->GetReturnDWord();
}
It works fine with reference types, float, int etc.
But when i try to receive an std::string i get an error. It's a value type so i guess it has something to do with that?
( I registered strings with registerStdString() btw)
The compiler tells me, that asIScriptObject* can't be converted to std::string.
I got no idea how to retrieve value types with this convention. Any ideas?
Sorry, if the question is kinda dumb... ^^"
Edit: Oh i forgot:
Thats how i retrieve the return value.
std::string str=sys->getReturnG<std::string>();
Thats how i registered the function:
"string getString()"
GetReturnObject() returns a void * to the return object, you don't need to cast it to a script object pointer unless it's actually of script object type. For a std::string, you would just cast it to a std::string pointer.
There are subtle differences that depends on what exactly the function is returning, but for functions that return a value type by value they all give the same result.
As you're trying to write a template function to retrieve the return value I suggest you use the GetAddressOfReturnValue() method as it will always return a pointer to the value which can be cast to the expected type, e.g.
// A function declared as int func();
int value = *reinterpret_cast<int*>(ctx->GetAddressOfReturnValue());
// A function declared as float func();
float value = *reinterpret_cast<float*>(ctx->GetAddressOfReturnValue());
// A function declared as string func();
string value = *reinterpret_cast<string*>(ctx->GetAddressOfReturnValue());
// A function declared as obj @func(); where obj is a script class
asIScriptObject *obj = *reinterpret_cast<asIScriptObject**>(ctx->GetAddressOfReturnValue());
Is there a special reason to use reinterpret_cast over my solution? Something like a speed improvement or similar?
I read about it a bit and it seems as unsafe as the other solutions i used... So i was just wondering.
reinterpret_cast is the C++ style, and you're using the original C style cast.
C++ defined specific rules for each type of cast, i.e. const_cast, static_cast, reinterpret_cast, and dynamic_cast, where as C did everything in a single way (except the dynamic_cast that is not available in C as far as I know). In C++ each cast has restrictions and the compiler will not allow you to do a cast that is not supported by the form you used. With the C style cast all types of casts are allowed, so the compiler cannot really know which you really wanted, it will simply evaluate each of them and use the one that is possible.
To tell you the truth, I frequently use the C style cast myself out of old habit and don't really have any problems with it since I know how it works, but I'm trying to re-educate myself to use C++ style casts as they are safer. Especially with code where there are multiple programmers of varying level of expertise maintaining it.
