using shared_ptr of a type of Class A as a member variable of class B

Question

Assume that my class B is something like this:

class B {
B (double d,double e)
private:
std::shared_ptr < class A > sp;
}

The Constructor from class A looks like:

A(double a, double b){...};

Now, I want to write the constructor function for my class B, in which an object from class A is constructed(initialized or assigned) using the constructor function written above. Can someone explain me how can i do it professionally? I tried something like below but i get errors like "term does not evaluate to a function taking 1 argument" and "an initializer list is unexpected in this context" ...

class B (double d, double e){
double a1 = d*2;
double b2=  e*2;
sp { std::make_shared<class A>(a1,b2) };

I'd appreciate to correct me either if i did typing mistake or if i misunderstood something conceptually(or any other explanation)
In general, why should we use make_shared? what are the other approaches and what are their pros and cons? Actually i don't understand if by private: std::shared_ptr < class A > sp; i already created the object by calling the default constructor of class A? So by make_shared i am creating another object?
How can i use the constructor initilizer list using : ? P.S According to one answer below, it seems that i cannot use the initializer list approach. Because the simple computation i wrote for a1 and b2 were only for showing my problem. My real computations are longer than that and I think i cannot use approaches like B (double d,double e): sp{std::make_shared<A>(d*2, e*2)} .

Thanks

Jason · Accepted Answer · 2022-05-15T11:18:19.947

1

How can i use the constructor initilizer list using :

If you want to initialize sp you can do it in the constructor initializer list as shown below, (and not inside the body of the constructor as you were doing):

//---------------------vvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvv-->constructor initializer list
B (double d,double e): sp{std::make_shared<A>(d*2, e*2)}
  {
      
  }

From std::make_shared's documentation:

template< class T, class... Args > shared_ptr<T> make_shared( Args&&... args );

std::make_shared is used to construct an object of type T and wraps it in a std::shared_ptr using args as the parameter list for the constructor of T.

(end quote)

The template parameter T in this case is A and thus std::make_shared is used to construct a std::shared_ptr<A> and initialize sp with it in the constructor initializer list.

Note that we can also use in-class initializer to initialize sp.

From How to create and use shared_ptr instance:

Whenever possible, use the make_shared function to create a shared_ptr when the memory resource is created for the first time. make_shared is exception-safe. It uses the same call to allocate the memory for the control block and the resource, which reduces the construction overhead. If you don't use make_shared, then you have to use an explicit new expression to create the object before you pass it to the shared_ptr constructor.

edited May 15 '22 at 11:18

answered May 15 '22 at 10:54

Jason

36,170
5
26
60

Thanks. But if i want to use the initializer list, where can i do the computations for my a1 and b2, which are going to be used for the construction later? You also wrote that i can use in-class initializer. I think it is what i was trying to do and i got the error. – Denis May 15 '22 at 11:07
@Denis I have updated the example in my answer. Check out my updated answer. In the updated answer, we are passing `d*2` and `e*2` to `A's` constructor which you wanted. Also, a [good C++ book](https://stackoverflow.com/questions/388242/the-definitive-c-book-guide-and-list) might be more useful. – Jason May 15 '22 at 11:14
Actually the simple `e*2` computations i wrote in my question were only example, which made the confusion. My real computation are longer than that. And it seems i cannot do them in the initializer list approach. And using in_class approach gives me the error i wrote in my question... – Denis May 15 '22 at 11:53
1

@Denis In C++, initialization and assignment are different things. In your original example you were using `sp { std::make_shared(a1,b2) };` which isn't valid syntax. Also, we can only answer according to the given information in the question which in this case is `e*2` and `d*2`. We cannot guess what actual code you're using. You can extend the method given in my answer and if done correctly it should work. Also, you can ask a separate follow up question and make sure to post the real computation on that question so that people don't get misled. – Jason May 15 '22 at 11:57
You are right about the confusion, and sorry for that. But i think my question is not that much unclear. I want to use in-class approach, to do what one can do with `sp { std::make_shared(a1,b2) }`. And you are right, since i misunderstood the concepts of construction, initialization and assignement, i formulated my question very bad. But thanks for your hints – Denis May 15 '22 at 12:13
1

@Denis Then you can use `sp = std::make_shared(d*2, e*2);` inside the constructor. Note that in the above statement i have removed the curly braces and added the `=` which means "assignment". And with this change the program will work. But again this is assignment. [Working demo](https://onlinegdb.com/KzplbkZXI). In the above linked demo, i have a comment saying "do your calculation here". – Jason May 15 '22 at 12:16

using shared_ptr of a type of Class A as a member variable of class B

1 Answers1