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