Constructing an object to return by value elsewhere

Question

In a wrapper to interface the V8 JavaScript engine with C++ code, I'd like to call a C++ function passing it an object by value. The object is automatically constructed from data inside JavaScript.

The C++ function to call takes an object of type T and a template is used to generate an adapter function A, returning T by value. The problem is that the adapter function A needs to call a JavaScript function passing it another C++ function B as a callback. The object of type T is constructed in that function B. It cannot be returned back to A through JavaScript, which doesn't know how to handle the object of type T.

The simplest way is to have a local variable of type T inside function A. A pointer to it is given to B, which assigns a new value to the local variable, which A later returns, approximately like so (Some details omitted regarding how arguments are passed to callJavaScript and callback. In reality, T's constructor and thus the B function may take any number of more complicated types as parameters):

C++ code:

T A() {
    T data;

    callJavaScript("someJavaScriptFunction", &B, &data);

    return data;
}

void B(T *data, int importantValue) {
    *data = T(importantValue);
}

JavaScript code:

function someJavaScriptFunction(callback, dataRef) {
    callback(dataRef, getImportantValueSomehow());
}

But what if the type T doesn't support assignment or even have a copy constructor? Is there a way to avoid unnecessary copying? I thought of allocating empty space inside function A as a local variable:

typename std::aligned_storage<sizeof(T), alignof(T)>::type data;

Function B could then construct the object in that space using placement new, but how can I return the resulting object from A using move semantics? How to call a possible destructor correctly?

My final idea was to use more template trickery to allocate space for parameters for type T's constructor inside function A, set them through pointers from B and finally construct the object inside A, but it will get nasty if data in some parameters goes out of scope when callJavaScript returns. Is there a solution for that?

EDIT: The point of all this is to get the contents of a JavaScript object into C++. Reading the object's properties from C++ requires looking them up by name using strings. A JIT-compiled function in V8 has more direct access to the object's fields and reads of the object's properties in someJavaScriptFunction get compiled into simple pointer reads. Then it can call the C++ callback with various parameters which are reasonably fast to convert from JavaScript value handles into C++ types.

EDIT2: The simple first idea is:

typename std::aligned_storage<sizeof(T), alignof(T)>::type data;
::new(&data) T(); // THIS LINE ACTUALLY PLACED IN ANOTHER FUNCTION
return(*reinterpret_cast<T *>(&data));

But should I call the destructor for the object T constructed in data, and when to call it, and how? This is a library and adding code to the recipient of the return value is not really an option.

Answer 1

I ended up using a wrapper around A that handles calling placement new and A's destructor. It allows the library's user to supply any class A, as long as it has a move constructor. The full code of a working test and discussion about it are found in a newer, better formulated question Placement new, return by value and safely dispose temporary copies and its accepted answer.

Answer 2

I am not sure I understood completely your question, but it seems that you don't have a need to pass output parameters in your functions.

Simply have function A return a value as you already put in the question, and have B return a value.

Because of the "named return value optimization" there is no need for assignment operator nor copy constructors. That is, if your code satisfies the requirements for "NRVO" you would be fine:

T B(int importantValue) { return T{importantValue}; }

Does not need assignment operator nor copy constructor from T. Then, change callJavascript to not require output parameters, but return a value, and then this will work without copy constructors or assignment operator:

T A() { A rv{callJavascript(&B)}; return rv; }

In general, make it so that your functions don't require output parameters, otherwise you require your types to have copy constructors and assignment operators, or to violate the type system.

By the way, make callJavascript such that it is a template that takes a callable as argument.