Move constructor for boost::property_tree::ptree

Question

I use boost::property_tree::ptree quite a bit, but I've found that I create, pass around, and then save copies too many times. With big ptree objects this is expensive.

Boost provides a swap function, but no move constructor. Why would they do that?

My current solution is to extend ptree and make one myself:

class MyPtree : public boost::property_tree::ptree
{
  MyPtree(MyPtree&& other)
  {
    swap(other);
  }

  ... plus adding the other constructors and operators
};

Is this the best solution or am I missing something?

"Why would they do that?" Because they've not updated it for C++11 — UKMonkey, May 31 '18 at 15:58

score 2 · Accepted Answer · answered May 31 '18 at 15:00

I think your solution is pretty decent. Note that it will never affect internal tree operations, as the tree will see its children as ptree, not MyPtree.

Slightly better is to propose the new feature and suggest it to de library devs.

Related is Is there a convenient way to erase a node from a property tree, preserving its child nodes?.

If you want to dig deeper, you'll find that Property Tree builds on Boost MultiIndex which, for various reasons, doesn't seemless allow moving from values: Move element from boost multi_index array

You could add a splice() operation building on the list-ness of the various indexes used:

For now, ptree could add a splice operation, which would naturally wrap multi_index's list operations: I just made a draft implementation sehe - Sep 23 '17 at 9:48

elarmando · Answer 2 · 2018-06-01T21:00:23.097

1

Stewart, I've seen the ptree destructor and it seems that it's not virtual. It means the base destructor (ptree) will not be invoked if MyPtree is used polymorphically. Maybe you should consider to use composition instead of inheritance. See this answer

This might be a sketch:

class MyPtree
{
   boost::property_tree::ptree m_tree;

   MyPtree(MyPtree&& other)
   {
      m_tree.swap(other.m_tree);
   }

  ... plus adding the other constructors and operators
};

edited Jun 01 '18 at 21:00

answered Jun 01 '18 at 14:53

elarmando

559
9
16

1

@JHBonarius i added a code sample, what do you think? – elarmando Jun 01 '18 at 16:22
It is often fine to derive from a class with a non-virtual destructor. You only get into trouble if the destructor of the derived class needs to do more than the one of the base, and you delete an object of the derived type using a pointer to the base class... – Marc Glisse Jun 01 '18 at 16:26
"It means the base destructor (ptree) will not be invoked when MyPtree is destroyed" this is complete nonsense. – T.C. Jun 01 '18 at 19:38

score 0 · Answer 3 · answered Aug 31 '18 at 13:03

use composition instead inheritance

class MyPtree
{
public:
  MyPtree():{m_tree_ptr = new boost::property_tree::ptree();
  MyPtree(MyPtree&& other){m_tree_ptr = other.m_tree_ptr; other.m_tree_ptr = nullptr;}
  ~MyPtree(){if (m_tree_ptr != nullptr) delete m_tree_ptr;}
  // copy conctructor and assign operator

private:
 boost::property_tree::ptree* m_tree_ptr;
};

Move constructor for boost::property_tree::ptree

3 Answers3