Is there a way to prevent assignment of pointers?

Question

A tricky question. If would like to write a function that returns a pointer to some IFoo object, is it possible to prevent the assignment of this pointer? I do not want to make IFoo a singleton and I can hide or delete the copy and assignment operators, but does C++ actually allow a pattern, where I explicitly have to call somebody else to obtain an object?

The background question is: I am thinking about some sort of dependency container, where you should always ask the container to get some IFoo * (pointer for the sake of polymorphism). The user should never be able to save it to some local variable or member to avoid a stalled reference to it. (For scenarios where the container is instructed to return no longer Foo, which is derived from IFoo but Bar)

Edit for clarification, although user R Sahu already said that is not possible. Indeed the example of Mark B was a perfect illustration of what I wanted to prevent:

IFoo* foo_ptr_I_will_keep_forever = obj->getIFoo();

When I wouldn't have interfaces but only explicit instance of types I could return a reference, which given a private operator= and copy ctor would suffice.

I'm having a little trouble grasping your precise question. Are you asking if there's a way to prevent a user from saying IFoo* foo_ptr_I_will_keep_forever = obj->getIFoo();? A short example might clarify your question. — Mark B
– Mark B, Commented Apr 3, 2017 at 15:06
Are you talking about a pointer to a read-only object and not allowing clients to write to the object? — Thomas Matthews
– Thomas Matthews, Commented Apr 3, 2017 at 16:33
@MarkB Added an example, actually exactly your example with some explanation, as it was spot-on — Samuel
– Samuel, Commented Apr 4, 2017 at 5:36
In terms of implementation, this sounds quite a bit like the Proxy design pattern. Some references here: Proxy pattern and here: Proxy Design Pattern. — Phil Brubaker
– Phil Brubaker, Commented Apr 5, 2017 at 17:48

R Sahu · Accepted Answer · 2017-04-03 15:30:14Z

Your title says:

Is there a way to prevent assignment of pointers?

No, you can't prevent that if your function returns a pointer.

However, if you return a handle, which can be a pointer to a type that is only forward declared or an integral value that can be used to come up the real object, and make sure that all the real functionality works with the handle, then you can have more freedom over when you can delete the real object without the risk of leaving the client code with a dangling pointer.

Here's a simple program that demonstrates the concept.

#include <iostream> #include <set> // Foo.h struct Foo; using FooHandle = Foo*; FooHandle createFoo(); void fooFunction1(FooHandle h); void fooFunction2(FooHandle h); // Test Program int main() { FooHandle h = createFoo(); fooFunction1(h); fooFunction2(h); fooFunction1(h); return 0; } // Foo implementation. namespace FooImpl { std::set<Foo*>& getLiveFooObjects() { static std::set<Foo*> liveObjects; return liveObjects; } bool isValid(Foo* h) { return (getLiveFooObjects().find(h) != getLiveFooObjects().end()); } } using namespace FooImpl; struct Foo {}; FooHandle createFoo() { FooHandle h = new Foo{}; getLiveFooObjects().insert(h); return h; } void fooFunction1(FooHandle h) { if ( isValid(h) ) { std::cout << "In fooFunction1.\n"; } else { std::cout << "Ooops. The handle is no longer valid.\n"; } } void fooFunction2(FooHandle h) { std::cout << "In fooFunction2.\n"; delete h; getLiveFooObjects().erase(h); }

Output:

In fooFunction1. In fooFunction2. Ooops. The handle is no longer valid.

Not possible was all the information I wanted :) even though I personally does not like the handle solution as it shifts the using paradigm of that handle and makes it quite complex to use.

Lou Franco · Accepted Answer · 2017-04-03 15:08:11Z

Give them back an object (that they can store if they want) that always looks up the real one via private (friend) interfaces.

For example, an IFooCaller that implements IFoo by getting the current IFoo and forwarding all calls to it.

cdhowie · Accepted Answer · 2017-04-03 15:22:28Z

A middle ground answer that would prevent accidentally storing a pointer to a particular implementation, but wouldn't prevent someone from doing it on purpose:

template <typename T> class service_wrapper; class service_manager { template <typename T> friend class service_wrapper; public: template <typename T> service_wrapper<T> get() const; private: template <typename T> T* get_instance() const; }; template <typename T> class service_wrapper { friend class service_manager; public: T* operator->() const; private: service_wrapper(service_manager const & p_sm) : sm(p_sm) { } service_manager const & sm; }; template <typename T> T* service_wrapper<T>::operator->() const { return sm.get_instance<T>(); }

Your manager only dispenses instances of service_wrapper<T>. The operator-> implementation allows invoking on the service using wrapper->method(...);, and always fetches the implementation pointer from the service manager.

This can be circumvented like:

T *ptr = sm.get<T>().operator->();

But that's not something you can accidentally do.

Collectives™ on Stack Overflow

Is there a way to prevent assignment of pointers?

3 Answers 3

1 Comment

Comments

Comments

Hot Network Questions