I would like to make sure the value of the pointer myFunction() returns is available, when it's not an Obj-C object.
double * vectorComponents (); //Just an example
double * vectorComponents ()
{
double componentSet[] = {1, 2, 3};
return componentSet;
}
How can I dynamically allocate these variables an then how to dealloc them. If I don't do anything it won't work. Thanks everyone.
NSLog(@":)");
You can use the C standard library functions malloc() and free():
double *vectorComponents()
{
double *componentSet = malloc(sizeof(*componentSet) * 3);
componentSet[0] = 1;
componentSet[1] = 2;
componentSet[2] = 3;
return componentSet;
}
double *comps = vectorComponents();
// do something with them, then
free(comps);
Also:
If I don't do anything it won't work.
Perhaps it's worth mentioning that it didn't work because it invokes undefined behavior. componentSet in your code was a local auto-array - it's invalidated at the end of its scope (i. e. it's deallocated at the time the function returns - exactly what you wanted not to happen.)
If you return a pointer that you dynamically allocate in the function then the caller will have ownership of the object and will be required to free the value.
/**
* Returns ownership, use free to release the value when done.
*/
double * vectorComponents()
{
double *componentSet = malloc(sizeof(double) * 3);
componentSet[0] = 1.0;
componentSet[1] = 2.0;
componentSet[2] = 3.0;
return componentSet;
}
void example()
{
double *components = vectorComponents();
//use components
free(components);
}
Given your example, first question is do you really need dynamic allocation? If you just want to return the address of an array initialized inside a function you can use a static variable:
double * vectorComponents ()
{
static double componentSet[] = {1, 2, 3};
return componentSet;
}
If you do need a dynamic array then there are many ways to do it. If you compute the array you can malloc() the storage to be free()'ed later. If you wish to initialize a dynamic array, then maybe change the values, and return it you can use a static array to do that. For example:
double * vectorComponents2 ()
{
static double componentSet[] = {1, 2, 3};
double *dynamic = malloc(sizeof(componentSet));
memcpy(dynamic, componentSet, sizeof(componentSet)); // copy values
// modify contents of dynamic here if needed
return dynamic;
}
Using memcpy and a static array is shorter than setting individual values and allows the contents and size of the array to be changed easily.
