Return Pointer Deallocation

Well here's my silly doubt..

Do i need to deallocate a return pointer...

Code:

char* function()
{
char *temp;
temp=new char[100];


\\ sometin



return temp;

}

I cannot deallocate it in the function itself... SHould i deallocate after the function call in the main.

Code:

temp=function(); \\ considering temp is a pointer
delete(temp);  \\ do i need to do this

I am asking this because i have never deallocated this kind of pointer.. Is what i am doing wrong.. do i need to deallocate it .. if so what is the right method... (hope i am not balbbering)

Yes, you have to deallocate it. Stuff you allocate with new doesn't go out of scope when the function/block ends.

Originally posted by blackrat364
Yes, you have to deallocate it. Stuff you allocate with new doesn't go out of scope when the function/block ends.

For obvious reasons io cannot deallocate it in the function itself.. So is deallocating from the calling point a good enough method..

Yup, you can deallocate it anywhere.

First, the proper deletion would be:

delete[] temp;

You should, however, use something that automatically deallocates. For char *, use a std::string instead. For an array of any other type, use std::vector. If you need to return a new single object of some kind, something like boost::shared_ptr is the key.

It's a very, very bad idea to write a function such that the caller must deallocate memory. If you must return a newly allocated resource, put it in a container that will free the memory automatically.

Originally posted by Cat
First, the proper deletion would be:

delete[] temp;

You should, however, use something that automatically deallocates. For char *, use a std::string instead. For an array of any other type, use std::vector. If you need to return a new single object of some kind, something like boost::shared_ptr is the key.

It's a very, very bad idea to write a function such that the caller must deallocate memory. If you must return a newly allocated resource, put it in a container that will free the memory automatically.

Thanx.. Could you please give me a small example.. Using Vector is one way... but how about if you have to use return pointers..

Here are some examples:

Code:

Before using std::vector:

#include <iostream>

int * getArray(){
   return new int[25];
}

int main(){
   int * arr = getArray();
   for (int i = 0; i < 25; i++)
      arr[i] = i * 2;
   for (int i = 0; i < 25; i++)
      std::cout << "[" << arr[i] << "]";
   delete[] arr;
}

After using std::vector:

#include <iostream>
#include <vector>

typedef std::vector<int> intArray;

intArray getArray(){
   return intArray(25);
}

int main(){
   intArray arr = getArray();
   for (int i = 0; i < 25; i++)
      arr[i] = i * 2;
   for (int i = 0; i < 25; i++)
      std::cout << "[" << arr[i] << "]";
}

For single objects, you can use std::auto_ptr (NOT CONTAINER SAFE) or download Boost and use boost::shared_ptr (container safe). One example:

Code:

Before using a smart pointer:

#include <iostream>

struct Point{
   int x;
   int y;
};

Point * getPoint(){
   return new Point;
}

int main(){
   Point * p = getPoint();
   p->x = 3;
   p->y = 11;
   std::cout << "(" << p->x << ", " << p->y << ")" << std::endl;
   delete p;
}

After using a smart pointer:

#include <iostream>
#include <memory>

struct Point{
   int x;
   int y;
};

typedef std::auto_ptr<Point> pointPtr;

pointPtr getPoint(){
   return pointPtr(new Point); //Note how we wrap a call to new inside a constructor for the auto_ptr
}

int main(){
   pointPtr p = getPoint();
   p->x = 3;
   p->y = 11;
   std::cout << "(" << p->x << ", " << p->y << ")" << std::endl;
}

Hope that helps. The examples are contrived, but should illustrate usage.

thanx.. that sure did help..