Blog de Nico-pyright(c) » C/C++ – Win32

[C] Implémentation de l’algo de Dijkstra en C

nico-pyright(c) — Sat, 18 Sep 2010 14:41:00 +0000

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 :

#define INFINI 10000
#define NB_SOMMET 6
  
int mat[NB_SOMMET][NB_SOMMET] =  
    {{ 0, 171, INFINI, INFINI, INFINI, INFINI},
    {171,   0,  30, INFINI, INFINI, INFINI},
    {INFINI,  30,   0, INFINI,  39,  13},
    {INFINI, INFINI, INFINI,   0,  30, INFINI},
    {INFINI, INFINI, 39,   30,   0,  26},
    {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 :

void dodijkstra(int sr,int ds, int path[])
{
    if (sr == ds)
        return;
  
    struct node
    {
        int pre;   /* Predecessor */
        int length; /* Length between the nodes */
        enum {perm,tent} label; /* Enumeration for permanent and tentative labels */
    }state[NB_SOMMET];
        
        int i,k,min;
        struct node *p;
        /* Initialisation of the nodes aka First step of Dijkstra Algo */
        for(p=&state[0];p<&state[NB_SOMMET];p++)
        {
           p->pre= -1;
           p->length=INFINI;
           p->label=node::tent;
        }
        state[ds].length=0; /* Destination length set to zero */
        state[ds].label=node::perm; /* Destination set to be the permanent node */
        k=ds; /* initial working node */
        /* Checking for a better path from the node k ? */
        do
        {
           for(i=0;i
              {
                  if(mat[k][i]!=0 && state[i].label==node::tent)
                     {
                        if((state[k].length+mat[k][i])
                           {
                               state[i].pre=k;
                               state[i].length=state[k].length+mat[k][i];
                           }
                     }
              }
             k=0;
             min=INFINI;
              /* Find a node which is tentatively labeled and with minimum label */
              for(i=0;i
              {
                 if(state[i].label==node::tent && state[i].length
                    {
                        min=state[i].length;
                        k=i;
                    }
              }
              state[k].label=node::perm;
        } while(k!=sr);
        
        i=0;
        k=sr;
        /* Print the path to the output array */
        do 
        {
            path[i++]=k;
            k=state[k].pre;
        } while(k>=0);
        path[i]=k;
}

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

int path[150];
for (int z = 0 ; z < 150 ; z++)
    path[z] = -1;
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 !

[C++] Interview de Bjarne Stroustrup dans Msdn Magazine. L’évolution des langages

nico-pyright(c) — Fri, 25 Apr 2008 09:43:44 +0000

Voici le lien : http://msdn2.microsoft.com/fr-fr/magazine/cc500572.aspx

Bonne lecture

[C++/CLI] Intéropérabilité de structure

nico-pyright(c) — Fri, 01 Feb 2008 21:52:49 +0000

Je viens de mettre à jour mon tutoriel sur l’intéropérabilité où j’expose une manière plus simple de mettre à jour une structure C native par référence depuis un programme C#.

soit la structure C suivante

typedef struct {
int age;
int taille;
} MASTRUCTURE;

et la méthode suivante qui incrémente une structure passée en paramètre :

extern "C" __declspec(dllexport) void Inc(MASTRUCTURE * s)
{
s->age++;
s->taille++;
}

On peut utiliser les méthodes PtrToStructure et StructureToPtr pour faire l’intéropérabilité, mais on peut également utiliser une méthode très simple en déclarant notre structure avec le mot clé struct :

[StructLayout(LayoutKind.Sequential)]
public struct MaStructCSharp
{
public int age;
public int taille;
}

Et si on déclare le DllImport avec une référence :

[DllImport("libCStruct.dll")]
public static extern void Inc(ref MaStructCSharp s);

On pourra faire l’implémentation de notre code C# ainsi :

MaStructCSharp s = new MaStructCSharp();
s.age = 27;
s.taille = 185;
Inc(ref s);
Console.WriteLine(s.age);
Console.WriteLine(s.taille);

Voilà

J’en profite pour remercier Mike pour ses remarques constructives sur mon article

MVP pour une nouvelle année

nico-pyright(c) — Thu, 03 Jan 2008 08:05:45 +0000

Me voici également renouvelé pour une nouvelle année de MVP à votre service.

J’en profite pour vous adresser mes meilleurs voeux pour cette année, qu’elle soit riche en C++, en .Net et en surprise de toutes sortes.

Bons devs

Tutoriel : Introduction à l’intéropérabilité (partie 2)

nico-pyright(c) — Sun, 28 Oct 2007 23:00:00 +0000

Je vous présente la deuxième partie de mon tutoriel d’introduction à l’intéropérabilité.

Vous apprendrez comment utiliser des structures C plus ou moins complexes dans un programme C#. Vous apprendrez aussi comment fonctionne COM Interop ainsi que le hosting de CLR afin d’utiliser des objets .Net dans une application native.

Aller au tutoriel d’introduction à l’intéropérabilité (partie 2)

Bonne lecture

L’avenir de visual c++ ?

nico-pyright(c) — Thu, 09 Aug 2007 19:00:00 +0000

Somasegar nous informe de l’orientation stratégique de Visual C++.

Comme on pouvait s’en douter, les priorités s’articulent autour de :

l’augmentation du support sur le développement natif
l’interop pour permettre a des applications natives d’accéder aux composants des framework.Net (WPF, WCF, …) que ce soit pour un relooking ou pour tirer parti des avancées du framework.
l’interop en tant que pont entre le monde managé et natif, pour tout ce qui est wrapper.

Des perspectives pour le C++/CLI, langage roi de l’intéropérabilité… et pour tout ce qui est natif, le C++ reste le langage de premier choix.

Comment intercepter des exceptions managées depuis du code natif ?

nico-pyright(c) — Tue, 07 Aug 2007 22:00:00 +0000

Des fois, il peut etre utile de pouvoir intercepter une exception managée à partir d’un code natif.

Soit le programme suivant qui simule, grace aux pragma unmanaged et managed, une intéraction entre un code natif et un code managé :

using namespace System;

void fonctionManagee()
{
throw gcnew Exception("Exception managée");
}

#pragma unmanaged
void fonctionNative()
{
fonctionManagee();
}
#pragma managed

int main()
{
fonctionNative();
return 0;
}

Si on exécute cet exemple, on obtient un crash de l’application à cause de la levée d’exception dans la méthode managée.

Le premier reflexe est d’utiliser un try catch … mais … quel type d’exception attraper ? Une solution pourrait être de tout attraper, avec une construction de ce genre :

void fonctionNative()
{
try
{
fonctionManagee();
}
catch (...)
{
std::cout << "N'importe quelle exception est attrapee, meme managee" << std::endl;
}
}

Cette construction a l’avantage de permettre d’intercepter l’exception levée dans la fonction managée depuis le code natif, mais a l’inconvénient de tout intercepter, à cause de la construction « … » suivant le catch.

La solution est d’utiliser un block try except, comme ci-dessous :

void fonctionNative()
{
__try
{
fonctionManagee();
}
__except(GetExceptionCode() == 0xE0434F4D ? EXCEPTION_EXECUTE_HANDLER : EXCEPTION_CONTINUE_SEARCH)
{
std::cout << "Uniquement les exceptions managees sont attrapees" << std::endl;
}
}

0xE0434F4D est le code d’erreur SEH correspond. (pour l’anectode, 0xE0434F4D correspond à 0xE0+ »COM » (= ‘àCOM’), car à l’origine, le CLR a été appelé COM+ 2.0. Le nom du projet a changé mais pas les codes d’exception)

L’inconvénient est qu’on ne peut pas avoir d’information sur l’exception, comme dans notre cas, le message d’exception levé.

Intéropérabilité de tableau dans une structure, le problème des tableaux à plusieurs dimensions

nico-pyright(c) — Fri, 29 Jun 2007 19:00:00 +0000

On vient de me poser une question :

je veux utiliser cette structure en C dans mon programme C#

typedef struct
{
int val;
int telfixe[10][2];
} MASTRUCTURETEL;

j’ai un peu modifié l’exemple pour que ce soit plus simple, mais la question porte sur le tableau à deux dimensions.

Alors, comment faire ?

Sur l’exemple de mes précédents billets, je vais créer une dll qui va exporter une fonction qui me retourne une structure :

typedef struct
{
int val;
int telfixe[10][2];
} MASTRUCTURETEL;

extern "C" __declspec(dllexport) MASTRUCTURETEL * GetUneStructure()
{
MASTRUCTURETEL *maStruct = new MASTRUCTURETEL;
for (int i = 0 ; i < 10 ; i++)
for (int j = 0; j < 2 ; j++)
maStruct->telfixe[i][j] = (i+1)*(j+1);
maStruct->val = 10;
return maStruct;
}

J’initialise mon tableau avec un peu n’importe quoi, mais bon voila, c’est exactement le tableau que je voulais avec les valeurs que je voulais :p

Maintenant, je veux pouvoir l’utiliser dans mon programme C#.

Il faut savoir que le marshaleur ne sait pas marshaler des tableaux multi-dimmensionnels, et donc que fatalement, nous allons récupérer un tableau à une seule dimension. Pour ce faire, on crée la structure C# ainsi :

[StructLayout(LayoutKind.Sequential)]
public class MaStructTelCSharp
{
public int val;
[MarshalAs(UnmanagedType.ByValArray, SizeConst=10*2, ArraySubType=UnmanagedType.SysInt)]
public int[] telFixe;
}

L’important est de noter la taille du tableau dans le paramètre SizeConst de l’attribut MarshalAs. On lui précise aussi qu’on veut récupérer des entiers.

Puis, on récupère la structure ainsi :

[DllImport("testLib.dll")]
public static extern IntPtr GetUneStructure();

...
IntPtr maStructureCUnmanaged = GetUneStructure();
MaStructTelCSharp maStructureCSharp = new MaStructTelCSharp();
Marshal.PtrToStructure(maStructureCUnmanaged, maStructureCSharp);

Au final donc, on se retrouve avec une structure qui contient un tableau à une dimension au lieu d’un tableau à deux dimensions.
C’est triste mais c’est ainsi.

Rien ne vous empeche de reconstruire éventuellement un tableau à deux dimensions à partir de notre tableau à 1 dimension.

COM Interop – Conserver la signature des méthodes

nico-pyright(c) — Sun, 24 Jun 2007 19:32:15 +0000

Le billet précédent présente une méthode qui simplifie grandement l’écriture de notre programme natif qui utilise un objet managé via COM Interop.
La contrainte qu’il rajoute est la transformation des signatures des méthodes à la sauce COM.
Ainsi, une méthode :

String^ ReadLine();

sera wrappée en

HRESULT ReadLine(/*[out,retval]*/ BSTR);

Ce qui suggère l’utilisation de la macro SUCCEEDED pour tester la bonne marche de la fonction.

Mais pouvons-nous encore simplifier et se passer de ce type de signature ? On aimerait pouvoir avoir une signature du genre :

BSTR ReadLine();

Bref, conserver la signature de la méthode, aux types près …

Et bien c’est possible, grâce à un attribut disponible dans le namespace System::Runtime::CompilerServices.

Notre classe managée ne change pas d’écriture, mais l’interface sera écrite ainsi :

using namespace System::Runtime::CompilerServices;

namespace MonStreamReader
{
public interface class IClassWrap
{
[MethodImpl(MethodImplOptions::PreserveSig)]
void SetFile(String ^fileName);
[MethodImpl(MethodImplOptions::PreserveSig)]
bool Create();
[MethodImpl(MethodImplOptions::PreserveSig)]
String^ ReadLine();
};

public ref class ClassWrap : IClassWrap
{
.........
}
}

L’attribut PreserveSig, comme son nom le suggère un peu, permet de préserver la signature ; et au final de simplifier encore un brin le programme natif.

int _tmain(int argc, _TCHAR* argv[])
{
CoInitialize(NULL);
MonStreamReader::IClassWrapPtr pClass(__uuidof(MonStreamReader::ClassWrap));
CComBSTR filePath = "c:\\test.txt";
pClass->SetFile(filePath);
if (pClass->Create())
{
CComBSTR line;
line = pClass->ReadLine();
while (line)
{
_bstr_t line_(line);
std::cout << line_ << std::endl;
line = pClass->ReadLine();
}
}
return 0;
}

Dingue ca, on dirait presque du C++/CLI :p, à part un ou deux BSTR qui trainent …

Un dernier petit truc : ne faites pas trop confiance à l’intellisense, il se débrouille pas trop mal, mais suite à quelques compilations, enregistrements, … dès fois, il pert un peu le nord. Heureusement que nous savons exactement ce que nous voulons faire

Wrapper de classes pour COM Interop, simplification et utilisation d’interfaces

nico-pyright(c) — Thu, 21 Jun 2007 00:19:38 +0000

Si vous êtes allé au bout du précédent billet, je vous félicite. Je rappelle que le but est de pouvoir utiliser un objet .net depuis notre exe natif pur et de passer des paramètres à son constructeur via un wrapper CLI.
Quand je re-regarde le code du billet, il me fait peur Tout ce code pour finalement si peu de choses…

N’y aurait-il pas moyen de faire plus simple ?

Forcément, si j’écris ca, c’est qu’il doit y avoir un moyen…

La solution est d’utiliser la capacité de visual studio à incorporer les tlb grâce à #import et à le convertir en classes C++.

Nous transformons notre précédente classe managée qui wrappe de manière simpliste le StreamReader pour faire en sorte que la classe implémente une interface :

using namespace System;
using namespace System::IO;

namespace MonStreamReader
{
public interface class IClassWrap
{
void SetFile(String ^fileName);
bool Create();
String^ ReadLine();
};

public ref class ClassWrap : IClassWrap
{
private:
String ^_fileName;
StreamReader ^sr;
protected:
!ClassWrap()
{
if (sr)
sr->Close();
}
public:
ClassWrap() {}
~ClassWrap()
{
this->!ClassWrap();
}
virtual void SetFile(String ^fileName)
{
_fileName = fileName;
}
virtual bool Create()
{
if (!String::IsNullOrEmpty(_fileName))
{
try
{
sr = gcnew StreamReader(_fileName);
return true;
}
catch (Exception ^)
{
sr = nullptr;
return false;
}
}
return false;
}
virtual String^ ReadLine()
{
if (sr)
return sr->ReadLine();
return nullptr;
} };
}

On génère le tlb, et on l’importe dans notre programme natif. Visual C++ va générer des classes et notamment une qui nous interesse IClassWrapPtr. C’est un smart pointer qui permet d’accèder à l’objet COM.

Il ne reste plus qu’à utiliser ce smart pointer pour appeler directement les méthodes de notre classe. Notez que les fonctions ont été relookées à la mode COM. On récupère un HRESULT et le retour de fonction se fait par un paramètre en sortie [out].

#include
#include

#import "..\debug\MonStreamReader.tlb" raw_interfaces_only

int _tmain(int argc, _TCHAR* argv[])
{
CoInitialize(NULL);
MonStreamReader::IClassWrapPtr pClass(__uuidof(MonStreamReader::ClassWrap));
CComBSTR filePath = "c:\\test.txt";
if (SUCCEEDED(pClass->SetFile(filePath)))
{
unsigned char resultBool;
if (SUCCEEDED(pClass->Create(&resultBool)))
{
if (resultBool)
{
CComBSTR line;
if (SUCCEEDED(pClass->ReadLine(&line)))
{
while (line)
{
_bstr_t line_(line);
std::cout << line_ << std::endl;
if (FAILED(pClass->ReadLine(&line)))
break;
}
}
}
}
}
return 0;
}

C’est quand même plus digeste !!
Notez l’utilisation de CComBstr pour passer des chaines qui seront marshalées en String^.net. Par contre, mon retour booleen donne un unsigned char.
Pour l’affichage, j’utilise également la classe _bstr_t qui dispose d’une surcharge de char *.

Vous pouvez télécharger le projet exemple.