Сохранение ссылки на объект в векторе

#include <functional>
#include <iostream>
#include <vector>
#include <memory>
#include <algorithm>
 
struct Test
{
    Test(int n) : n{n} {}
    int n; //magic number
    //over9000 parameters
};
 
typedef std::shared_ptr<Test> TestPtr;
 
 
struct TestFindHelper
{
    TestFindHelper(size_t idx, TestPtr ref) : idx{idx}, ref{ref} {}
    size_t idx;
    TestPtr ref;
};
 
 
struct BigDataContainer
{
    typedef std::vector<TestPtr> VecTestPtr;
    VecTestPtr bigData;
    std::vector<TestFindHelper> helpers;
    
    BigDataContainer() : bigData() {}
    //BigDataContainer() : bigData(5) {} //with it all works
    
    TestPtr addData(TestPtr& ptr, int n)
    {
        bigData.push_back(std::move(ptr));
        
        
        if(bigData.back()->n == 10)
            helpers.emplace_back(bigData.size() - 1, bigData.back());
            
        
        return findFirstMagicNumber(n);
        //do smth with find
    }
    
    TestPtr findFirstMagicNumber(int n)
    {
        auto lambda =
            [&n]
            (const TestFindHelper& h)
            {
                return h.ref.get()->n == n;
            };
        
        auto ret = std::find_if(helpers.begin(), helpers.end(), lambda);
        return *(bigData.begin() + ret->idx);
    }
};
 
int main()
{
    BigDataContainer c;
    TestPtr ptr1(new Test(10));
    TestPtr ptr2(new Test(20));
    auto it1 = c.addData(ptr1, 10);
    auto it2 = c.addData(ptr2, 10);
    std::cout << "it1: " << it1->n << "\n";
    std::cout << "it2: " << it2->n << "\n";
}

#include <iostream>
#include <memory>
#include <unordered_set>
#include <vector>
 
struct Test
{
    Test(int n_, int anotherData_) : n(n_), anotherData(anotherData_) {}
    int n;
    int anotherData;
};
 
using TestPtr = std::shared_ptr<Test>;
 
struct HashTest
{
    std::size_t operator()(const TestPtr &p) const
    {
        return std::hash<int>()(p->anotherData);
    }
};
 
struct CmpTest
{
    bool operator()(const TestPtr &lhs, const TestPtr &rhs) const
    {
        return lhs->anotherData == rhs->anotherData;
    }
};
 
struct BigDataContainer
{
    using DataContainer = std::vector<TestPtr>;
    using HelpersContainer = std::unordered_set<TestPtr, HashTest, CmpTest>;
 
    void addData(const TestPtr &t)
    {
        data.push_back(t);
        if (t->n == 10)
            helpers.insert(t);
    }
 
    TestPtr findTestByData(const int anotherData) const
    {
        const auto it = helpers.find(std::make_shared<Test>(10, anotherData));
        return it != helpers.end() ? *it : nullptr;
    }
 
    DataContainer data;
    HelpersContainer helpers;
};
 
int main()
{
    BigDataContainer bdc;
    bdc.addData(std::make_shared<Test>(10, 42));
    bdc.addData(std::make_shared<Test>(20, 12));
    bdc.addData(std::make_shared<Test>(10, 22));
    auto it = bdc.findTestByData(22);
    if (it)
        std::cout << it->n << " " << it->anotherData << std::endl;
}

#include <iostream>
#include <memory>
#include <unordered_map>
#include <vector>
 
struct Test
{
    Test(const int data_ = 0) : data(data_) {}
    int data;
};
 
using TestPtr = std::unique_ptr<Test>;
using VecTestPtr = std::vector<TestPtr>;
 
struct BigDataContainer
{
    using DataContainer = std::unordered_map<int, VecTestPtr>;
 
    void addData(const int n, TestPtr &&t)
    {
        data[n].push_back(std::move(t));
    }
 
    void printTest(const int n) const
    {
        const auto it = data.find(n);
        if (it != data.end())
            for (const auto &pTest : it->second)
                std::cout << pTest->data << " ";
    }
 
    DataContainer data;
};
 
int main()
{
    BigDataContainer bdc;
    bdc.addData(10, std::make_unique<Test>(42));
    bdc.addData(10, std::make_unique<Test>(22));
    bdc.printTest(11);
    bdc.printTest(10);
}