boost candy
DESCRIPTION
Boost Candy. A quick introduction to some libraries. Boost?. Collection of C++ libraries and a community Meant to establish best practice Reference implementations for future C++ standards Widely used, well tested, industrial strength code Portable. Smart pointers library. scoped_ptr - PowerPoint PPT PresentationTRANSCRIPT
Boost CandyA quick introduction to some libraries
Boost?• Collection of C++ libraries and a community• Meant to establish best practice• Reference implementations for future C++ standards• Widely used, well tested, industrial strength code• Portable
Smart pointers library• scoped_ptr• shared_ptr • weak_ptr• intrusive_ptr
scoped_ptr{boost::scoped_ptr<int> ptr(new int);...
}
class X {private:boost::scoped_ptr<SomeClass> iPtr;
};
boost::scoped_ptr<int> get_ptr (); // Illegal
shared_ptr
boost::shared_ptr<int> get_ptr ()
{
boost::shared_ptr<int> local_ptr(new int);
return local_ptr;
}
{
boost::shared_ptr<int> ptr;
ptr = get_ptr();
}
shared_ptr caveats
struct C
{
boost::shared_ptr<C> mNeighbour;
};
{
boost::shared_ptr<C> a(new C), b(new C);
a->mNeighbour = b;
b->mNeighbour = a;
}
shared_ptr caveats
Consider:
call(boost::shared_ptr<Foo>(new Foo(...)),
throwing_call())
shared_ptr caveats
Always use named variables:
boost::shared_ptr<Foo> foo(new Foo(...));
call(foo, throwing_call())
weak_ptrnamespace {weak_ptr<SomeClass> cache;
}
shared_ptr<SomeClass> cached_get(){shared_ptr<SomeClass> ptr = cache.lock();
if (!ptr){
ptr.reset(new SomeClass(...));cache = ptr;
}return ptr;
}
intrusive_ptr
Interface with libraries that uses internal reference counts
Smart pointersDon’t use shared_array and scoped_array
Use shared/scoped pointer to std::vector, boost::array
Full STL compliance
Smart pointers comparison boost::shared_ptr shared ownership
boost::weak_ptr break circular ownership, implement cache
boost::scoped_ptr RAII
boost::intrusive_ptr Interface 3rd party libraries
std::auto_ptr Sole, transferable ownership
boost::optional
Some functions only sometimes return a value
double sqrt(double n)
char get_async_input()
point polygon::get_any_point_effectively_inside()
boost::optional
Alternatives to cope with this:
• Required pre-condition and undefined behaviour• Throw exception• Special value (i.e. zero, inf)• Return std::pair<bool, return_value>
boost::optional approach
Single-element container, contain 0 or 1 element
boost::optional example
boost::optional<double> sqrt(double n)
{
boost::optional<double> result;
if (n >= 0) result = sqrt_helper(n);
return result;
}
boost::optional<double> root = sqrt(n);
if (root) std::cout << *root;
boost::optional exampleenum ChessPiece { WHITE_KING, BLACK_KING, …};
typedef std::vector< std::vector< boost::optional<ChessPiece> > >
ChessBoard;
ChessBoard board(…);
board.at(0).at(3) = WHITE_KING;
board.at(7).at(4) = BLACK_KING;
boost::optional approach
• Deep copy semanticscopies of the container implies copies of the value • Deep relational semanticscompare container size and if match, contained value
boost::optional benefits• Easy to read• Intuitive value semantics – principle of least astonishment• ==, !=, <, >, <=, >=
boost::assign purpose
Easy to fill containers
Both insert and initialize
boost::assign example
#include <boost/assign/std/vector.hpp> // For +=
using namespace boost::assign;
{
std::vector<int> values = (-2) (-1) (0);
values += 1,2,3,4,5,6,7,8,9;
}
boost::assign example
#include <boost/assign/map_list_of.hpp>
#include <boost/assign/list_inserter.hpp>
namespace boost::assign = ba;
{
std::map<int, std::string> mapping
= ba::map_list_of (1, ”one”) (2, ”two”);
ba::insert(mapping) (3, ”three”) (4, ”four”);
}
boost::assign example
#include <boost/assign/list_inserter.hpp>
{
std::list<int> list;
boost::assign::push_front(list) (1) (2) (3);
}
boost::assign example
#include <boost/assign.hpp>
using namespace boost::assign;
{
// 1,2,2,2,2,2,3
std::vector<int> = 1, repeat(5, 2), 3;
}
boost::assign example
std::map<std::string, std::list<int> > numbers
= map_list_of ( ”Primes", list_of (1)(2)(3)(5) )
( ”Zero", list_of (0) )
( ”Odd", list_of (1)(3)(5)(7) );
boost::assign problems• Compilers not supporting templates full out• Not 100% STL compliant std-lib implementations
boost::assign work-arounds
std::vector<int> v = list_of(1)(2)(3).to_container( v );
std::set<int> s = list_of(1)(2)(3)(4).to_container( s );
std::map<int,int> m = map_list_of(1,2)(2,3).to_container( m );
std::stack<int> st = list_of(1)(2)(3)(4).to_adapter( st );
std::queue<int> q = list_of(1)(2)(3)(4).to_adapter( q );
boost::array<int,4> a = list_of(1)(2)(3)(4).to_array( a );