De nouvelles applications à prévoir

Microsoft frappe fort avec un nouveau concept d'ordinateur : Microsoft surface.

Imaginez un ordinateur dans une table, juste devant vous qui vous permet en déplaçant le doigt sur la table de manipuler l'interface utilisateur.

Vous pouvez poser des objets sur cette table, comme un appareil photo ou un PDA, la table reconnaît ces objets et peut en extraire ou y introduire des informations.

Les images parlent d'elles mêmes à voir absolument :

http://www.surface.com

Une bien triste nouvelle

Aujourd'hui une bien triste nouvelle secoue la famille LTM : notre très apprécié collaborateur Philippe PONS nous a quitté ce week end.

Philippe, collaborateur de la première heure était autant apprécié pour son travail, ses compétences techniques et pédagogiques, que pour sa gentillesse et ses qualités humaines.

Nous nous étions rencontré il y a dix ans par le biais d'internet où j'avais su apprécier son travail sur UML et l'homme tout particulièrement.

Une très forte pensée pour sa famille et ses proches en souffrance absolue en ce bien triste moment.

Vieux frère je te souhaite de connaître dans l'autre monde tout le bonheur que j'espère l'on réserve aux êtres d'exception.

Bien tristement, ton collaborateur et ami Bertrand.

Les 'smarts pointers' de boost(tm)

Les développeurs C++ qui connaissent des déboires avec la gestion mémoire sur le tas (heap) du langage C++, seront bien aise de connaître les 'smarts pointers' de boost.

Je rappel que les 'smarts pointers' encore appelés 'handler' par certains, vous permettent de gérer automatiquement des objets ou tableaux d'objets alloués sur le tas (avec new).

Ce projet 'Open Source' propose des librairies sources, multi compilateurs (et donc multi platefomes), dédiées à l'amélioration des programmes C++.

Si vous y prenez garde, vous remarquerez que le projet boost propose plusieurs smarts pointers C++ :

Le 'scoped_ptr' : dédié à la gestion d'objets simples

Le 'scoped_array' : dédié à la gestion de tableaux d'objets simples (le smart pointeur pointe un tableau d 'objets alloués sur le tas)

Le 'shared_ptr' : dédié à la gestion d'objets multi pointés (plusieurs smarts pointers pointent le même objet (alloué sur le tas) et un compteur de référence permet la gestion du cycle de vie de l'objet pointé)

Le 'shared_array' : Même chose que ci-dessous mais pour les tableaux d'objets

Deux autres smarts pointers : le 'weak_ptr' et l'intrusive_ptr', dédiés à des utilisations plus particulière (voir doc de boost)

Remarque : les sp 'scoped' ne permettent pas de transmettre la propriété d'un objet pointé (contrairement à l' auto_ptr' du C++ dans les STL).

Lien sur le site boost présentant ses smarts pointeurs : http://www.boost.org/libs/smart_ptr/smart_ptr.htm

Quelques petits exemples ci-dessous :

Exemple du 'scoped_ptr'

L'exemple ci-dessous décrit le 'scoped_ptr' pointant des objets sur le tas. Celui-ci ne permet pas la gestion d'un compteur de référence interne, comptant combien de sp pointent l'objet sur le tas. Le code important apparaît dans le source ci-dessous en gras.

include "boost/scoped_ptr.hpp"

#include <iostream>

class Y{

public:

Y(){ std::cout << "Y::Y" << std::endl; }

virtual ~Y() { std::cout << "Y::~Y" << std::endl; }

};

class X{

private:

boost::scoped_ptr<Y> spy; // ici spy va pointer l'objet alloué sur le tas dans le constructeur

public:

X() : spy( new Y() ) { std::cout << "X::X" << std::endl; }

virtual ~X(){ std::cout << "X::~X" << std::endl; }

};

int main() {

boost::scoped_ptr<X> spx( new X() );

return 1;

} // ici le destructeur de 'spx' entrainera toutes les libérations

Exemple du 'scoped_array'

Cet exemple met en oeuvre le smart pointeur 'scoped_array' permettant le pointage simple d'un tableau d'objets alloués sur le tas.

#include "boost/scoped_array.hpp"
#include <iostream>

class Y{
public:
Y(){ std::cout << "Y::Y" << std::endl; }
virtual ~Y() { std::cout << "Y::~Y" << std::endl; }
};

class X{
private:
boost::scoped_array<Y> spy;
public:
X() : spy( new Y[2] ) { std::cout << "X::X" << std::endl; }
virtual ~X(){ std::cout << "X::~X" << std::endl; }
};

int main() {
boost::scoped_array<X> spx( new X[2] );

return 1;

} // ici les destructeurs des smarts pointeurs vont parler pour libérer les objets sur le tas

Exemple du 'shared_ptr'

Cet exemple montre en action le 'shared_ptr' permettant que plusieurs 'shared_ptr' pointent le même objet alloué sur le tas.

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

class X{
public:
X() { std::cout << "X::X" << std::endl; }
virtual ~X() { std::cout << "X::~X" << std::endl; }
};

int main() {

// ici les smart pointers se partagent un objet par jeu de copies
boost::shared_ptr<X> sp1( new X() );
boost::shared_ptr<X> sp2( sp1 );
boost::shared_ptr<X> sp3;
sp3 = sp2;

// autre test, normal ici ca plante, on ne peut faire pointer un smart pointeur sur la pile !
// X x1;
// boost::shared_ptr<X> sp4( &x1 );

// 3ème test, on passe deux fois la même adresse à des smart pointers qui ne se connaissent pas
// moralité : sp6 ne sais pas que sp5 pointe déjà cette adresse, on aura droit à un double delete en règle
// bien sûr : ici ça plante aussi, c'est le destructeur de sp5 qui est en cause
X * px = new X();
boost::shared_ptr<X> sp5( px );
boost::shared_ptr<X> sp6( px );

} // Même chose ici les destructeurs vont parler

Une seule adresse : http://www.boost.org/

A bientôt et bonne découverte ^^