从函数返回共享指针与在 Lambda 中捕获共享指针

问：

我正在 a 中构造一个共享指针，并将其作为 lambda 的捕获。function_1

我认为这是一个问题，你能确认这是否安全还是我是对的，我不应该这样做？

#include <memory>
#include <future>
#include <iostream>
#include <vector>

using Op = std::function<double(std::size_t)>;
struct A
{
    std::shared_ptr<const std::vector<double>> function_1() const
    {
        const std::vector<double> v = {1.0, 2.0};
        auto pVec = std::make_shared<const std::vector<double>>(v);
        return pVec;
    };
};

struct B
{
    B() { m_a = A(); };
    
    void populate_op(Op& op) const
    {
        std::shared_ptr<const std::vector<double>> pVec = m_a.function_1();
        op = [pVec](const std::size_t index) -> double
        {
            return pVec->at(index);
        };
    }
    
    void run()
    {
        m_futures.resize(2u);
        Op op0;
        populate_op(op0);
        m_futures[0u] = std::async(std::launch::async, op0, 0u);
        
        Op op1;
        populate_op(op1);
        m_futures[1u] = std::async(std::launch::async, op1, 1u);
        
        const double res0 = m_futures[0u].get();
        const double res1 = m_futures[1u].get();
        
        std::cout << res0 + res1 << std::endl;
        //clean futures
    }
    
private:
    A m_a;
    mutable std::vector<std::future<double>> m_futures;
};

int main() {
    B b;
    b.run();
    return 0;
}

它不会被破坏，因为它是一个局部变量，我最终会得到一个移动的共享指针，指向一个被破坏的对象，从而在 lambda 中捕获后者？v