Initializing std::shared_ptr with std::make_shared having an std::array as argument

Question

I do not understand why this works fine:

std::array<double, 2> someArray = {0,1};
std::shared_ptr<MyClass> myobj = std::make_shared<MyClass>(someArray);

But this does not work:

std::shared_ptr<MyClass> myobj = std::make_shared<MyClass>({0,1});

Compiler says:

too many arguments to function ‘std::shared_ptr< _Tp> std::make_shared(_Args&& ...)
...
candidate expects 1 argument, 0 provided

Question: Can someone clarify why this happens and if there is any way I can fix the second approach without defining an extra variable?

Edit: Example of MyClass:

#include <memory> //For std::shared_ptr
#include <array>
#include <iostream>

class MyClass{
  public:
    MyClass(std::array<double, 2> ){
      std::cout << "hi" << std::endl;
    };
};

What is MyClass?

Oblivion
– Oblivion

2019-09-27 16:27:06 +00:00
Commented Sep 27, 2019 at 16:27 — Oblivion
– Oblivion, Commented Sep 27, 2019 at 16:27
... and what does its constructors look like?

Ted Lyngmo
– Ted Lyngmo

2019-09-27 16:27:37 +00:00
Commented Sep 27, 2019 at 16:27 — Ted Lyngmo
– Ted Lyngmo, Commented Sep 27, 2019 at 16:27

fdan · Accepted Answer · 2019-09-27 16:47:51Z

5

Braced initializers {} can never be deduced to a type (in a template context). A special case is auto, where it is deduced to std::initializer_list. You always have to explictly define the type.

auto myobj = std::make_shared<MyClass>(std::array<double, 2>{0, 1});

edited Sep 27, 2019 at 16:47

answered Sep 27, 2019 at 16:45

fdan

1,9697 silver badges21 bronze badges

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

1 Comment

Ted Lyngmo Over a year ago

auto myobj = std::make_shared<MyClass>(std::array{0., 1.}); would be fine too.

Alecto · Accepted Answer · 2019-09-27 16:52:59Z

-1

The type of {0, 0} is context-dependent. If {0, 0} is being used to immediately construct another object of known type, then it represents a prvalue of that object type:

MyClass m({0, 0});

Here, {0, 0} refers to a prvalue of type std::array<double, 2> On the other hand, if there are no constraints on the type, then {0, 0} refers to an initializer list of type std::initializer_list<int>:

auto vals = {0, 0};

There's no way to initialize MyClass from std::initializer_list<int>, so make_shared fails to compile:

MyClass m(vals); // Fails: can't construct MyClass from initializer list

How does this connect to std::make_shared? Because std::make_shared is a template, {0, 0} isn't being used to construct a specific type. As a result, it's treated as a std::initializer_list.

answered Sep 27, 2019 at 16:52

Alecto

10.9k1 gold badge32 silver badges53 bronze badges

3 Comments

NathanOliver Over a year ago

This is not correct. {0, 0} is only a std::initializer_list<int> when used with auto. Without it has no type

Alecto Over a year ago

Isn’t it also a std::initiaizer_list when passed to a templated function?

NathanOliver Over a year ago

No. A special rule was added for auto so it could work (still not sure if I like that or not). No rule was put in place for template deduction.

Collectives™ on Stack Overflow

Initializing std::shared_ptr with std::make_shared having an std::array as argument

2 Answers 2

1 Comment

3 Comments

Your Answer

Hot Network Questions

Collectives™ on Stack Overflow

2 Answers 2

1 Comment

3 Comments

Your Answer

Sign up or log in

Post as a guest

Related