Catégorie: MS Visual C++

L'add-in Qt pour Visual Studio est sorti en version 1.1.9, qui supporte Visual Studio des versions 2005 à 2010 (8.0 à 10.0).

Par rapport à la version 1.1.8 précédente, seuls quelques bogues ont été fixés :
- régression lors de l'import des fichiers .pro dans la 1.1.8 ;
- compatible avec les projets Intel VTune ;
- vérification de la compatibilité de la version de Visual Studio lors de l'ajout d'une nouvelle version de Qt, pour éviter qu'un build pour MinGW soit utilisé avec Visual Studio et les plaintes qui vont avec ;
- possibilité d'ajout d'options pour lupdate et lrelease.

Il est disponible au téléchargement : http://qt.nokia.com/downloads/visual-studio-add-in

J’ai eu besoin d’utiliser l’algo bien connu de Dijkstra pour trouver un plus court chemin entre 2 points. Le principe est très bien expliqué sur wikipédia, mais j’avais besoin d’une implémentation en C.

Après quelques recherches, je suis tombé sur cette page qui m’offre l’aglo tout cuit, mais sans son utilisation.

Je montre ici comment l’utiliser après une ou deux corrections de coquille dans l’algo trouvé.

Il faut dans un premier temps une matrice adjacente, qui peut être de cette forme :

   1: #define INFINI 10000

   2: #define NB_SOMMET 6

   3:  

   4: int mat[NB_SOMMET][NB_SOMMET] =  

   5:     {{ 0, 171, INFINI, INFINI, INFINI, INFINI},

   6:     {171,   0,  30, INFINI, INFINI, INFINI},

   7:     {INFINI,  30,   0, INFINI,  39,  13},

   8:     {INFINI, INFINI, INFINI,   0,  30, INFINI},

   9:     {INFINI, INFINI, 39,   30,   0,  26},

  10:     {INFINI, INFINI,  13, INFINI,  26,   0}};

On a une constante “Infini” qui est suffisamment grande, c’est à dire plus grande que la distance maxi entre 2 sommets. Et une matrice carrée contenant la distance entre chaque sommet.

Ensuite la méthode avec les 2-3 trucs corrigés :

   1: void dodijkstra(int sr,int ds, int path[])

   2: {

   3:     if (sr == ds)

   4:         return;

   5:  

   6:     struct node

   7:     {

   8:         int pre;   /* Predecessor */

   9:         int length; /* Length between the nodes */

  10:         enum {perm,tent} label; /* Enumeration for permanent and tentative labels */

  11:     }state[NB_SOMMET];

  12:         

  13:         int i,k,min;

  14:         struct node *p;

  15:         /* Initialisation of the nodes aka First step of Dijkstra Algo */

  16:         for(p=&state[0];p<&state[NB_SOMMET];p++)

  17:         {

  18:            p->pre= -1;

  19:            p->length=INFINI;

  20:            p->label=node::tent;

  21:         }

  22:         state[ds].length=0; /* Destination length set to zero */

  23:         state[ds].label=node::perm; /* Destination set to be the permanent node */

  24:         k=ds; /* initial working node */

  25:         /* Checking for a better path from the node k ? */

  26:         do

  27:         {

  28:            for(i=0;i<NB_SOMMET;i++)

  29:               {

  30:                   if(mat[k][i]!=0 && state[i].label==node::tent)

  31:                      {

  32:                         if((state[k].length+mat[k][i])<state[i].length)

  33:                            {

  34:                                state[i].pre=k;

  35:                                state[i].length=state[k].length+mat[k][i];

  36:                            }

  37:                      }

  38:               }

  39:              k=0;

  40:              min=INFINI;

  41:               /* Find a node which is tentatively labeled and with minimum label */

  42:               for(i=0;i<NB_SOMMET;i++)

  43:               {

  44:                  if(state[i].label==node::tent && state[i].length<min)

  45:                     {

  46:                         min=state[i].length;

  47:                         k=i;

  48:                     }

  49:               }

  50:               state[k].label=node::perm;

  51:         } while(k!=sr);

  52:         

  53:         i=0;

  54:         k=sr;

  55:         /* Print the path to the output array */

  56:         do 

  57:         {

  58:             path[i++]=k;

  59:             k=state[k].pre;

  60:         } while(k>=0);

  61:         path[i]=k;

  62: }

et enfin, l’appel de la méthode :

   1: int path[150];

   2: for (int z = 0 ; z < 150 ; z++)

   3:     path[z] = -1;

   4: dodijkstra(sommetSource, sommetDestination, path);

On initialise le tableau de résultat. Ici j’ai pris 150 arbitrairement, le but est que le tableau puisse contenir toutes les étapes intermédiaires.

L’algorithme nous rempli le tableau avec le trajet optimal.

path[0] contiendra la source
path[i] contient les différents sommets intermédiaires
path[n] contient la destination
path[n->150] contient -1

Simple et efficace !

Après avoir abordé le Trailing return type dans mon dernier billet, passons aux "Expressions lambda".
Considérons la classe ci-dessous :

» Lire la suite!

