#include <iostream>
#include <string>
#include <boost/shared_ptr.hpp>

class Test
{
public:
    Test( const char * Name ):
        name( Name )
    {
    }

    ~Test()
    {
        std::cout << "Destruction de " << this->name << '\n'; 
    }
    
    void printName()
    { 
        std::cout << this->name << '\n'; 
    }

private:
    std::string name;
};

// déclaration du type pointeur intelligent sur Test
typedef boost::shared_ptr<Test> TestPtr;

int main()
{
    TestPtr ptr; // pointeur initialisé à NULL

    {
        // pointeur temporaire détruit à la fin du bloc
        TestPtr ptr_tmp( new Test( "objet1" ) );

        // initialiser ptr avec ptr_tmp
        ptr = ptr_tmp;
    } // ici, ptr_tmp est détruit, mais ptr reste valide

    ptr->printName(); // OK, affiche "objet1"

    // réinitialiser le pointeur avec un nouvel objet
    // objet1 est détruit, objet2 est créé
    ptr.reset( new Test( "objet2" ) );

    ptr->printName(); // OK, affiche "objet2"
    
    // copie du pointeur sur objet2
    TestPtr ptr2 = ptr;

    // mise à NULL de ptr
    ptr.reset(); // rien ne se passe

    // mise à NULL de ptr2
    ptr2.reset(); // objet2 est détruit
    
    // utilisation du pointeur NULL : erreur en mode Debug
    ptr->printName(); // Assertion failed: px != 0
}

struct Delete
{
    void operator ()(Test*& Ptr) const
    {
        cout << "Destruction";
        delete Ptr;
    }
};

int main()
{
    shared_ptr<Test> Ptr(new Test(), Delete());
}

#include <boost/shared_ptr.hpp>

class Base
{
public:
    virtual ~Base() {};
};

class Derived : public Base {};

typedef boost::shared_ptr<Base> BasePtr;
typedef boost::shared_ptr<const Base> BaseConstPtr;
typedef boost::shared_ptr<Derived> DerivedPtr;
typedef boost::shared_ptr<const Derived> DerivedConstPtr;

void implicit_upcasting()
{
// casting implicite sur des pointeurs bruts
{    
    Derived *d = new Derived;
    Base *b1 = d;
    const Base *b2 = d;
    delete d;
}
// équivalent avec des pointeurs intelligents
{    
    DerivedPtr d( new Derived );
    BasePtr b1 = d;
    BaseConstPtr b2 = d;
}
}

void down_casting()
{
// downcasting sur des pointeurs bruts
{
    Base *b = new Derived;
    Derived *d1 = static_cast<Derived*>( b );
    Derived *d2 = dynamic_cast<Derived*>( b );
    assert( d2 != 0 );
    delete b;
}
// équivalent avec des pointeurs intelligents
{
    BasePtr b( new Derived );
    DerivedPtr d1 = boost::static_pointer_cast<Derived>( b );
    DerivedPtr d2 = boost::dynamic_pointer_cast<Derived>( b );
    assert( d2 != 0 );
}
}

void const_casting()
{    
// constcasting sur des pointeurs bruts
{
    const Base *b_const = new Base;
    Base *b2 = const_cast<Base*>( b_const );
    delete b_const;
}
// équivalent avec des pointeurs intelligents
{
    BaseConstPtr b_const( new Base );
    BasePtr b2 = boost::const_pointer_cast<Base>( b_const );
}
}

void deprecated_casting()
{        
// downcasting sur des pointeurs bruts
{
    Base *b = new Derived;    
    try
    {        
        // downcasting levant std::bad_cast en cas d'échec
        Derived &d1 = dynamic_cast<Derived&>( *b );        
    }
    catch ( const std::bad_cast & ) 
    {
    }
    // downcasting provoquant une erreur uniquement en debug
#ifdef _DEBUG
    Derived *d2 = dynamic_cast<Derived*>( b );
    assert( d2 );
#else
    Derived *d2 = static_cast<Derived*>( b );
#endif
    delete b;
}
// équivalent avec des pointeurs intelligents
{
    BasePtr b( new Derived );
    try
    {        
        // downcasting levant std::bad_cast en cas d'échec
        DerivedPtr d1 = boost::shared_polymorphic_cast<Derived>( b );        
    }
    catch ( const std::bad_cast & )
    {
    }
    // downcasting provoquant une erreur uniquement en debug
    DerivedPtr d2 = boost::shared_polymorphic_downcast<Derived>( b );
}
}

std::auto_ptr<int> p1( new int );
boost::shared_ptr<int> p2( p1 );
// ici, p1 est invalide

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

// découpe la chaine avec les séparateurs par défaut
void split( const std::string & Msg )
{
    // utiliser le tokenizer par défaut
    boost::tokenizer<> tok( Msg );

    // itérer la séquence de tokens
    for ( boost::tokenizer<>::const_iterator i = tok.begin();
          i != tok.end();
          ++i )
    {
        // afficher chaque token extrait
        std::cout << *i << '\n';
    }
}

