How should I initialise a shared-pointer member?

I can initialize a std::shared_ptr member in 2 different ways in my constructor (which both increment its use_count):

1. Pass by reference:

   class MyClass {
       std::shared_ptr<std::string> s1;
   public:
       MyClass(std::shared_ptr<std::string>& s2): s1{s2} {}
   };
   

2. Pass by value

   class MyClass2 {
       std::shared_ptr<std::string> s1;
   public:
       MyClass2(std::shared_ptr<std::string> s2): s1{std::move(s2)} {}
   };
   

Test program:

int main() {
    std::shared_ptr<std::string> s2 = std::make_shared<std::string>("Hello World");
    MyClass myClass {s2};
    MyClass2 myClass2 {s2};
    
    std::cout << "Use count:" << s2.use_count() << std::endl;
        
    return 0;
}

Result:

Use count:3

I don't see any advantage of the 2nd way over the 1st way.
I think the 2nd way should never be used because there is an extra move operation.

Which way do you think is better to initialise a std::shared_ptr, in terms of performance?

Updated

I can update MyClass according to below so it can be called like:
MyClass myClass {std::make_shared<std::string>("Hello World")};

class MyClass {
    std::shared_ptr<std::string> s1;
public:
    MyClass(const std::shared_ptr<std::string>& s2): s1{s2} {}
};

Performance I guess makes a difference in too many loops.

Benchmark

#include <iostream>
#include <memory>
#include <chrono>

using namespace std;

class MyClass {
    std::shared_ptr<std::string> s1;
public:
    MyClass(const std::shared_ptr<std::string>& s2): s1{s2} {}
};

class MyClass2 {
    std::shared_ptr<std::string> s1;
public:
    MyClass2(std::shared_ptr<std::string> s2): s1{std::move(s2)} {}
};


int main() {
    std::shared_ptr<std::string> s2 = std::make_shared<std::string>("Hello Wolrd");
    
    auto start = std::chrono::high_resolution_clock::now();
    
    for (int i = 0; i < 10000000; i++) {
        MyClass myClass {s2};
    }    
    auto end = std::chrono::high_resolution_clock::now();
    
    std::chrono::duration<float> duration = end - start;
    std::cout << duration.count() << std::endl;
    
    
    
    start = std::chrono::high_resolution_clock::now();
    
    for (int i = 0; i < 10000000; i++) {
        MyClass2 myClass2 {s2};
    }    
    end = std::chrono::high_resolution_clock::now();
    
    duration = end - start;
    std::cout << duration.count() << std::endl;    
        
    return 0;
}

Online c++ compiler and c++17

0.358915
0.623789

The first way requires at least one copy of the shared_ptr (from s2 to s1), regardless of what the calling function does, which requires grabbing locks, incrementing and decrementing the reference count, and other overhead.
Also, since the first version requires a shared_ptr&, then if the calling function has a temporary shared_ptr&&, then they're forced to store it in a variable before constructing the class:

    std::shared_ptr<std::string> s2 = std::make_shared<std::string>("Hello World");
    MyClass myClass {s2};

The second way allows the caller to move a shared_ptr value into the constructor, which is then moved directly into s1. Move operations are cheaper: they do not require locks, and they do not increment or decrement the reference count. They're insanely fast. Also, since the second one just takes a value, it can be constructed in any way, and therefore can be constructed directly from temporaries:

    MyClass myClass {std::make_shared<std::string>("Hello World")};

So the second way is superior in every way.

In my tests that mirror your tests, the move version is ~10% faster.
https://quick-bench.com/q/P3pX-bC8kRXSEmqJw2_KSz-kc0s