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 *?

Answer 1

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.