namespace boost {
  class bad_any_cast;
  class any;
  template<typename T> T any_cast(any &);
  template<typename T> T any_cast(const any &);
  template<typename ValueType> const ValueType * any_cast(const any *);
  template<typename ValueType> ValueType * any_cast(any *);
}

class any 
{
	public :
	any();
	template <typename ValueType> any(const ValueType & value);
	any(const any & other);
	
	~any();
	
	any & swap(any & rhs);
	template <typename ValueType> any & operator=(const ValueType & rhs);
	any & operator=(const any & rhs);
	bool empty() const;
	const std::type_info & type() const;
	
	// nous n'étudions pas le reste de la classe
};

class bad_any_cast : public std::bad_cast {
public:
  virtual const char * what() const;
};

template <typename T> T any_cast(any &);
template <typename T> T any_cast(const any &);
template <typename ValueType> const ValueType * any_cast(const any *);
template <typename ValueType> ValueType * any_cast(any *);

#include <boost/any.hpp>

using namespace boost;

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

using namespace boost;
using namespace std;

int main()
{

	any a1(5); // création d'un boost::any contenant un entier
	cout << any_cast<int>(a1) << endl; // récupération puis affichage de l'entier 5
	any a2('c'); // création d'un boost::any contenant un caractère
	cout << any_cast<char>(a2) << endl; // récupération puis affichage du caractère 'c'
	a1 = a2; // appel à l'opérateur = de la classe boost::any : on remplace 5 par 'c' dans a1
	cout << any_cast<char>(a1) << endl; // affiche le caractère 'c'

	return 0;
}

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

using namespace boost;
using namespace std;

// définition d'une structure, pour les besoins de l'exemple
struct S
{
};

int main()
{
	S s; 
	any a(s); // on stocke l'instance de S dans notre boost::any

	try
	{
		char c = any_cast<char>(a); // on essaye de convertir le boost::any contenant une instance de S en un caractère
		// cela va échouer et lancer une exception de type bad_any_cast
	}

	catch(bad_any_cast& bac) // nous attrapons l'exception
	{
		cout << bac.what() << endl; // on affiche le message contenu dans l'exception
	}

	return 0;
}

#include <iostream>
#include <vector>
#include <algorithm>
#include <boost/any.hpp>

using namespace boost;
using namespace std;

// définition d'une classe, pour l'exemple
class MaClasse
{
	std::string s;

	public :
		MaClasse(const std::string& s_) : s(s_)
		{ }
};

// 4 fonctions permettant d'établir une correspondance entre le type réel de l'objet stocké
// et les types char, int, std::string et MaClasse
bool is_char(const any& a)
{
	return a.type() == typeid(char);
}

bool is_int(const any& a)
{
	return a.type() == typeid(int);
}

bool is_std_string(const any& a)
{
	return any_cast<std::string>(&a);
}

bool is_ma_classe(const any& a)
{
	return a.type() == typeid(MaClasse);
}

int main()
{
	// création de nos variables pour le std::vector
	int i1 = 2;
	int i2 = 45;
	int i3 = 2321;
	char c1 = 'd';
	char c2 = 'v';
	char c3 = 'p';
	std::string s1 = "Developpez";
	std::string s2 = ".com";
	MaClasse mc1("Boost.Any");
	MaClasse mc2("permet de stocker n'importe quel type");

	// création d'un vecteur contenant des boost::any, donc pouvant contenir presque
	// n'importe quoi
	vector<any> values;

	// ajout des variables dans le vecteur
	values.push_back(i1);
	values.push_back(i2);
	values.push_back(i3);
	values.push_back(c1);
	values.push_back(c2);
	values.push_back(c3);
	values.push_back(s1);
	values.push_back(s2);
	values.push_back(mc1);
	values.push_back(mc2);

	// on compte le nombre d'entiers, de caracteres, de std::string et de MaClasse
	// présents dans le vecteur
	cout << "Nombre d'entiers : " << count_if(values.begin(), values.end(), is_int) << endl;
	cout << "Nombre de caracteres : " << count_if(values.begin(), values.end(), is_char) << endl;
	cout << "Nombre de std::string : " << count_if(values.begin(), values.end(), is_std_string) << endl;
	cout << "Nombre de MaClasse : " << count_if(values.begin(), values.end(), is_ma_classe) << endl;

	return 0;
}