What strategy should be used when trying to point to automatic objects?

Question

I am developing a relatively large library (~13000 lines) as a personal utility library. It uses exclusively STL containers and smart pointers for memory management - but now I find myself in a situation where I could see going for normal pointers due to an apparent lack of an obvious solution in STL. I would like to maintain a modern C++ style, though.

Here's my mcve:

Struct Foo - a int-wrapper struct displaying which member functions were called.

struct Foo {
    Foo(int x) {
        this->x = x;
        std::cout << "constructor\n";
    }
    Foo(const Foo& other) {
        this->x = other.x;
        std::cout << "copy constructor\n";
    }
    ~Foo() {
        std::cout << "destructor\n";
    }

    int x;
};

Looking at main I create an automatic instance of struct Foo:

int main() {
    Foo foo{ 0 };
    std::cout << "\nfoo.x : " << foo.x << "\n\n";    
}

output >

constructor

foo.x : 0

destructor

Easy as that. - now if I want to point to foo and manipulate its content.

---

Smart pointers like std::unique_ptr or std::shared_ptr won't achieve this effect (apparently!). Using std::make_unique<T>() (/ std::make_shared<T>()) will dynamically allocate memory and only copy the value:

Foo foo{ 0 };
std::unique_ptr<Foo> ptr = std::make_unique<Foo>(foo);

ptr->x = 2;

std::cout << "\nptr->x : " << ptr->x << '\n';
std::cout << "foo.x  : " << foo.x << "\n\n";

output >

constructor
copy constructor

ptr->x : 2
foo.x  : 0 // didn't change  

destructor
destructor

So that's not working. However, their void reset(pointer _Ptr = pointer()) noexcept member function allows to directly assign a pointer:

std::unique_ptr<Foo> ptr;
Foo foo{ 0 };

ptr.reset(&foo);

ptr->x = 2;

std::cout << "\nptr->x : " << ptr->x << '\n';
std::cout << "foo.x  : " << foo.x << "\n\n";

output >

constructor

ptr->x : 2
foo.x  : 2

destructor
destructor //crash

But crash! foo get's deconstructed normally and than std::shared_ptr also wants to deconstruct its already deconstructed dereferenced value.

HEAP[main.exe]: Invalid address specified to RtlValidateHeap(...)

---

Using a const pointer:

Foo foo{ 0 };
Foo* const ptr = &foo;

ptr->x = 2;

std::cout << "\nptr->x : " << ptr->x << '\n';
std::cout << "foo.x  : " << foo.x << "\n\n";

output >

constructor

ptr->x : 2
foo.x  : 2

deconstructor

• 1 allocation, 1 deallocation.
• no copying.
• actually manipulating the value.

So far the pointer feels like the best option.

---

I am just looking for a way to point to automatically allocated objects. So far it seems surprisingly difficult without going back to plain pointers.

I provided one solution by myself - which is using /*const*/ std::reference_wrapper<T>. (feel free to correct me about this solution)

But I am not sure what's the best strategy. The pointer? the std::reference_wrapper maybe? Did I made a mistake with using std::shared_ptr / std::unique_ptr?

Is there a better, more straightforward STL class?

Answer 1

Hedging my bets a little on this one, as your goal is unclear.

---

If you want to pass resources around strongly, in a manner that makes ownership and lifetime clear, then a smart pointer is the appropriate way to do that. The standard library already provides them, so just use them.

You've discovered already that this is largely incompatible with objects of automatic storage duration (what you've called "on the stack"). You can work around it with a custom no-op deleter, but honestly why? You're just making life way too complicated for yourself. When you create objects in this manner, the ownership and lifetime are chosen for you, and easy to get wrong (dangling pointers, folks!).

Just have std::make_unique or std::make_shared dynamically allocate your Foos for you, and use the resulting smart pointer in the usual manner.

---

However, obviously we cannot see your design, nor do we know much about it.

If all you need to do is pass references to objects to functions, which will do a thing then return, then simply do that!

void bar(const Foo& foo)
{
    // do stuff
}

int main()
{
   Foo foo;
   bar(foo);
}

Answer 2

But I am not sure what's the best strategy. The pointer?

Possibly. If you need to point at an object, then pointer can be a good choice.

Reference might be another:

Foo foo{ 0 };
Foo& ref = foo;
ref = 2;

If a reference is sufficient, then it's usually preferable to a pointer.

Did I made a mistake with using std::shared_ptr / std::unique_ptr?

Yes. You took ownership of an automatic variable. That's a no-no.

In the first example you made a copy of an object, expecting modification of the copy to affect the original.

Answer 3

std::reference_wrapper:

Foo foo{ 0 };
std::reference_wrapper<Foo> ref = foo;

ref.get().x = 2;

std::cout << "\nref.x : " << ref.get().x << '\n';
std::cout << "foo.x : " << foo.x << "\n\n";

output >

constructor

ref.x : 2
foo.x : 2

deconstructor

Which behaves just like a pointer. Well, looking at it's implementation it is a pointer:

template<class _Ty>
    class reference_wrapper
        : public _Weak_types<_Ty>::type
    {
public:
    /*...*/
private:
    _Ty * _Ptr; //<---
    };

For a pointer const effect (Foo* const) it can be declared as a const std::reference_wrapper<Foo> - disallowing any change of its pointer address.

Foo foo{ 0 };
const std::reference_wrapper<Foo> ref = foo;
Foo foo2{ 2 };
ref = foo2; //error

Error C2678 binary '=': no operator found which takes a left-hand operand of type 'const std::reference_wrapper' (or there is no acceptable conversion)