// découpe la chaine selon les séparateurs donnés
void split( const std::string & Msg, const std::string & Separators )
{
    // typedef pour alléger l'écriture
    typedef boost::tokenizer<boost::char_separator<char> > my_tok;

    // séparateur personnalisé
    boost::char_separator<char> sep( Separators.c_str() );

    // construire le tokenizer personnalisé
    my_tok tok( Msg, sep );

    // itérer la séquence de tokens
    for ( my_tok::const_iterator i = tok.begin();
          i != tok.end();
          ++i )
    {
        // afficher chaque token extrait
        std::cout << *i << '\n';
    }
}

int main()
{
    std::cout << "-- exemple 1 --\n";

    split( "mot1;mot2;   ;mot3;;mot4;mot5;" );
   
    std::cout << "-- exemple 2 --\n";

    split( "mot-compose1;mot,compose2;[mot][compose3];mot compose4;<mot><compose><5>", ";" );
}

-- exemple 1 --
mot1
mot2
mot3
mot4
mot5
-- exemple 2 --
mot-compose1
mot,compose2
[mot][compose3]
mot compose4
<mot><compose><5>

#include <list>
#include <algorithm>
#include <boost/checked_delete.hpp>

int main() 
{ 
    // Création d'une liste de pointeurs 
    std::list<int*> l; 
    l.push_back(new int(5)); 
    l.push_back(new int(0)); 
    l.push_back(new int(1)); 
    l.push_back(new int(6)); 

    // Destruction de la liste : attention il faut bien libérer les pointeurs avant la liste ! 
    std::for_each(l.begin(), l.end(), boost::checked_deleter<int>()); 

    return 0; 
}

#include <list>
#include <algorithm>
#include <boost/foreach.hpp>

int main() 
{ 
    // Création d'une liste de pointeurs 
    std::list<int*> l; 
    l.push_back(new int(5)); 
    l.push_back(new int(0)); 
    l.push_back(new int(1)); 
    l.push_back(new int(6)); 

    // Destruction de la liste : attention il faut bien libérer les pointeurs avant la liste !
    BOOST_FOREACH( int *pi, l )
    {
       delete pi;
    }

    return 0; 
}

class A { }; 
class B { }; 
class C {};
class D {};
 
boost::variant<A,B,C,D,std::string,int> v;
v = A(); // v contient une valeur de type A
v = B(); // v contient une valeur de type B
v = C(); // v contient une valeur de type C
v = D(); // v contient une valeur de type D
v = "Salut"; // v contient une valeur de type std::string
v = 42; // v contient une valeur de type int

struct Op
{
  enum op_type { ADD, SUB };
  
  double e1, e2;
  op_type op;
};
 
double compute_op(const Op& o)
{
  switch(o.op)
  {
    case Op::ADD:
    return o.e1 + o.e2; break;
    case Op::SUB:
    return o.e1 - o.e2; break;
  }
}
 
typedef boost::variant<double, Op> expression;
 
double compute_expression(const expression& e)
{
  if( double* d = boost::get<double>(&e) )
  {
    return d;
  }
  Op* o = boost::get<Op>(&e);
  return compute_op(*o);
}
 

template<typename U, typename T1, typename T2, ..., typename TN> 
  U * get(variant<T1, T2, ..., TN> * operand); // (1)
template<typename U, typename T1, typename T2, ..., typename TN> 
  const U * get(const variant<T1, T2, ..., TN> * operand); // (2)
template<typename U, typename T1, typename T2, ..., typename TN> 
  U & get(variant<T1, T2, ..., TN> & operand); // (3)
template<typename U, typename T1, typename T2, ..., typename TN> 
  const U & get(const variant<T1, T2, ..., TN> & operand); // (4)

#include <iostream>
#include <boost/variant.hpp>
 
int main()
{
  boost::variant<int, std::string> v;
  v = 42;
  
  int* i = boost::get<int>(&v); // l'entier pointé par i vaut 42.
  assert(*i == 42);
  *i = 84; // cela a également modifié la valeur contenue dans v
  std::string* s = boost::get<std::string>(&v);
  assert(s == NULL); // s vaut effectivement le pointeur nul
  
  int& i2 = boost::get<int>(v);
  assert(i2 == 84);
  try
    {
      std::string& s = boost::get<std::string>(v);
    }
  catch (std::exception& e)
    {
      std::cout << "Exception ! " << e.what() << std::endl;
    }
  return 0;
}

boost::variant< int, string > x; // déclare une variable de type boost::variant en précisant les types autorisés.
x = 42; //x contient un entier 
x = "hello, world"; // x contient une chaine de caractères
x = new Widget(); //erreur, x ne peut pas contenir un Widget.
 

boost::any x;
x = 42; // x contient un entier
x = "hello, world"; //x contient une chaine de caractères 
x = new Widget(); // x contient un widget, pas d'erreur