有没有一种声明和初始化指针变量的方法？

Question

When I need to create a pointer variable, I currently use the following approach which works:

int getIntPointer()
{
    int * intPointer = new int;
    *intPointer = 0;

     return *intPointer;
}

likewise, when returning such a pointer from another function I would use something like this in main() to use it:

int main()
{
    int * intPointer = new int;
    *intPointer = getIntPointer();

    delete intPointer;
 }

This all works, but for readability and efficiency I'd like to know is if there are one line equivalents. (and I don't mean to just put them on the same line. I mean a short hand approach.)

Also: In this above example, I used the same pointer variable in both functions, and it works. Are they the same pointer in memory? Adding something like:

delete intPointer; 

Immediately after the return statement doesn't crash the program, but does it even get there? Or is it safe to just delete it's passed iteration in main when no longer needed?

Answer 1

You could do:

int *intPointer = new int(0); 

(or new int(100); if you want intPointer to point at the value 100).

And of course, you could shorten that to :

return new int(0);

assuming you don't need to do anything else with the pointer.

Note that:

int * intPointer = new int;
*intPointer = getIntPointer();

is incorrect. Either you mean:

int * intPointer = new int;
intPointer = getIntPointer();

in which case it's a memory leak, because you are overwriting intPointer from new with the one created by the call.

Or you mean to write:

int * intPointer = new int;
*intPointer = *getIntPointer();

in which case there is a memory leak because getIntPointer called new and you "lost" that pointer by not saving the return value.

For EVERY new you call, you should have exactly one corresponding delete , or it is a memory leak. Since both of my examples above does NOT provide that, because both cases will lose one of the pointers returned from new , this is incorrect.

In general, it is best to NOT use "raw pointers", and instead use either std::unique_ptr (if you only ever expect the pointer to "live" in one place at a time) or std::shared_ptr (if you expect multiple objects to have a copy of the pointer).

Edit: My answer above assumes that getIntPointer actually does what the name describes, rather than what the code in the question does, which is rather poor design: allocate memory and then return the pointed-to value.

Answer 2

I could be wrong, but I think you're reaching for std::shared_ptr and its helper function std::make_shared .

std::shared_ptr< int > intPointer = std::make_shared< int >( 42 );

Rather than repeat all the use cases of smart pointers here, I'll simply link to an answer that goes into more detail on the topic.

inb4 rants about why smart pointers are good or bad.