为什么我们需要传递 const 共享指针作为引用？

Question

While I was reading an open-source code, I found the following where a shared pointer is passed to a function in two different ways.

class A{A();};

typedef std::shared_ptr<A> A_Ptr;

void func1(A_Ptr a);

void func2( const A_Ptr& a);

What is the reason to pass it as a reference when const is used? I understand the writer of the func2 does not expect the function to be able to change anything in a. But can't we just do this const A_Ptr a ? Also, what are the reason we shouldn't pass it with A_Ptr & a in func1?

Occurance of the above in the code:

Git: https://github.com/uzh-rpg/rpg_svo/

List of FramePtr in the code

void FrameHandlerMono::setFirstFrame(const FramePtr& first_frame)

void DepthFilter::addFrame(FramePtr frame)

Answer 1

But can't we just do this const FramePtr frame?

Sure, we could, but then the copy constructor would be invoked, which is for larger types (anything larger than the built-in types) normally more expensive than passing by reference. This is nothing specific to shared_ptr . It should be generally your default to pass any objects by const reference if you don't need a copy and don't want to change them. Only built-in types like int, float, or char should be passed-by-value.

More interesting is why func1 uses a copy. Most probable case is that he needs a copy anyway, because he wants to keep a reference in the class. I couldn't find the exact file you're refering to in the github repository you've posted. If it's still unclear please past the function body of func1 into the question.

Edit: Ah, I see. Looks like the reason he passes-by-value here, has more to do with thread-safety. Didn't read the whole but otherwise the shared_ptr might be deleted by the owning thread if he passed by const reference.

Here for examle func needs pass-by-value cause otherwise the pointer could be deleted by the main thread. Probably something like this but more complicated:

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

using namespace std::chrono_literals;

struct S {
    S() {}
};

void
//This signature would be false
//func(std::shared_ptr<S> const& s)
func(std::shared_ptr<S> s)
{
    std::cout << s.use_count() << '\n';
    std::this_thread::sleep_for(2s);
    //use_count would be 0 here if we pass by reference
    std::cout << s.use_count() << '\n';
}



int
main(int argc, char**) {
    std::shared_ptr<S> s{std::make_shared<S>()};

    std::thread t{func, std::ref(s)};

    std::this_thread::sleep_for(1s);

    s.reset();

    t.join();

    return 0;
}