My solutions to the exercises in "The Boost C++ Libraries"

I like books with excercises, but I also want solutions to see if I got it right. When working through The Boost C++ Libraries I only found solutions that I had to pay for, so here are my own solutions if you want to compare to yours. Please let me know if you thing I got it wrong or if you have a better solution.
Chapter 2: Smart Pointers
Excercise 1

#include <iostream>
#include <cstring>
#include <boost/shared_array.hpp>

boost::shared_array<char> get(const char *s)
{
int size = std::strlen(s);
boost::shared_array<char> text(new char[size + 1]);
std::strncpy(text.get(), s, size + 1);
return text;
}

void print(boost::shared_array<char> text)
{
std::cout << text.get() << std::endl;
}

int main(int argc, char *argv[])
{
if (argc < 2)
{
std::cerr << argv[0] << " <data>" << std::endl;
return 1;
}

boost::shared_array<char> text = get(argv[1]);
print(text);
}

Excercise 2

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

template <typename T>
T *create()
{
return new T;
}

int main()
{
boost::ptr_vector<int> v;
v.push_back(create<int>());
}

Chapter 3: Function Objects
Excercise 1

#include <algorithm>
#include <functional>
#include <vector>
#include <iostream>
#include <boost/bind.hpp>
#include <boost/lambda/lambda.hpp>

int divide_by(int n, int div)
{
return n / div;
}

int main()
{
std::vector<int> numbers;
numbers.push_back(10);
numbers.push_back(20);
numbers.push_back(30);

std::transform(numbers.begin(), numbers.end(), numbers.begin(),
boost::bind(divide_by, _1, 2));

std::for_each (numbers.begin(), numbers.end(), std::cout << boost::lambda::_1 << " ");
}

Excercise 2

#include <string>
#include <vector>
#include <iostream>
#include <algorithm>
#include <boost/bind.hpp>
#include <boost/ref.hpp>
#include <boost/lambda/lambda.hpp>

void save_size(std::vector<int> & sizes, const std::string & s)
{
sizes.push_back(s.size());
}

int main()
{
std::vector<std::string> strings;
strings.push_back("Boost");
strings.push_back("C++");
strings.push_back("Libraries");

std::vector<int> sizes;

std::for_each (strings.begin(), strings.end(), boost::bind(save_size, boost::ref(sizes), _1));

std::for_each (sizes.begin(), sizes.end(), std::cout << boost::lambda::_1 << " ");
}

Excercise 3

#include <vector>
#include <iostream>
#include <cstdlib>
#include <cstring>
#include <boost/bind.hpp>
#include <boost/function.hpp>

void apply_fn(boost::function<int(const char*)> f, const char * data)
{
std::cout << f(data) << std::endl;
}

int main()
{
std::vector< boost::function<int(const char*)> > processors;
processors.push_back(std::atoi);
processors.push_back(std::strlen);

const char data[] = "1.23";

std::for_each(processors.begin(), processors.end(), boost::bind(apply_fn, _1, data));
}

Chapter 4: Event Handling
Excercise 1

#include <boost/signals2.hpp>
#include <iostream>

class button
{
public:
boost::signals2::connection add_handler(boost::function<void ()> h) { return handler.connect(h); }
void remove_handler(boost::signals2::connection c) { c.disconnect(); }
void click() { handler(); }

protected:
boost::signals2::signal<void ()> handler;
};

void func1()
{
std::cout << "Hello" << std::endl;
}

void func2()
{
std::cout << ", world!" << std::endl;
}

int main()
{
button btn;
btn.add_handler(func1);
boost::signals2::connection handle = btn.add_handler(func2);
btn.click();
btn.remove_handler(handle);
btn.click();
}

Chapter 5: String Handling
Excercise 1

#include <iostream>
#include <fstream>
#include <boost/regex.hpp>
#include <boost/algorithm/string.hpp>

