Ouais et au vu de tout ce que j´ai à apprendre et maîtriser avant même de songer à l´algorithme de mon programme, j´ai pas mal de boulot ^^ Bon, j´ai enfin trouvé à quoi allaient me servir les heures d´allemand

j´ai pas mal travaillé sur le sujet et il faut effectivement te creer un petit analyseur lexical et syntaxique. pour ça, tu dois d´abords te creer une grammaire de ton language mathematique.
Le language C est très bien adapté. Tu peux utiliser C++ si tu considères les éléments de ta grammaire comme des objets mais ce n´est absolument pas obligatoire.
Si tu veux trouver de plus amples renseignement là dessus je te conseille de regarder du coté de la création de compilateur.

il y a beaucoup trop de chose dans la création de compilateur qui dépassent clairement son problème.
Regardes du coté des expressions régulières puis des grammaires hors contexte.

Pouh j´ai vraiment pas de temps à moi ^^ J´ai juste pu voir sur un tuto chopé sur dvpez.com ce qu´étaient les arbres (enfin les bases des bases).
Je veux juste savoir une chose, est-il nécessaire que j´apprenne les surcharges ? Je veux pas me lancer dans un truc qui me prendra du temps si ça ne me servira à rien.
Encore merci pour votre aide

non, la surcharge est probablement inutile. Ca apporte une ecriture sympathique, mais rien d´impératif. (AMHA bien sur)

« Je veux juste savoir une chose, est-il nécessaire que j´apprenne les surcharges ? Je veux pas me lancer dans un truc qui me prendra du temps si ça ne me servira à rien. »

Je comprend pas comment un mec intéressé par les maths peut dire ça :D

justement quelqu´un intéréssé par les maths (devrait) se rends bien compte que c´est foutrement pareil... surcharge ou pas, ce n´est que du sucre syntaxique.

Ouais mais les maths ça prend pas de temps ^^
Bon : arbre, Lex&Yacc. Ca me fait déjà un sacré boulot, ne serait-ce que pour maîtriser les arbres à fond.
Merci, je m´y mets dès ce week-end

Moi j´aime bien les surcharges d´opérateurs, mais pas a tout va quand meme.

Car y´a quand meme un piege.
Imagine que vous ayez une classe Vecteur (qui a toute l´arithmétique vectorielle surchargée)
(j´en ai une, j´avoue qu´elle est tres pratique, quand meme, donc la critique que je vais faire ne vient pas du fond du coeur, c´est juste pour faire l´avocat du diable)

Vous faites :

Vecteur i;
Vecteur j;
Vecteur k;
double a;
double b;
.....

k = a*i+k*j;

Dans la derniere ligne, entre les opérations, les créations de vecteurs temporaires, et les recopies, il n´est pas trivial d´évaluer une complexité. Voila ou est le piege, une telle ligne appelle finalement pas mal de fonctions, et peut ralentir dans certains cas.
(bon, si je manipule des vecteurs qui, en interne, ont juste 3 double, pas trop de soucis), mais si je fais l´arithmétique matricielle et que je manipule des matrices 200*200, la, je vais souffrir...

Voila, c´était une petite parenthese sur les opérateurs

*

k = a*i+b*j;

(ben, on fait tous des erreurs de frappe, lol)

personnelement, je déteste la redéfinition d´opérateur parcequ´elle ne fait jamais ce que je veux.
Par exemple, Il est difficile de munir un espace d´un ordre partiel.
On estime généralement que les opérateurs < et >= ne renvoye pas la meme valeur. Ou encore que >= renvoye la valeur de > || ==. Ce qui n´est pas vrai quand on considere des ordres partiels.

On peut également avoir a redéfinir plusieurs opératuer de multiplication. typiquement produit scalaire et vectoriel. Certes tu va dire que tu peux toujours prendre un autre opérateur que *. Tu peux choisir . ou encore ^. Mais ces opérateurs ont déja plus ou moins un sens.
Cela nous amène a des ´std::cout << "toto" << std::iosjesaisplusquoi::hex;´

On peut également être amener a redéfinir des opérateurs qui introduisent des confusions énorme, comme l´opérateur + sur des string pour faire de la concaténation. Pour moi + est un opérateur commutatif (c´est a dire que a+b = b+a), ce qui n´est pas vrai pour la concaténation.

Bref, je n´aime pas trop la redéfinition d´opérateur...

En fait, en y repensant, j´aime bien la redéfinition de l´opérateur () parcequ´il n´introduit pas de confusion je trouve.
On a UN objet qui représente UNE fonction (éventuellement une classe de fonction pour pouvoir prendre un nombre variable de paramètre)

les operateurs peuvent etre bien pratiques pour optimiser, et que l´on ne veut pas ecrire bcp de noms de fonctions.
Par exemple une bonne utilisation des templates (cf mon implementation okay-ish a
http://potages.googlepages.com/sources) permet de ne pas creer d objets temporaires et de diminuer l´utilisation de la stack pour une operation du type k = a*i+b*j; alors que ca aurait bcp bcp plus long a ecrire sans les operateurs.

http://potages.googlepages.com/sources meme

« les operateurs peuvent etre bien pratiques pour optimiser, et que l´on ne veut pas ecrire bcp de noms de fonctions. »

La surcharge d´opérateurs ne permet pas d´optimiser quoi que ce soit, non ? Soit on s´est mal compris, soit je ne suis pas d´accord avec toi (je me doutais que je ne serais pas d´accord avec quelqu´un qui écrit "bcp" :-° ).

en effet la redéfinition d´opérateur n´optimise rien du tout. Ce que les opérateurs calculs aurait du etre calculé autremnet.
Par contre ca permet plus facilement de reprendre du code template déjà écris.

Kufa, je ne suis pas bien sur d´avoir compris, tu te sers des template pour faire un genre d´arbre d´évaluation a la compilation que tu evalue de facon itérative et du coup sans objet temporaire, c´est ca ?

oui clairement les operateurs n optimisent rien, mais ils aident a l ecriture, et ce bcp lorsqu on optimise (a l aide de template par exemple).

@godrik: mon code est une version un peu plus safe et cross-platforme d un article (gamedev?), bizarre que je l ai pas mentionne, je vais regarder dans mon sourcesafe car je suis sur que j avais le lien dans mes commentaires. L article etait tres bien, et expliquait en profondeur tout cela.

Mon code a deux principaux objectifs:
- ne pas avoir d objets temporaires lorsqu on peut s en passer
- evaluer les x,y,z separement, et une seule fois (si possible) par expression (pour eviter de devoir sauver des variables sur la pile)
Ca se fait a l´aide de template: l´idee est de travailler sur des expressions a la place de vecteurs. Par exemple si tu as k= a*i+b*j; comme cite plus haut, voici ce qui se passe (en simplifie, et dans l ordre)

a*i -> cree un vec_exp2<vector3d,float,mul> (appelons ca expA)

b*j -> cree un vec_exp2<vector3d,float,mul> (expB)

expA*expB -> cree un vec_exp2<type de expA,type de expB,mul> (expC)

k = expC va appeller une fonction inline, qui va evaluer d abord expC.evaluate(0) pour x, expC.evaluate(1) pour y, etc.
Comme tout est inline et comme on utilise partout des references constantes, aucune des expressions n est vraiment stockee en memoire/stack, ce qui est bien pratique. Le code source en sortie est bien impressionant par rapport a une implementation habituelle, par contre si on veut faire du simd cette version est pourrie.
Sans les operateurs, ca deviendrait vraiment tres moche a ecrire.. vraiment..