John Zwinck’s essential analysis is spot on: The bug is that you’re using shared_from_this() on an object which has no shared_ptr pointing to it. This violates a precondition of shared_from_this(), namely that at least one shared_ptr must already have been created (and still exist) pointing to this. However, his advice seems completely beside the point … Read more
I didn’t know how to do this either. But after poking around in here, the getting started, and trial and error: $ ./bootstrap –with-toolset=clang $ ./b2 clean $ ./b2 toolset=clang cxxflags=”-stdlib=libc++” linkflags=”-stdlib=libc++” You’ll get lots of warnings. And the signals library will fail to build due to LWG 2059. But otherwise I think it works.
Note that property_tree interprets the keys as paths, e.g. putting the pair “a.b”=”z” will create an {“a”:{“b”:”z”}} JSON, not an {“a.b”:”z”}. Otherwise, using property_tree is trivial. Here is a little example. #include <sstream> #include <map> #include <boost/property_tree/ptree.hpp> #include <boost/property_tree/json_parser.hpp> using boost::property_tree::ptree; using boost::property_tree::read_json; using boost::property_tree::write_json; void example() { // Write json. ptree pt; pt.put (“foo”, … Read more
You should Try pugixml Light-weight, simple and fast XML parser for C++ The nicest thing about pugixml is the XPath support, which TinyXML and RapidXML lack. Quoting RapidXML’s author “I would like to thank Arseny Kapoulkine for his work on pugixml, which was an inspiration for this project” and “5% – 30% faster than pugixml, … Read more
There are a couple of reasons to switch over to std::shared_ptr: You remove a dependency on Boost. Debuggers. Depending on your compiler and debugger, the debugger may be “smart” about std::shared_ptr and show the pointed to object directly, where it wouldn’t for say, boost’s implementation. At least in Visual Studio, std::shared_ptr looks like a plain … Read more
Simple Array: #include <boost/property_tree/ptree.hpp> using boost::property_tree::ptree; ptree pt; ptree children; ptree child1, child2, child3; child1.put(“”, 1); child2.put(“”, 2); child3.put(“”, 3); children.push_back(std::make_pair(“”, child1)); children.push_back(std::make_pair(“”, child2)); children.push_back(std::make_pair(“”, child3)); pt.add_child(“MyArray”, children); write_json(“test1.json”, pt); results in: { “MyArray”: [ “1”, “2”, “3” ] } Array over Objects: ptree pt; ptree children; ptree child1, child2, child3; child1.put(“childkeyA”, 1); child1.put(“childkeyB”, 2); … Read more
You should have a look at FindBoost.cmake script, which handles Boost detection and setting up all Boost variables. It typically resides in /usr/share/cmake-2.6/Modules/. In it, you will find documentation. For instance: # These last three variables are available also as environment variables: # # BOOST_ROOT or BOOSTROOT The preferred installation prefix for searching for # … Read more
Use boost::static_pointer_cast: boost::shared_ptr<Base> b(new Derived()); boost::shared_ptr<Derived> d = boost::static_pointer_cast<Derived>(b);
boost::bind has overloaded relational operators, std::bind does not. boost::bind supports non-default calling conventions, std::bind is not guaranteed to (standard library implementations may offer this as an extension). boost::bind provides a direct mechanism to allow one to prevent eager evaluation of nested bind expressions (boost::protect), std::bind does not. (That said, one can use boost::protect with std::bind … Read more
shared_ptr uses an extra “counter” object (aka. “shared count” or “control block”) to store the reference count. (BTW: that “counter” object also stores the deleter.) Every shared_ptr and weak_ptr contains a pointer to the actual pointee, and a second pointer to the “counter” object. To implement weak_ptr, the “counter” object stores two different counters: The … Read more