Discussion :

[Spartx]

Salutations !

Avant toute chose, je m'excuse pour le nom du sujet... Difficile de trouver un titre qui explique vraiment en quelques mots ce que je recherche !

En bref, j'aimerais savoir s'il existait un moyen simple de faire des fonctions (ou classes) qui puissent être modifiées après la compilation de mon programme.

La première solution qui viendrait à l'idée serait l'utilisation de DLL. Cependant, je souhaiterais que le code modifié soit complètement interactif avec le programme ! En clair, il faudrait que les fonctions placées dans la DLL puissent interagir directement avec des éléments de l'exécutable.
Je pensais qu'il y avait quelque chose à faire en combinant le "dllexport" avec le "dllimport", mais je ne parviens pas à l'utiliser correctement et à en faire ce que je souhaite ici... (Si c'est la solution, pourrait-on m'expliquer comment il fonctionne svp (j'ai recherché des multitudes d'exemples sur le net, mais aucun n'a été assez complet à mon goût pour vraiment m'aider...))

Je vous remercie d'avance pour votre aide !

[oxyde356]

Oui les DLL conviennent dans ton cas si ce que tu veux c'est pouvoir changer la définition (juste le corps) d'une fonction sans avoir à toucher à ton programme. Tu trouveras plein de tutos de qualités sur le sujet en cherchant sur google ou sur la FAQ de ce site qui contient une rubrique sur les DLLs.

[3DArchi]

Salut,
La première chose qui me vient à l'idée c'est qu'il ne s'agit pas d'un problème de dllimport ou de dllexport mais un problème d'architecture logiciel : identifier les bonnes interfaces, les bons DP, les bons points de variations, etc....

[Obsidian]

Bonjour,

En bref, j'aimerais savoir s'il existait un moyen simple de faire des fonctions (ou classes) qui puissent être modifiées après la compilation de mon programme.

Dis-nous exactement ce que tu aimerais faire au final, ce sera beaucoup plus clair. Tu ne pourras pas réellement « modifier » dynamiquement et a posteriori le code de ton programme puisque c'est justement le but de la compilation. Par contre, tu peux faire en sorte que tes fonctions appellent différentes routines en fonction du contexte à l'exécution.

Le plus simple est encore un gros switch principal dans le corps de ta fonction, mais tu peux également utiliser les pointeurs de fonction comme démontré dans cette discussion sur le forum C.

Si par « modifier », tu entends « les mettre à jour », effectivement, l'utilisation de DLL est ce qu'il y a de plus indiqué.

[Spartx]

Merci à tous pour vos réponses ! :p

Je vais être plus clair sur ce que je cherche à faire ; cela vous aidera peut être à m'aider !

En fait, je souhaiterais, dans un but pédagogique, concevoir un mmorpg.
La seule difficulté que je n'ai pu réellement surmonter est celle de la gestion des cartes : celles-ci doivent être fréquemment mises à jour.

La difficulté est que j'ai choisi de coder les évènements directement sur chaque carte ; et c'est pour cela que j'avais axé mon étude sur les DLL.

En théorie, j'vais pensé à cette architecture :
[DLL contenant les données de la carte et quelques évènements (à faible sécurité)] <==> [client du jeu]
Le problème ici est que la DLL ne peut utiliser des classes définies dans le client ! C'est pour cela que j'ai cherché du coté du dllimport pour définir ces classes dans la DLL sans en refaire l'implémentation.


Dans le cas où la seule solution serait effectivement du côté des dllimport et dllexport, serait-il possible d'avoir un petit exemple simple d'utilisation svp ? J'ai consulté moultes tutoriaux, mais à chaque fois, si l'explication quant au dllexport est complète, celle du dllimport n'est abordée que trop brièvement et je m'y perds... :s

Merci d'avance !

[screetch]

en général un jeu est une sorte de moteur qui interprète et affiche des données, et ce sont les données qui donnent le comportement du code.

Les données permettent donc d'agir sur le comportement du jeu, qui réagit selon que l'on a affaire a un troll ou a une tapette d'elfe (oops pardon c'est sorti tout seul)
on essaye de tendre vers le moins possible de code, le plus possible de données =)

les données ne sont jamais dans une DLL

[Spartx]

Seulement, il ne s'agit pas directement de données de jeu, mais d'évènements propres à la carte dans laquelle ils s'inscrivent !

Dans la plupart des éditeurs de jeu que l'on peut trouver sur le net, les évènements (tant la condition que l'effet) sont pré-établis, ce qui, à mon goût, limite grandement les possibilités du jeu.
L'idée serait donc de faire appel à des scripts évènementiels pour maximiser les possibilités. C'est pour cela que j'ai pensé qu'il serait efficace de garder une partie "programmation" propre à chaque map.
J'ai d'ailleurs jeté un bref coup d'oeil aux langages de script s'interfacant à c++ (Lua / Boost:ython ...), mais le problème reste le même : impossible de faire appel à des données internes au client (la fenêtre de sortie, par exemple).

[Obsidian]

Donc, en gros, ce que tu veux faire, c'est un système de « plug-in ».

— Effectivement, c'est très courant ;
— Effectivement, ce n'est pas trivial du tout.

La difficulté va résider d'une part dans le fait de définir à l'avance des interfaces à la fois propres et suffisamment versatiles pour te permettre d'implémenter ce à quoi tu n'as pas encore pensé et, d'autre part, d'éviter les failles de sécurité, notamment quand tu les distribueras (système de signature).

Il peut être salutaire, dans ce cas, de concevoir à l'avance plus systèmes d'intérêt général qui te permettent d'emblée de faire 99% du travail, pour éviter d'avoir à recourir à du code par la suite. Par exemple, l'intelligence artificielle qui régit le comportement des PNJ s'appuie elle-même sur une base de connaissances. Si ton I.A. est suffisamment polyvalente à la base, il te suffira la plupart du temps de mettre à jour cette base.

Autrement, la plupart des « add-on » commercialisés sont souvent des applications à part entière, avec processus d'installation etc. qui, une fois lancées, s'interfacent avec les logiciels déjà en place.

Donc, pour résumer, c'est avant tout un problème de conception en amont et de distribution ensuite. Entre les deux, sur le plan technique, les plug-in prennent généralement la forme de DLL chargées a posteriori par l'application exécutée, comme tu l'as suggéré. C'est le cas des modules Apache, par exemple.