Deallocating memory in main function that was malloc'd elsewhere.

The instructions for the program state that "The main program should deallocate the returned array when it's finished using it."

Which is slightly ambiguous, the function actually returns a pointer that points to the first element of an array that the function creates.

My main:

Code:

int main (void)
{
	int c[] = {2,4,4,6};

	printf("Reverse 2 returns: %i, which is the value of the pointer\n" 
	"that points to the first element in a new array containing the\n" 
	"elements of array c in reverse.\n", reverse2(c, 4));
	printf("The dereferenced value it points to is: %i\n", *reverse2(c, 4));
	free(temp);
	system("pause");
}

My reverse2 function:

Code:

int* reverse2 (const int a[], int size)
{
	int i;
	int j=0;
	int* temp;
	temp=(int*)malloc(size*sizeof(int));
	int* ptr=temp;

	for (i=size-1; i>=0; --i)
	{
		temp[j]=a[i];
		++j;
	}
	return ptr;
}

That returned an error:
error C2065: 'temp' : undeclared identifier

The program itself runs fine-- if I don't free the memory-- returning all the correct values. But if I want to free up the memory used to assign that new array and such it errors.

So I'm not sure how to de-allocate that memory (besides freeing it inside the reverse2 function but then the ptr is returned in the main function pointing to garbage) in the main function.

I tried a few different approaches but it just brain damaged the comp

You need to do something like

Code:

int *bob = reverse2(c,4)

Every time you call reverse2 without storing the pointer somewhere, you immediately "leak" that memory that was allocated in the function.

Originally Posted by tabstop

You need to do something like

Code:

int *bob = reverse2(c,4)

Every time you call reverse2 without storing the pointer somewhere, you immediately "leak" that memory that was allocated in the function.

Hmm, and free(bob) will also end up freeing temp in reverse2?

There is no such thing as "temp in reverse2". By the time we get here, all knowledge of reverse2 is gone. If you mean "the memory that was allocated and stored into temp in reverse2", then yes.

Originally Posted by tabstop

There is no such thing as "temp in reverse2". By the time we get here, all knowledge of reverse2 is gone. If you mean "the memory that was allocated and stored into temp in reverse2", then yes.

Yes that is what I meant, thanks

As long as I see, you defining "tmp" INSIDE reverse2. Remember that (in C and almost all languages) when you define a variable 'foo' inside a subprocess, the scope of that variable is just that subprocess and it's children.

So, the parent of reverse2 don't see anything named "tmp", because "tmp" is locally defined in reverse2. A correct way to do what you want to do, I think, is this: (as pointed by tabstop)

Code:

int main (void)
{
	int c[] = {2,4,4,6};
	int* foo = reverse2(c, 4);

	printf("Reverse 2 returns: %p, which is the value of the pointer\n" 
	"that points to the first element in a new array containing the\n" 
	"elements of array c in reverse.\n", foo);
	printf("The dereferenced value it points to is: %i\n", *foo);
	free(foo);
	system("pause");
}

Originally Posted by ninboy

Code:

	printf("Reverse 2 returns: %i, which is the value of the pointer\n" 
	"that points to the first element in a new array containing the\n" 
	"elements of array c in reverse.\n", foo);
}

Use %p for pointers. %i will result in errors if sizeof(void *) != sizeof(int). Also the behavior is undefined regardless.

Malloc and free works with memory addresses. Malloc allocates a range and returns the address, which is stored in temp.
You return this value which can then be stored inside another variable. You then call free on that variable (pointer), which contains the original address that malloc returned.
That's how it works.