error when defining a std::shared_ptr with new operator

Question

I am trying to define a std::shared_ptr with new operator in the following way:

#include <memory>

struct A {
};

int main() {

  std::shared_ptr<A> ptr = new A();

  return 0;
}

but I obtained the following compile-time error:

main.cpp: In function 'int main()':

main.cpp:8:30: error: conversion from 'A*' to non-scalar type 'std::shared_ptr' requested std::shared_ptr ptr = new A();

Anyway, the following definitely works:

      std::shared_ptr<A> ptr{new A()};

Does anyone of you know why this happens?

Lightness Races in Orbit · Accepted Answer · 2016-10-10 12:17:44Z

7

tl;dr: it's a consequence of the relevant constructor being explicit.

When you initialise with =, you invoke copy-initialisation. C++ does not allow copy-initialisation of a shared_ptr from a raw pointer, because it would be too easy to end up with an accidental implicit conversion from some arbitrary raw pointer into a shared_ptr that doesn't actually manage it.

This way, the only way you can "ensnare" a raw pointer into a shared_ptr is very deliberately and very explicitly (as you have correctly done in your second example). Now, only in this initialiser do you have to remember not to do so with a pointer you're already managing elsewhere.

Is there anything actually dangerous about the specific line std::shared_ptr<A> ptr = new A()? No. But what you're seeing is a consequence of various C++ rules working together in concert.

answered Oct 10, 2016 at 12:17

Lightness Races in Orbit

387k77 gold badges670 silver badges1.1k bronze badges

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

Comments

Hayt · Accepted Answer · 2016-10-10 12:29:50Z

5

You can imagine your statement also as a 2 liner like this.

A* a = new A();
std::shared_ptr<A> ptr = a;

While in this case this may be correct in more complicated code it can lead to potential pitfalls so copy initialization is not allowed to a raw pointer.

Imagine

A* a = new A();
//.....
std::shared_ptr<A> ptr = a;
//.....
std::shared_ptr<A> ptr2 = a; //second ptr holding a... UB

Here you would have 2 shared pointers holding the same object which causes trouble.

To avoid those "implicit" errors C++ is not allowing this kind of initialization.

While you can still to the same with constructors but it is more "verbose" and harder to accidentally assign pointers.

std::shared_ptr<A> ptr{ new A() };

This looks more like constructing a new object and may not result in an mis-assignment by accident.

Also the preferred way to create a shared pointer in modern is

auto ptr = std::make_shared<A>();

edited Oct 10, 2016 at 12:29

answered Oct 10, 2016 at 12:21

Hayt

5,39032 silver badges37 bronze badges

2 Comments

Lightness Races in Orbit Over a year ago

No, that is not an assignment.

Hayt Over a year ago

@LightnessRacesinOrbit yeah you are right. I rephrased that part.

Collectives™ on Stack Overflow

error when defining a std::shared_ptr with new operator

2 Answers 2

Comments

2 Comments

Your Answer

Hot Network Questions

Collectives™ on Stack Overflow

2 Answers 2

Comments

2 Comments

Your Answer

Sign up or log in

Post as a guest

Related