std::shared_ptr or std::unique_ptr assignment operator overloads

Question

I don't see a reason why these don't have an assignment operator overload for plain old pointers of the type they're templated to. If the goal of making smart pointers interface as close to plain old pointers as they could, then why didn't they make an overload for the assignment operator like this?

inline std::shared_ptr<type> &operator=( const type * pointer)
{
    reset(a);
}

this way you could use them just like you would a normal pointer, like so:

std::shared_ptr<int> test = new int;

it's not an issue at all, just wondering why they went to the trouble of just overloading a couple of operators.

Also wondering if there's a way to overload the global assignment operator to do this, or if there's any reason i shouldn't.

edit: adding a response to Nawaz about his answer here for code formatting. I just wrote this test program to see if what you were saying was right:

template<class T>
class peh
{
public:
    peh() {meh = 3;}
    const peh<T> & operator=(const int * peh)
    {
    }
};

void f( peh<int> teh)
{

}

int main()
{
    int * meh = new int;

    f(meh);

    system("PAUSE");
    return 0;
}

this here errors out saying there is no usable conversion from peh<int> to int *. so why is it acceptable with std::shared_ptr<int> to int *?

There is no global assignment operator. The assignment operator can only be overloaded as a member function. — Benjamin Lindley
– Benjamin Lindley, Commented Jul 1, 2012 at 15:54
@BenjaminLindley: I think he was talking about why it is not a member function, as he wants to write std::shared_ptr<int> test = new int;. — Sarfaraz Nawaz
– Sarfaraz Nawaz, Commented Jul 1, 2012 at 15:59
Also, overloading the assignment operator would not allow the construction std::shared_ptr<int> test = new int;, that requires an implicit constructor. It would allow std::shared_ptr<int> test; test = new int; — Benjamin Lindley
– Benjamin Lindley, Commented Jul 1, 2012 at 16:03

Sarfaraz Nawaz · Accepted Answer · 2012-07-01 16:27:27Z

5

Also wondering if there's a way to overload the global assignment operator to do this, or if there's any reason i shouldn't.

No. Assignment operator overload must a member function.

By the way, if you want the following functionality, then you should not talk about assignment operator, you should rather ask : why the constructor which takes raw pointer as argument is made explicit? why it is not implicit?

//this code requires an implicit constructor, not assignment!
std::shared_ptr<int> test = new int;  //illegal

It is illegal, but suppose for a while that this was allowed, then you would be able to call the following function passing a raw pointer as argument : such a feature would be dangerous, as the rest of the answer explains (read the comments) :

void f(std::shared_ptr<int> test)
{
     //code

} //test will be destructed here  (when it goes out of scope)
  //if test.use_count() == 1, then the pointer which it manages 
  //will be destructed as well. (NOTE THIS POINT)

Now see the dangerous part:

int *ptr = new int;

f(ptr); 
//note that calling f is allowed if it is allowed:
//std::shared_ptr<int> test = new int;
//it is as if ptr is assigned to the parameter:
//std::shared_ptr<int> test = ptr;

//Question : now what happened in f()?
//Answer : inside f(), test (the shared_ptr) will infer that no one else
//refers to the pointer it contains, because test.use_count() == 1
//test is obviously wrong in this case, because it cannot prove that!

//DANGER
*ptr = 10; //undefined behavior, because ptr is deleted by the shared_ptr

Please read the comments. It explains each part of the code snippet above.

edited Jul 1, 2012 at 16:27

answered Jul 1, 2012 at 15:41

Sarfaraz Nawaz

363k121 gold badges682 silver badges867 bronze badges

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

7 Comments

FatalCatharsis Over a year ago

why wouldn't that call to void f() error? std::share_ptr<int> and int * are entirely different types.

Sarfaraz Nawaz Over a year ago

@FatalCatharsis: Because it is allowed, if std::shared_ptr<int> test = new int; is allowed.

FatalCatharsis Over a year ago

@Nawaz: added a response comment in my main question.

Martin Bonner supports Monica Over a year ago

Nawaz: It's worse than that. It would also fail (in exactly the same way), if the function is declared void f(const std::shared_ptr<int>& test).

Sarfaraz Nawaz Over a year ago

@MartinBonner: I didn't understand your comment. What is worse than what?

|

bames53 · Accepted Answer · 2012-07-01 16:27:28Z

