Function creates memory space and returns reference to class

What I want to do is have a function create the memory space outside of the stack for a class and then return the object via a reference. Is there any problem using the below method?

Code:

---

#include <iostream>

class test {
  public:
  test *ptr;
  int x;
  test(test *x){ ptr = x; }
  ~test() { delete ptr; }
};

test & func1(void);

int main(void)
{
  test &x = func1();

  std::cout<<x.x<<std::endl;
  std::cout<<x.ptr<<std::endl;
}

test & func1(void)
{
  test *x = new test(x);

  x->x = 12;

  return *x;
}

---

It compiles and runs fine. Just wondering if there is any potential problems I should be aware of. Thanks

Code:

---

test *x = new test(x);

---

You can't do that. You are trying to use x before it has been defined. Why are you trying to do this? What are you trying to accomplish, maybe there is a better way.

Basically what I'm trying to do is to have a function create the space, load the data into the class (it will be a friend function), and return it as a reference to the caller. Since it will be by reference I don't think I can use delete on it so I need to declare a destructor that will do it for me.

As to the example above: Doesn't it depend on the order in which things are invoked? I would think the new would be done first, assigned to x, and then passed into the constructor.

I still don't understand why you would want to do what you are trying to do. As for the above example, you call new and it will construct the object with the parameter to the constructor and then assign that to x.

Look at the first post. I don't want the memory space to be removed until main()'s x variable dies. I want to pass it by reference so that I don't have to keep dereferencing a pointer each time I want to use x. I don't want to return it by copy because thats wasteful.

As for the order, the asm code shows different but that could just be g++.

Well, I know on VC++ .NET 2003 you will get a run-time error saying you are trying to use the variable before it's been defined. I also know it's pretty compliant as far as the standard goes, but who knows. I always thought it was the other way but I could be wrong.

What about using an auto_ptr ? You would have to dereference still but it would automatically be deallocated when it goes out of scope.

The problem with yours, and it may or may not be a problem for what you need it for, is you can't dynamically allocate an array the way you have it.

Ok did another test

Quote:

---

test *x=NULL;
x= new test(x);

---

and sure enough its doing what you say. thanks :)

In fact the destructor is never called. when x dies. I'll have to think of another method to do this. Thanks for the help

Ah dang. Looked at my book and as far as assigning the pointer goes it couldn't be easier.

Code:

---

test() { ptr = this; }

---

To add on to what MrWizard mentioned, std::auto_ptr would probably best suit your needs.

Code:

---

#include <iostream>
#include <memory>

class test {
  public:
    int x;
};

std::auto_ptr<test> func1(void);

int main(void)
{
  std::auto_ptr<test> x = func1();

  std::cout<<x->x<<std::endl;

  // test object is properly deleted at end of scope
}

std::auto_ptr<test> func1(void)
{
  std::auto_ptr<test> x(new test);
  x->x = 12;
  return x;
}

---

No I reference would best suit my wants, an auto_ptr might just be want I have to use though :)

Also took it a step further and realized that there was no need to store the address and this is always avilable to me and can be used on the delete.

Ok I went with auto_ptr. While its not exactly what I wanted it will do just fine. Thanks for the help you two.