How to combine sql::driver with smart pointers?

Question

I am writing a class which is going to connect to a database. So I have a global variable std::shared_ptr<sql::Driver> driver; because I am trying to learn how to do everything with smart pointers. But this always ends up in an problem, with every smart pointer so far, beacuse the destructor of sql::Driver is protected. So call like driver.reset( ) Always end up in problems. How do I combine smart pointers with sql::Driver?

If the destructor of sql::Driver is protected, how are you supposed to delete it? How would you do it with plain pointers? — K-ballo
– K-ballo, Commented Jun 18, 2013 at 18:27
@Cheiron: If you would not delete it at all then you do not have ownership of the value it points to. If you do not have ownership, then what is the point of using a smart pointer that shares ownership? — K-ballo
– K-ballo, Commented Jun 18, 2013 at 18:47
@Cheiron: The error it is not in the code, it is in your understanding of it. — K-ballo
– K-ballo, Commented Jun 18, 2013 at 18:57
@Cheiron 'because I am trying to learn how to do everything with smart pointers' BTW this is a mindset pitfall, see also the Golden Hammer Antipattern. — πάντα ῥεῖ
– πάντα ῥεῖ, Commented Jun 18, 2013 at 19:16

Son-Huy Pham · Accepted Answer · 2013-06-18 18:58:00Z

2

In short, some classes are not intended to be managed by some external caller (i.e YOU).

Some classes are designed in a way where destruction occurs as a side effect:

void finished() {
  // Do something...
  delete this;
}

In other cases, these classes may be managed by some friend-class like an instance-manager or some sort. A protected destructor might imply that you'll need to extend that class to gain permission.

Along these lines, singleton classes cannot be instantiated nor stored in a smart pointer of any kind since the constructor is typically private;

class Singleton {
private:
  Singleton() {  //...
  }
};

These types of classes are not compatible with smart pointers since it does not allow for proper reference counting.

answered Jun 18, 2013 at 18:58

Son-Huy Pham

1,90918 silver badges19 bronze badges

Sign up to request clarification or add additional context in comments.

3 Comments

Cheiron Over a year ago

So.. Just use naked pointers, because nothing can go wrong anyway?

K-ballo Over a year ago

They are compatible with smart pointers. Not so sure that is a smart idea, though...

πάντα ῥεῖ Over a year ago

@Cheiron In case sql::Driver represents a singleton you can just use naked pointers, yes.

18446744073709551615 · Accepted Answer · 2015-12-01 14:08:16Z

2

The section Connector/C++ Connecting to MySQL says that you don't have to delete driver explicitly, this is why you get error: ‘virtual sql::Driver::~Driver()’ is protected. So the solution is to use a dumb pointer for driver instead of a smart one. (Only for driver!)

And Connection, Statement and ResultSet have no problems with smart pointers:

// a dumb pointer is used here intentionally, no need to delete it
sql::Driver* driver = get_driver_instance();
// shared_ptr also works
unique_ptr<sql::Connection> con( driver->connect("tcp://127.0.0.1:3306", "root", "root") );

Note that in Connector/C++ Complete Example 1 and Connector/C++ Complete Example 2 driver is not deleted.

edited Dec 1, 2015 at 14:08

answered Dec 1, 2015 at 14:00

18446744073709551615

17.1k4 gold badges102 silver badges135 bronze badges

Comments

K-ballo · Accepted Answer · 2013-06-18 18:54:56Z

What you are trying to do is just plain wrong. You mention that if you were using plain pointers, you wouldn't be calling delete at all. That, together with the fact that the destructor is protected, hints to the fact that you do not have ownership of the pointer value.

Since you do not have ownership, you have nothing to do with unique_ptr and/or shared_ptr, which deal with unique and shared ownership of the value pointed to.

If you insist on going on that route, and adding considerable overhead to keep reference counts on synchronization for something you do not even need, then you can do it. Both unique_ptr and shared_ptr can take a Deleter parameter. In your case, as you already mention, it would be a no-op.

struct noop_deleter
{
    void operator ()(void const* ptr) const { /*no-op*/ };
};

shared_ptr<sql::driver>{ driver_ptr, noop_deleter{} };
unique_ptr<sql::driver, noop_deleter>{ driver_ptr, noop_deleter{} };

metal · Accepted Answer · 2013-06-18 19:27:18Z

If it's protected, it is either meant to be inherited from or you're supposed to call a static Destroy() function (or similar) for destruction. For the former, you do something like:

class MyDriver : public sql::Driver
{
public:
    virtual ~MyDriver() {} // calls sql::Driver::~Driver() implicitly

    // ...
};

Perhaps some concrete classes in your SQL library fulfills this for you. In that case, look for how to use them.

For a destroy function, you use a custom deleter. Assuming something like this:

namespace sql
{
    class Driver
    {
    public:
        static Driver* Create(); // factory
        static void Destroy( Driver* );
        // ...
    protected:
        Driver();
        virtual ~Driver();
    };
}

you would do this:

std::shared_ptr<sql::Driver> driver( 
    sql::Driver::Create(), 
    sql::Driver::Destroy );

In general, however, your destructors should either be public and virtual or private and non-virtual.

A third option is that your sql::Driver is meant to be a singleton, though the dtor should still be private there unless it's designed for inheritance.

Collectives™ on Stack Overflow

How to combine sql::driver with smart pointers?

4 Answers 4

3 Comments

Comments

Comments

Comments

Your Answer

Hot Network Questions

Collectives™ on Stack Overflow

4 Answers 4

3 Comments

Comments

Comments

Comments

Your Answer

Sign up or log in

Post as a guest

Related