Après avoir abordé decltype dans mon dernier billet, passons au "Trailing return type" ou en français la mise en place du type de retour (je n'ai pas trouvé mieux comme traduction).

» Lire la suite!

decltype permet de déduire le type de donnée d’une expression:

int n ; 
decltype(n) var ;

» Lire la suite!

Après avoir abordé la référence r-Value dans mon dernier billet, passons au mot-clef auto.

auto permet de déclarer une variable sans spécifier son type de donnée.
Un exemple très simple :

auto myvar= 1 ;

La ligne ci-dessus déclare un variable sans préciser son type.
Celui-ci est déterminé par le compilateur en examinant la partie droite de l’expression.
Le code est alors transformé en :

» Lire la suite!

Après avoir abordé static_assert dans mon dernier billet, passons à la référence R-Value.

Pour bien comprendre ce qui va suivre il est impératif de connaitre les méthodes de transmission d’un argument dans une méthode en l’occurrence le passage par valeur et par référence.

Dans la littérature C++, rValue désigne un objet pouvant figurer à droite (right) d’une affectation, alors que lValue désigne un objet pouvant se trouver à gauche.
Concrètement une nouvelle forme de déclaration utilisant l'opérateur && va nous permettre de transférer la responsabilité d’une ressource d’un objet temporaire à un autre, évitant ainsi une libération mémoire et une nouvelle allocation et la copie de la ressource concernée.

» Lire la suite!

Après avoir abordé nullptr dans mon dernier billet, passons à static_assert.

static_assert permet de vérifier une condition au moment de la compilation.
Sa syntaxe est la suivante :

static_assert( expression, message)

Exemple :

static_assert( 0==1, "zero n’est pas egal a 1 !") ;

si la condition est vérifiée le compilateur ne dit rien, par contre en cas d’erreur comme dans l’exemple ci-dessus il génère une erreur C2338 avec le message mentionné :
error C2338: zero n’est pas egal a 1 !

Le message ne supporte que les caractères de base et donc pas les accents.
Dans le cas d’utilisation de static_assert avec une classe template, la condition sera vérifiée lorsque une classe utilisant le template sera déclarée.

Référence MSDN

Dans mon billet précédent je présentais mon article sur les nouveautés de Visual C++ avec notamment un point sur le support partiel de C++0x.
Je vous propose de découvrir quelques-unes de ces nouvelles fonctionnalités en commençant par : nullptr.

Nullptr, littéralement : pointeur nul, devient un mot clef du langage à part entière, il est destiné à remplacer dans votre code NULL qui est une définition:

#define NULL 0

Nous pouvons maintenant écrire :

CData* pData= nullptr; 
if ( pData == nullptr ){} 
 
BOOL CMainFrame::CreateOutlookBar(…) 
{ 
If(this==nullptr || m_hWnd== nullptr) return FALSE; 
} 
 


Jusqu'à présent rien de bien essentiel par rapport à l’utilisation de NULL.
En fait ce mot clef va s’avérer utile dans le cas suivant :

… 
void MyClass ::FunctionAdd(int *pInt){... 
void MyClass ::FunctionAdd(int n){... 
… 
MyClass var; 
var.FunctionAdd(nullptr); // Appellera FunctionAdd(int *pInt); 
var.FunctionAdd(NULL); // Appellera FunctionAdd(int n); sans avertissement du compilateur... 


nullptr permet ici d’éviter la mauvaise résolution d’appel de la méthode suggérée par NULL qui est un entier.

Dernier point : Je n’ai pas fait l’essai, mais il serait intéressant de voir si nullptr peut être utilisé dans du code mixte C++ et C++CLI qui utilise aussi ce mot clef…

Dans mon précédent billet j’annonçais la sortie de Visual Studio 2010 et les principales raisons de s’y intéresser.
Je reviens sur le sujet avec un article de présentation disponible ici.

Pour un développeur C++ voici quelques raisons pour s’y intéresser

1) Meilleur performance sur des projets volumineux :

L’IntelliSense le compagnon indispensable du développeur s’appuie maintenant sur un mini base SQL et réduit notablement le temps de construction de la base de référence.
On dispose maintenant d’un soulignement des erreurs de syntaxe.

2) Support de Windows 7 dans les MFC

Le ruban (ribbon) peut être construit directement dans l’éditeur de ressources
support du redémarrage de l’application après un crash
le support du « higth DPI »
la prévisualisation des documents associés à l’application dans l’explorateur, ainsi que la vue simplifiée.
La possibilité de ces documents d’être intégrés dans le système de recherche.
Le support du multi-touch
le retour de classwizard.

3) nouvelle bibliothèque sur le parallélisme : (parallel Patterns library)

4) support amélioré sur les principales fonctionnalités que propose le C++0X.

Je reviendrai bientôt dans un article (presque finit !) sur ces différents thèmes.

Après avoir passé trois jours aux Techdays pour assister aux conférences en rapport à Visual Studio 2010 et le C++, et être présent sur le stand de développez, il était chuchoté que la RC de Visual studio 2010 allait être annoncé d’ici peu.
Hé bien c’est chose faite elle est disponible sur le site Us sur ce lien.
A ce sujet Eric Vernié avec qui j’ai discuté hier de cette RC me signalait qu’il avait un bug avec IntelliSense et l’utilisation du multi-touch mais qu’il y avait un patch en cours de diffusion...
Bon je vous laisse j’ai un téléchargement à lancer.