int main()
{
std::ifstream ifs("sol.5.37.txt");
std::string xml;
while(ifs.good()) {
std::string line;
getline(ifs, line);
xml += line;
}

std::string first_name;
std::string last_name;
std::string dob_year;
std::string dob_month;
std::string dob_day;
float amount = 0.0;
std::string currency;

boost::smatch what;
boost::regex name_regex("<name>(.+)\s+(\w+)</name>");
if (boost::regex_search(xml, what, name_regex)) {
first_name = what[1];
last_name = what[2];
}
boost::regex dob_regex("<dob>(\d+)\-(\d+)\-(\d+)</dob>");
if (boost::regex_search(xml, what, dob_regex)) {
dob_year = what[1];
dob_month = what[2];
dob_day = what[3];
}
boost::regex account_regex("<account>(.+)\s+(\w+)</account>");
if (boost::regex_search(xml, what, account_regex)) {
std::string a = what[1];
boost::algorithm::erase_all(a, ",");
amount = std::atof(a.c_str());
currency = what[2];
}
else std::cout << "no amount found in " << xml << std::endl;

std::cout << first_name << " " << last_name
<< " DOB: " << dob_day << "." << dob_month << "." << dob_year
<< " : " << floor(amount) << " " << currency << std::endl;
}

Data

<person>
<name>Karl-Heinz Huber</name>
<dob>1970-9-30</dob>
<account>2,900.64 USD</account>
</person>

Excercise 2

#include <iostream>
#include <fstream>
#include <boost/algorithm/string.hpp>
#include <boost/format.hpp>

int main()
{
std::ifstream ifs("sol.5.38.txt");
while(ifs.good()) {
std::string line;
getline(ifs, line);
std::vector<std::string> tok;
boost::algorithm::split(tok, line, boost::algorithm::is_space());
if (tok.size() == 5)
std::cout << boost::format("%-10s -> %-10s %4.2f EUR (%05s-%05s)") % tok[0] % tok[1] % tok[2] % tok[3] % tok[4] << std::endl;
}
}

Data

Munich Hamburg 92.12 8:25 9:45

Chapter 6: Multithreading
Excercise 1

#include <boost/date_time/posix_time/posix_time.hpp>
#include <boost/cstdint.hpp>
#include <iostream>
#include <boost/thread.hpp>

boost::mutex mutex;
boost::uint64_t sum = 0;

void partial_sum(int from, int to)
{
boost::uint64_t local_sum = 0;
for (int i = from; i < to; ++i)
local_sum += i;

mutex.lock();
sum += local_sum;
mutex.unlock();
}

int main()
{
boost::posix_time::ptime start =
boost::posix_time::microsec_clock::local_time();

boost::thread t1(partial_sum, 0, 1000000000/2);
boost::thread t2(partial_sum, 1000000000/2, 1000000000);
t1.join();
t2.join();

boost::posix_time::ptime end =
boost::posix_time::microsec_clock::local_time();
std::cout << end - start << std::endl;

std::cout << sum << std::endl;
}

Excercise 2

#include <boost/date_time/posix_time/posix_time.hpp>
#include <boost/cstdint.hpp>
#include <iostream>
#include <vector>
#include <boost/thread.hpp>

boost::mutex mutex;
boost::uint64_t sum = 0;

void partial_sum(int from, int to)
{
boost::uint64_t local_sum = 0;
for (int i = from; i < to; ++i)
local_sum += i;

mutex.lock();
sum += local_sum;
mutex.unlock();
}

int main()
{
boost::posix_time::ptime start =
boost::posix_time::microsec_clock::local_time();

std::vector<boost::thread*> threads;

int num_threads = boost::thread::hardware_concurrency();

unsigned chunk = 1000000000 / num_threads;
for(int i=0; i < num_threads; ++i) {
boost::thread *t = new boost::thread(partial_sum, i*chunk, (i+1)*chunk);
threads.push_back(t);
}
for(unsigned i=0; i < threads.size(); ++i) {
threads[i]->join();
}

boost::posix_time::ptime end =
boost::posix_time::microsec_clock::local_time();
std::cout << end - start << std::endl;

std::cout << sum << std::endl;
}

Excercise 3

#include <iostream>
#include <boost/thread.hpp>

boost::mutex calc_mutex;
boost::mutex output_mutex;
int sum = 0;

void calculate()
{
calc_mutex.lock();
sum = 0;
for (int i = 0; i < 1000; ++i)
sum += i;
calc_mutex.unlock();
}

void print()
{
output_mutex.lock();
std::cout << sum << std::endl;
output_mutex.unlock();
}

void thread()
{
calculate();
print();
}

int main()
{
boost::thread t1(thread);
boost::thread t2(thread);
t1.join();
t2.join();
}