Declare stack variable without specifying the name and get the pointer

Question

It's known that defining a heap variable with new gets the pointer without specifying the name:

Var *p = new Var("name", 1);

But I have to clear the variable pointed to by p with delete p later on in the program.

I want to declare a stack variable so it is automatically cleared after function exits, but I only want to get the pointer, and the following:

Var v("name", 1);
Var *p = &v;

is quite tedious, and specifier v will never be referenced.

Can I declare a stack class instance and get its pointer without specifying its name?

Answer 1

There's two questions hidden in here. The first one is:

Var *p = new Var("name", 1);

But I have to clear the variable pointed to by p with delete p later on in the program.

I want to declare a stack variable so it is automatically cleared after function exits

So here, you're asking how to allocate memory without having to explicitly clean it up afterwards. The solution is to use std::unique_ptr:

std::unique_ptr<Var> p(new Var("name", 1));

Voila! unique_ptr will automatically clean itself up, it has virtually no overhead compared to a raw pointer, and it's overloaded the * and -> operators so you can use it just like a raw pointer. Search for "C++11 smart pointers" if you want to know more.

The second question is:

I only want to get the pointer, and the following:

Var v("name", 1);
Var *p = &v;

is quite tedious, and specifier v will never be referenced.

The important point here is that Var *p = &v is completely unnecessary. If you have a function that requires a pointer, you can use &v on the spot:

void SomeFunc(const Var* p);
// ...
Var v("name", 1);
SomeFunc(&v);

There's no need to put &v in a separate variable before passing it into a function that requires a pointer.

The exception is if the function takes a reference to a pointer (or a pointer to a pointer):

void SomeFunc2(Var*& p);
void SomeFunc3(Var** p);

These types of functions are rare in modern C++, and when you see them, you should read the documentation for that function very carefully. More often than not, those functions will allocate memory, and you'll have to free it explicitly with some other function.

Answer 2

There's no way to do this by allocating on the stack. However, you can use std::make_shared for the heap:

#include <memory>

std::shared_ptr<Var> p = std::make_shared<Var>();

Answer 3

At the cost/risk of being more confusing, you can avoid repeating the type in your code in the question ala:

Var v("name", 1), *p = &v;

You could also potentially use alloca, which is provided by most systems and returns a pointer to stack-allocated memory, but then you have to go through a separate painful step to placement new an object into that memory and do your own object destruction. alloca needs to be called inside the function so it's the function stack on which the object is created, and not during the preparation of function arguments (as the variable's memory may be embedded in the stack area the compiler's using to prepare function arguments), which makes it tricky to wrap into some easily reused facility. You could use macros, but they're evil (see Marshall Cline's C++ FAQ for an explanation of that). Overall - not worth the pain....

Anyway, I recommend sticking with the code in your question and not over-thinking this: using &v a few times tends to be easier, and when it's not it's normally not a big deal if there's an unnecessary identifier for the stack-based variable.

Answer 4

I don't think there is a way to overcome it without some overhead (like the shared_ptr). so the shortest way to write it will be:

Var v("name", 1), *p = &v;

Answer 5

Yes, it's possible to return an address to a temporary (i.e. stack) object and assign it to a pointer. However, the compiler might actually discard the object (i.e. cause that section in memory to be overwritten) before the end of the current scope. (TO CLARIFY: THIS MEANS DON'T DO THIS. EVER.) See the discussion in the comments below about the behavior observed in different versions of GCC on different operating systems. (I don't know whether or not the fact that version 4.5.3 only gives a warning instead of an error indicates that this will always be "safe" in the sense that the pointer will be valid everywhere within the current scope if you compile with that particular version of GCC, but I wouldn't count on it.)

Here's the code I used (modified as per Jonathan Leffler's suggestion):

#include <stdio.h>

class Class {
public:
    int a;
    int b;
    Class(int va, int vb){a = va; b = vb;}
};

int main(){ 
    Class *p = &Class(1, 2);
    Class *q = &Class(3, 4);
    printf("%p: %d,%d\n", (void *)p, p->a, p->b);
    printf("%p: %d,%d\n", (void *)q, q->a, q->b);
}

When compiled using GCC 4.5.3 and run (on Windows 7 SP1), this code printed:

0x28ac28: 1,2
0x28ac30: 3,4

When compiled using GCC 4.7.1 and run (on Mac OS X 10.8.3), it printed:

0x7fff51cd04c0: 0,0
0x7fff51cd04d0: 1372390648,32767

---

In any case, I'm not sure why you wouldn't just declare the variable normally and use &v everywhere you need something "pointer-like" (for instance, in functions that require a pointer as an argument).