1. Что такое boost::any. Введение для самых маленьких :)

boost::any — это контейнер для 0 или 1 элементов, который может содержать разные типы, но не разрешает неявных преобразований между ними. При этом типы должны быть CopyConstructible, и не должны бросать исключения в дторах.

boost::any позволяет сделать вид, что все типы (удовлетворяющие перечисленным требованиям) входят в иерархию с одним корнем (как в .NET FCL). А именно, корнем этой „иерархии“ будет класс any::placeholder, как видно из реализации. Кстати, советую заглянуть в реализацию, она очень кратка, красива и поучительна :) Никаких там union'ов или, прасти 'оспади, void*'ов, чисто ООП и тэ́мплит программинг.

Чтобы прочувствовать общность между System.Object и boost::any, сравните два примера:

using System;
using System.Windows.Forms;

...

private void ButtonOnClick(Object sender, EventArgs args)
{
  Button btn = sender as Button;
  if (btn != null)
    btn.Text = "Click me!";
}

private void FormOnClick(Object sender, EventArgs args)
{
  try {
    Form frm = (Form) sender;
    frm.Text = "Close me!";
  }
  catch (System.InvalidCastException ex) {
    MessageBox.Show("Invalid cast exception", "Exception",
      MessageBoxButtons.OK, MessageBoxIcon.Error);
  }
}

// Если бы все компиляторы (по крайней мере, хоть один!)
// были в состоянии правильно делать ADL,
// то этой строки не понадобилось бы.
using boost::any_cast;

...

void ButtonOnClick(boost::any sender, EventArgs args)
{
  if (Button* const btn = any_cast<Button>(&sender))
    btn->SetText("Click me!");
}

void FormOnClick(boost::any sender, EventArgs args)
{
  try {
    Form frm( any_cast<Form>(sender) );
    frm.SetText("Close me!");
  }
  catch (boost::bad_any_cast const& ex) {
    ::MessageBoxA(0, "Invalid cast exception",
      "Exception", MB_ICONERROR);
  }
}

Первая функция в каждой колонке использует „небросающее“ приведение. Обратите внимание, как это делается в коде на C++ — в аргумент any_cast'а передаётся указатель, целевой тип остаётся прежним. Тут выпендрёжа ради переменная объявляется а заголовке условного оператора (как в for'е), и видна только в скоупе if'а. В реальном коде такое встречается редко, но может быть полезным, когда у вас цепочка if'ов, и вводить свою „одноразовую“ переменную для каждого типа лениво и вообще error prone. Во второй функции используется „бросающая“ форма приведения. В общем, поведение any_cast'а похоже на поведение плюсового dynamic_cast'а.

2. Зачем нужен streamable any, и как его реализовать

Было бы удобно, если бы такой контейнер умел бы выводиться в поток. Но boost::any слишком универсален, поэтому в библиотеке не реализована функция, сужающая область применения шаблона на streamable типы. В то время, как мне приходится хранить не произвольные типы, а только фундаментальные и строки. А выбирать тип каждый раз только для того, чтобы вывести его на консоль немного напряжно. Поэтому, быть может, удобнее будет самопальный класс Any (implemented in terms of boost::any), который может хранить лишь типы, для которых определён оператор вывода в поток. Тогда можно будет сделать так:

Utils::Any const a(3.1415);
std::cout << a << std::endl;

Решение я содрал из книжки Björn Karlsson “Beyond the C++ Standard Library: An Introduction to Boost”. Разве что добавил пару const и по пространствам раскидал. Вот как оно выглядит:

// Utils.h

#pragma once

#include <boost/any.hpp>

#include <iostream>

namespace Detail
{
  class Streamer
  {
  public:
    virtual void Print(std::ostream& ostr, boost::any const& a) const = 0;
    virtual Streamer* Clone() const = 0;
    virtual ~Streamer() {}
  };

  template <typename T>
  class StreamerImpl : public Streamer
  {
  public:
    void Print(std::ostream& ostr, boost::any const& a) const {
      ostr << *boost::any_cast<T>(&a);
    }
    Streamer* Clone() const {
      return new StreamerImpl<T>();
    }
  };
}

namespace Utils
{
  class Any
  {
  public:
    Any() : streamer_(0) {}
    template <typename T> Any(T const& value)
      : streamer_(new Detail::StreamerImpl<T>), o_(value) {}
    Any(Any const& a)
      : streamer_(a.streamer_ ? a.streamer_->Clone() : 0), o_(a.o_) {}
    template <typename T> Any& operator =(T const& r) {
      Any(r).swap(*this);
      return *this;
    }
    Any& operator=(Any const& r) {
      Any(r).swap(*this);
      return *this;
    }
    ~Any() { delete streamer_; }
  public:
    Any& swap(Any& r) {
      std::swap(streamer_, r.streamer_);
      std::swap(o_, r.o_);
      return *this;
    }
    friend std::ostream& operator <<(std::ostream& ostr, Any const& a) {
      if (a.streamer_) { a.streamer_->Print(ostr, a.o_); }
      return ostr;
    }
  private:
    boost::any o_;
    Detail::Streamer* streamer_;
  };
}

Щаз пример употребления слабаю:

// Test.cpp

#include "Utils.h"

#include <boost/lexical_cast.hpp>

#include <iostream>
#include <string>

class D
{
  double d_;
public:
  explicit D(double d) : d_(d) {}
  double Value() const { return d_; }
  friend std::ostream& operator << (std::ostream& ostr, D const& d) {
    return ostr << d.Value();
  }
};

int main()
{
  D const d(3.1415);
  Utils::Any const a(d);
  std::cout << a << std::endl;

  // Приведение к строке теперь доступно автоматически.
  std::string const str( boost::lexical_cast<std::string>(a) );
  std::cout << str << std::endl;

  return 0;
}