2

The operator= you show would not actually enabled the syntax you want. shared_ptr<int> p = new int; would use shared_ptr's constructor from T* and shared_ptr's copy constructor. shared_ptr has both of these, but your syntax does not work because the constructor from T* is explicit.

The reason for this is because if that construction, std::shared_ptr<int> test = new int;, could be done implicitly it would mean that a shared_ptr could take ownership of a pointer without anyone ever explicitly asking it to. Nawaz shows one reason this would be really error prone; you'd have to be really careful that a pointer you're using isn't suddenly adopted by a shared_ptr somewhere without your knowledge, and then destroyed out from under you.

Here's an example that shows this dangerous implicit construction:

#include <iostream>

template<typename T>
struct owning_pointer {
    T *t;
    owning_pointer(T *t) : t{t} {}
    ~owning_pointer() {
        std::cout << t << " deleted\n";
        delete t;
    }
};

void foo(owning_pointer<int> thief) {}

int main() {
    int *i = new int;
    std::cout << i << " allocated\n";
    foo(i);
}

The output will be something like:

0x10d400880 allocated
0x10d400880 deleted

And see the error you get when you add explicit to owning_ptr's constructor. I get:

main.cpp:18:5: error: no matching function for call to 'foo'
    foo(i);
    ^~~
main.cpp:13:6: note: candidate function not viable: no known conversion from 'int *' to 'owning_pointer<int>' for 1st argument;
void foo(owning_pointer<int> thief) {}
     ^

Also it's unnecessary to allow implicit construction from T* since there are already some perfectly simple ways to allocate without the same potential for errors:

std::shared_ptr<int> test(new int); // one extra character isn't a hardship. I typically prefer () construction anyway.
std::shared_ptr<int> test{new int}; // although I might start preferring {} construction in C++11
auto test = std::make_shared<int>(); // this is slightly different in that the allocated int is zero-initialized

If you're initializing a member shared_ptr then you can initialize it in the initializer list instead of using assignment or reset() in the body of the constructor:

struct foo {
    std::shared_ptr<int> m_meh;
    foo()
      : m_meh(new int)
    {
        // no need for m_meh.reset(new int) here
    }
};

What operator= would enable is this:

shared_ptr<int> s;
s = new int;

This doesn't seem quite as error prone as implicit construction of shared_ptr from T*, but I can't see that there's really any value to it either.

edited Jul 1, 2012 at 16:27

answered Jul 1, 2012 at 16:04

bames53

88.7k15 gold badges191 silver badges255 bronze badges

6 Comments

FatalCatharsis Over a year ago

i actually normall construct my pointers like that, it was actually when it was split up between declaring and definition, that made me want to do this. when i used to declare a member pointer in a class(int * m_meh), i would define in the constuctor like m_meh = new int; , you have to declare you smart pointer (std::shared_ptr<int> m_meh) and then in the constructor call reset (m_meh.reset(new int); and i guess that syntax was just kinda rubbing me the wrong way. definition without using the assignment operator. BUT, it all works the same i guess. i was just curious.

Sarfaraz Nawaz Over a year ago

bames53 : Even s = new int is error prone. You might easily write s = ptr. And s might destroy the underlying pointer when it goes out of scope, and you might still use ptr.

bames53 Over a year ago

@Nawaz yes, but that's not anywhere near as bad as having a shared_ptr you don't even know exists take ownership. Here you at least have to mention the shared_ptr whereas with implicit construction some API you're using might change to a shared_ptr and you'd never know.

bames53 Over a year ago

@FatalCatharsis I added an example of initializing a member shared_ptr for you: it uses the initializer list instead of reset() in the constructor's body.

Sarfaraz Nawaz Over a year ago

@bames53: Hmm.. that makes perfect sense. It is not that error prone, but still is, to a lesser degree. The idea of implicit conversion (or something equivalent) is bad in most cases, which is why the library provides explicit function reset to do that. s.reset(ptr) appears explicit, and could be thought of as : here you take my onwership from now on".

|

Collectives™ on Stack Overflow

std::shared_ptr or std::unique_ptr assignment operator overloads

2 Answers 2

7 Comments

6 Comments

Your Answer

Hot Network Questions

Collectives™ on Stack Overflow

2 Answers 2

7 Comments

6 Comments

Your Answer

Sign up or log in

Post as a guest

Related