创建 boost::shared_ptr 的深层副本

Question

I have two vectors of shared_ptr;

typedef boost::shared_ptr <A> someptr;
std::vector<someptr>src;
std::vector<someptr>dest;

If I copy using dest=src,both the vector elements are sharing the same memory location which increases the ref count of pointer.They both point to common location and any change in elements of one vector will affect the other.I understood that this is a shallow copy and it is the intended behaviour.

But if I want to create a deep copy for dest vector elements with different memory location,what should I do?How to achieve this?

Does boost have a function to achieve this?

Answer 1

Sure. Simplest:

#include <vector>
#include <memory>

struct T {};

int main() {
    std::vector<T> a{100};
    auto b = a; // deep copy all T
}

Of course, there will be a reason why you had the shared_ptr . Eg when the objects aren't movable and/or runtime polymorphic.

---

Enter Pointer Container

Boost Pointer Container satisfies this need. It allows you to customize the way in which elements should be cloned (see eg How does boost::ptr_vector deep copy the underlying objects? or the docs ).

Simple example: Live On Coliru

#include <vector>
#include <memory>
#include <boost/ptr_container/ptr_vector.hpp>
#include <iostream>

struct Base {
  virtual ~Base() = default; // runtime polymorphic
  virtual char const* foo() const = 0;
};

struct T : Base {
  virtual char const* foo() const override { return "T"; }
};
struct U : Base {
  virtual char const* foo() const override { return "U"; }
};

static inline Base* new_clone(Base const& obj) {
    if (auto* p = dynamic_cast<T const*>(&obj))
        return new T{*p};
    if (auto* p = dynamic_cast<U const*>(&obj))
        return new U{*p};
    return nullptr;
}

int main() {
    boost::ptr_vector<Base> a;
    std::generate_n(std::back_inserter(a), 5, [] { return new T{}; });
    // polymorphic
    a.insert(a.begin()+2, new U{});

    auto b = a; // deep copy all elements, derived from Base

    // not sharing the instances:
    assert(&a.front() != &b.front());

    std::cout << "\na:";
    for (auto& el : a) std::cout << " " << el.foo(); 

    std::cout << "\nb:";
    for (auto& el : b) std::cout << " " << el.foo(); 
}

Prints

a: T T U T T T
b: T T U T T T

---

std::vector<unique_ptr>

This is conceptually similar, but requires more work by you:

Live On Coliru

#include <algorithm>
#include <vector>
#include <memory>
#include <iostream>
#include <cassert>

struct Base {
  virtual ~Base() = default; // runtime polymorphic
  virtual char const* foo() const = 0;
};

struct T : Base {
  virtual char const* foo() const override { return "T"; }
};
struct U : Base {
  virtual char const* foo() const override { return "U"; }
};

struct Cloner {
    using Ptr = std::unique_ptr<Base>;
    Ptr operator()(Ptr const& pb) const {
        if (auto* p = dynamic_cast<T const*>(pb.get()))
            return std::make_unique<T>(*p);
        if (auto* p = dynamic_cast<U const*>(pb.get()))
            return std::make_unique<U>(*p);
        return nullptr;
    }
};

int main() {
    std::vector<std::unique_ptr<Base> > a;
    a.push_back(std::make_unique<T>());
    a.push_back(std::make_unique<U>());
    a.push_back(std::make_unique<T>());

    std::vector<std::unique_ptr<Base> > b;

    // deep copy all elements, derived from Base
    Cloner clone;
    std::transform(begin(a), end(a), back_inserter(b), clone);

    // not sharing the instances:
    assert(&*a.front() != &*b.front());

    std::cout << "\na:";
    for (auto& p : a) std::cout << " " << p->foo(); 

    std::cout << "\nb:";
    for (auto& p : b) std::cout << " " << p->foo(); 
}

Prints:

a: T U T
b: T U T

vector<unique_ptr> but "easier"?

If you like you can use some "magic" to make that simpler:

• Using Boost Range

  Live On Coliru

   // deep copy all elements, derived from Base auto b = boost::copy_range<upvec>(a | transformed(Cloner{}));

• Using standard ranges (c++20)

  Using Ranges v3 instead because to_vector hasn't been standardized (yet)

  Live On Compiler Explorer

   // deep copy all elements, derived from Base auto b = ranges::to_vector(a | ranges::views::transform(Cloner{}));

---

Fully automatic: Boost PolyContainer

This doesn't retain order, but it has the advantage that you don't have to come up with the cloning logic, and you can do smart iteration by type etc.:

Live On Coliru

#include <boost/poly_collection/base_collection.hpp>
#include <memory>
#include <iostream>
#include <cassert>

struct Base {
  virtual ~Base() = default; // runtime polymorphic
  virtual char const* foo() const = 0;
};

struct T : Base {
  virtual char const* foo() const override { return "T"; }
};
struct U : Base {
  virtual char const* foo() const override { return "U"; }
};

int main() {
    using C = boost::poly_collection::base_collection<Base>;
    
    C a;
    a.insert(T{});
    a.insert(U{});
    a.insert(T{});

    // deep copy all elements, derived from Base
    auto b = a;

    // not sharing the instances:
    assert(&*a.begin() != &*b.begin());

    std::cout << "\na:";
    for (auto& p : a) std::cout << " " << p.foo(); 

    std::cout << "\nb:";
    for (auto& p : b) std::cout << " " << p.foo(); 
}

Prints

a: U T T
b: U T T