#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; 
}