If you’ve used C++, the emxArray data types are like generated C equivalents of std::vector. Namely, this is how the generated code represents dynamically allocated arrays. They store data and size pointers as well as a few other details.
If you look in the directory where you generated code you should find a file named <functionName>_emxAPI.h. This file declares some utility functions which make constructing and destroying emxArray values simpler. Using them to create emxArray values ensures that all of the fields are properly initialized and insulates your code from any possible changes to the emxArray type.
In an example I made which takes an array of uint32 values and also returns such an array, I see the following functions:
extern emxArray_uint32_T *emxCreateWrapperND_uint32_T(unsigned int *data, int
numDimensions, int *size);
extern emxArray_uint32_T *emxCreateWrapper_uint32_T(unsigned int *data, int rows,
int cols);
extern emxArray_uint32_T *emxCreateND_uint32_T(int numDimensions, int *size);
extern emxArray_uint32_T *emxCreate_uint32_T(int rows, int cols);
extern void emxDestroyArray_uint32_T(emxArray_uint32_T *emxArray);
The first four functions can be used to create emxArray values in different situations.
The first pair, i.e. emxCreateWrapper_uint32_T, emxCreateWrapperND_uint32_T, can be used to create a uint32 emxArray with the specified number of dimensions and sizes from existing data. So if you already have the input data allocated in some memory, these functions wrap that data up into an emxArray of the specified size without allocating extra memory for your data.
/* Create a 10-by-10 C array of uint32 values and wrap an emxArray around it */
uint32_T x[100];
emxArray *pEmx = NULL;
int k = 0;
for (k = 0; k < 100; k++) {
x[k] = (uint32_T) k;
}
pEmx = emxCreateWrapper_uint32_T(x, 10, 10);
/* Use pEmx here*/
/* Deallocate any memory allocated in pEmx. */
/* This DOES NOT free pEmx->data because the "wrapper" function was used */
emxDestroyArray_uint32_T(pEmx);
The second pair, i.e. emxCreate_uint32_T, emxCreateND_uint32_T, also create emxArray values. However, they also heap allocate storage for the data field of the emxArray. This memory will be large enough to hold the number of elements specified in their respective size arguments After calling these, you will need to populate the data stored in the data field of the returned emxArray struct:
/* Allocate a 10-by-10 uint32 emxArray and fill the values */
int k = 0;
emxArray *pEmx = emxCreate_uint32_T(10, 10);
for (k = 0; k < 100; ++k) {
pEmx->data[k] = (uint32_T) k;
}
/* Use pEmx here*/
/* Deallocate any memory allocated in pEmx. */
/* This DOES free pEmx->data */
emxDestroyArray_uint32_T(pEmx);
The last, emxDestroyArray_uint32_T, will be used to destroy the array and deallocate any memory allocated by the previous methods.
Finally, to capture your output, you could use emxCreate_struct_T or emxCreateND_struct_T to create an empty emxArray of struct_T values with the proper number of dimensions by passing 0 for one or more sizes where appropriate. The generated code will allocate enough memory to hold the resulting data in your output emxArray at runtime. You can then check the size field of this output emxArray to view the sizes of the dimensions of the data field and extract the data as you wish.
The documentation for using emxArray arguments is available here.