Sinon tu le mets en dur dans le code et tu transformes cela en feature.
Plus sérieusement, c'est pas possible d'utiliser facilement un moteur de script (javascript) en c# ?
Sinon tu le mets en dur dans le code et tu transformes cela en feature.
Plus sérieusement, c'est pas possible d'utiliser facilement un moteur de script (javascript) en c# ?
Tu peux, mais je trouve ça un peu con d'utiliser du JS sur une appli lourde.
Et hop:
Code:$formula = '(5 + 4) * 2'; function parse($formula) { $string = ''; // première étape : chercher les parenthèses et calculer le contenu for ($i = 0; $i < strlen($formula); ++$i) { $char = substr($formula, $i, 1); if ($char == '(') { // on cherche la parenthèses fermante $numParenthese = 0; $start = (++$i); for (; $i < strlen($formula); ++$i) { $char2 = substr($formula, $i, 1); if ($char2 == '(') { ++$numParenthese; } else if ($char2 == ')' && ($numParenthese--) == 0) { // on est à la fin de notre parenthèse, on appelle la fonction parse par récursivité pour calculer le contenu $string .= parse(substr($formula, $start, $i - $start)); continue 2; } } throw new RuntimeException('Il manque une parenthèse fermante'); } else { $string .= $char; } } // $string contient désormais notre formule sans parenthèses $additions = explode('+', $string); $somme = 0; foreach ($additions as $a) { $multiplications = explode('*', $a); $produit = 1; foreach ($multiplications as $m) $produit *= intval($m); $somme += $produit; } return $somme; } echo parse($formula);
Je connais pas le C# mais ça doit être convertible.
Sachant que '.=' c'est l'opérateur de concaténation pour ajouter la string à droite à la fin de la string à gauche. Et explode() découpe la string en utilisant le premier paramètre comme séparateur, et renvoie un tableau du découpage.
C'est vraiment du code de bourrin, mais bon.
EDIT : j'avais oublié un '.' dans le code
EDIT 2 : mini bug corrigé
---------- Post added at 18h43 ---------- Previous post was at 18h37 ----------
Ben c'est pas con, y a plein de jeux vidéos qui utilisent lua ou python. Donc pourquoi pas JS.
Lua par exemple a été spécifiquement conçu pour être intégré à l'intérieur d'appli plus lourdes, il n'a pas été conçu pour s'exécuter en "stand-alone".
Dernière modification par Tomaka17 ; 28/12/2012 à 20h01.
Rust fanboy
Oui
Les soustractions ne marchent pas mais tu peux écrire "5 + -3".
Après j'avoue qu'il aurait fallu améliorer la partie en bas, parce que pour rajouter des opérateurs c'est assez coton. Comme dit c'est du code bourrin.
Tu peux essayer en copiant-collant le code là : http://sandbox.onlinephpfunctions.com/ (j'ai pas trouvé de meilleur service)
Il y a un bouton "share" mais il faut s'inscrire.
Rust fanboy
Tiens, d'ailleurs, ça m'étonne qu'en C# il n'y ai rien pour faire ce que tu veux faire dans les classes de base... Enfin je dis ça moi...
http://sandbox.onlinephpfunctions.co...12d6adbe226d8c
vs
https://www.google.fr/#hl=en&tbo=d&s...=1920&bih=1082
Pourtant j'ai remplacé les / et les - par des + et des *
"Dieu est mort" · "Si le téléchargement c’est du vol, Linux c’est de la prostitution."
Ouai non mais c'est une petite couille que j'ai remarquée, faut enlever la ligne 24 avec le ++$i
En fait ça sautait un caractère après chaque parenthèse fermante. Je l'ai pas remarqué vu que je mettais des espaces autour.
http://sandbox.onlinephpfunctions.co...8d348c3438e2fe
Rust fanboy
J'ai fait une conversion vite fait en C#, mais ça ne marche pas, j'ai du me planter quelque part
m ne choppe pas la bonne valeur "(5+3)*2" choppe comme valeur 5+32Code:string sr = ""; string Formule = Tb_Entree.Text; for (int i = 0; i < Formule.Length; ++i) { string char0 = Formule.Substring(i,1); if (char0 == "(") { // on cherche la parenthèses fermante int numParenthese = 0; int start = ++i; for (; i < Formule.Length; ++i) { string char02 = Formule.Substring(i,1); if (char02 == "(") { ++numParenthese; } else if (char02 == ")" && (numParenthese--) == 0) { sr += Formule.Substring(start, i - start); ++i; // on saute après la parenthèse fermante break; } } //throw new RuntimeException('Il manque une parenthèse fermante'); } else { sr += char0; } } string[] additions = sr.Split(new string[]{"+"}, StringSplitOptions.RemoveEmptyEntries); int somme = 0; foreach (string a in additions) { string[] multiplications = sr.Split(new string[]{"*"},StringSplitOptions.RemoveEmptyEntries); int produit = 1; foreach (string m in multiplications) produit *= int.Parse(m); somme += produit; } Tb_Sortie.Text = somme.ToString();
Edit :
string[] multiplications = sr.Split(new string[]{"*"},StringSplitOptions.RemoveEmptyEntries); doit devenir string[] multiplications = a.Split(new string[]{"*"},StringSplitOptions.RemoveEmptyEntries);
Et ça marche sauf quand je mets des parenthèses, je pense que c'est la fonction "continue" que je pige pas
Euh ouai t'as oublié la moitié dans ta conversion
Déjà j'ai mis le tout dans une fonction parse(), c'est pas pour rien puisque la fonction s'appelle elle-même à la ligne 23.
Et le "continue 2" ça veut dire continue mais pour le for à la ligne 8 et pas celui à la ligne 16. Je pense que continue 2 existe aussi en C#.
Et puis faut enlever la ligne "++i" au dessus du continue, c'était une coquille dans mon code.
Rust fanboy
Effectivement
Sinon le "continue" ne marche pas de la même façon en PHP et en C#, si je suis bien le tien, théoriquement si je fais i +=2 ça devrait revenir au même non ?
Pour apprendre les bases de la programmation tu es allé fort.
Sinon, si tu veux vraiment pouvoir évaluer des expressions complexes, tu finiras par faire parser comme le suggère rOut. Ce n'est pas franchement compliqué, largement plus efficace que la plupart des codes que les gens vont écrire pour interpréter le truc. Mais c'est pas de l'initiation .
Si tu veux faire un truc simple et qui soit didactique, tu peux commencer par une recherche des lexèmes (constantes, parenthèses, opérateurs), flanquer ça dans un conteneur quelconque et procéder par réécriture successive en remplaçant les expressions élémentaires comportant des constantes par des constantes et commençant par les opérateurs prioritaires.
Je suis pas sur d'être clair, mais y a moyen d'embrayer proprement sur la programmation fonctionnelle, la récursivité etc...
---------- Post added at 02h17 ---------- Previous post was at 02h15 ----------
Ah, et pour ne pas connaître la polonaise inverse, il faut ne pas avoir eu de calculette HP et avoir... disons... un certain age.
Ahhh ma HP34C (call me old timer)
Ne mets pas de "i += 2". Comme je l'ai dit il faut supprimer le "++i" juste au dessus de ton break.
Si tu remplaces "continue 2" par "break" ça marche à condition d'enlever le throw. Si tu veux le remettre il faudrait que tu rajoutes une variable "if (!onEstPasseParBreak) throw ...".
---------- Post added at 09h37 ---------- Previous post was at 08h37 ----------
Hop, version 2 : http://jsfiddle.net/SPQPv/2/
Nouveau : soustractions, divisions, priorité des opérateurs, nombres à virgule, parsing manuel des nombres, non-utilisation du split.
À part les fonctions pour push/pop et insérer des éléments dans un tableau, je n'utilise plus aucune fonction du langage.
EDIT : en fait ça marche pas sévère mon truc, mais bon là j'ai la flemme de chercher les bugs
Rust fanboy
Non, c'est juste que sa question m'a intrigué, c'est un peu comme ici quand on a parlé de conversions en chiffres romains, je trouve le problème sympa à résoudre
C'est plus le côté méthodologique/théorique qui m'intéresse, quelque soit le langage.
Et ça a excité Tomaka aussi
Je vais essayer de parser et de calculer en Zepolak inversé pour le fun.
Tenez une petite question en POO avec... javascript (hohoho).
Est-ce que c'est possible, dans une classe fille, d'accéder à un attribut de la classe mère? Si oui comment?
protected
Après je savais même pas qu'on peut faire de la POO en javascript...
google m'a redirigé là dessus:
http://nemisj.com/protected-javascript/
Ca n'existe pas la POO en Javascript.
C'est un langage de prototype, et quelques hurluberlus essayent de retranscrire les concepts de classe et d'héritage parce qu'ils ne savent rien faire d'autre que de la POO.
Rust fanboy
C'est un peu fort de dire que cela n'existe pas vu qu'il y a bien le concept d'objet, d'héritage avec Object.prototype etc... Voir https://developer.mozilla.org/en-US/...ted_JavaScript
Certains huluberlus essayent de faire n'importe quoi en javascript.
moi.org
Non mais en Javascript les objets sont tout simplement des tableaux associatifs comme on en a en PHP ou en lua par exemple.
La propriété "prototype" ça veut dire "si on essaye d'accéder à une valeur qui n'est pas dans l'objet [ie. dans le tableau], on essaye ensuite dans le prototype au lieu de renvoyer tout de suite une erreur. Puis dans le prototype du prototype, puis dans le prototype du prototype du prototype, et ainsi de suite.".
C'est pas plus compliqué que ça. Si tu veux tu peux écrire "a.prototype = b" et deux lignes plus loin "a.prototype = c". Si tu me trouves un langage orienté objet qui est capable de changer en plein milieu du programme la classe dont hérite une autre classe, ça m'intéresse.
Si des mecs qui se mettent au javascript après avoir fait 20 ans de POO ont envie de dire que en fait les objets ce sont des classes, et que en fait le prototype c'est de l'héritage, et que en fait bla et en fait bla, ça veut pas dire pour autant que c'est comme ça que ça marche.
En attendant le mot-clé "class" n'est pas utilisé en javascript (mais il est réservé pour une éventuelle utilisation future), et dès les premières pages du standard tu peux lire "javascript does not use classes" et "unlike classes-based languages, javascript does blabla".
Et le fait d'adapter les concepts de POO au javascript non seulement c'est pas justifié, mais en plus tu te prives de l'incroyable flexibilité du langage en t'imposant des normes comme ça.
Rust fanboy
Hey pas besoin de m'agresser hein, j'essaie juste de comprendre comment fonctionne ce langage (j'ai beaucoup de mal avec ) et sur internet, on lit vraiment tout et n'importe quoi donc bon...
Toutes ces années où j'écrivais :
Et où on me disait "explicit ça sert à rien quand il y a plusieurs paramètres", et où je répondais "ouai je sais que ça sert à rien mais je le fais par principe".Code:class Foo { explicit Foo(int param1, int param2, int param3); };
Maintenant qu'il y a l'uniform initialization, j'ai enfin une vraie raison de le faire
Rust fanboy
http://channel9.msdn.com/posts/C-and...lank-and-blank
TL;DR :
Quand on écrit "int a" et qu'on lit simultanément la valeur de "a" depuis plusieurs threads, ça ne pose aucun problème puisque c'est une simple lecture. Par contre si on lit et qu'on écrit simultanément, ou bien qu'on écrit plusieurs fois simultanément sur "a", là il y a une méchante data race et un undefined behavior.
En gros tant qu'on accède à "a" uniquement de manière const on peut le faire autant de fois qu'on le veut simultanément.
Là où ça devient intéressant c'est qu'en C++11, les mecs ont fait la même chose avec la lib standard.
Par exemple si on a un std::string ou un std::vector, hé bien on peut y accéder autant de fois qu'on veut simultanément tant qu'on n'utilise que des méthodes const. Par contre si on utilise une méthode non-const et méthode const simultanément, ou deux méthodes non-const, là c'est undefined.
Et les mecs encouragent les développeurs C++ à faire pareil avec leur classes à eux. En gros const avant c'était un simple indicateur "l'objet ne sera pas modifié", et maintenant il devient également un indicateur "tu peux accéder autant de fois que tu veux simultanément à des méthodes const".
Rust fanboy
Intéressant. Si ça continue, peut-être qu'un jour on pourra écrire un programme parallèle en C++ qui ne soit pas un gros comportement indéfini.
Si j'ai bien compris, ce que Herb veut dire est que const et mutable n'ont fondamentalement rien à voir avec la "constance". Ils sont passés d'une sémantique un peu vague de "ouais, en fait c'est comme si c'était constant, alors t'occupes pas des trucs que je modifie" à une sémantique précise de thread-safety. Genre on pourrait changer le mot-clef "const" en "threadsafe" et "mutable" en "synchronized" en gardant la même sémantique sans trop que ça se voit...
TL;DR: on peut faire des classes avec toutes les fonctions membres déclarées const avec des paramètres const et toutes les variables membres mutable, c'est normal et c'est même encouragé, c'est du C++11.
Pour ça, essayez go.
une balle, un imp (Newstuff #491, Edge, Duke it out in Doom, John Romero, DoomeD again)
Canard zizique : q 4, c, d, c, g, n , t-s, l, d, s, r, t, d, s, c, jv, c, g, b, p, b, m, c, 8 b, a, a-g, b, BOF, BOJV, c, c, c, c, e, e 80, e b, é, e, f, f, f, h r, i, J, j, m-u, m, m s, n, o, p, p-r, p, r, r r, r, r p, s, s d, t, t
Canard lecture
T'es pas censé coder des classes qui sont entièrement thread-safe. Uniquement des classes qui sont thread-safe quand on les lit (comme c'est le cas avec les types de base), c'est à dire quand on y accède via const.
T'es censé mettre le mutex à l'extérieur de la classe, et gérer si c'est nécessaire le vérouillage à l'endroit où tu gères tes threads.
Le mot-clé const ne change pas, ça veut toujours dire que la classe ne sera pas modifiée. Ce qui est nouveau c'est qu'on peut se dire qu'une classe qui ne sera pas modifiée peut être lue simultanément par plusieurs threads.
Rust fanboy
Je suis censé, oui, mais si moi j'ai pas envie ?
Y a-t-il quelque chose dans la norme qui m'empêche de faire des classes complètement thread-safe avec des const et des mutable de partout et les utiliser avec la lib standard ?
Et si j'ai bien suivi l'explication, écrire "mutable mutex truc" ça paraît moche et redondant. On sait bien qu'un mutex est toujours "mutable" (thread-safe en lecture/écriture). On aurait pu déclarer les fonctions de la classe mutex en const, ça aurait évité de se trimballer le mutable.
J'avais plutot l'impression qu'il voulait ajouter une sémantique de réentrance au qualifier const. Auquel cas, le mutable sera plutôt déconseillé, le but étant d'avoir toutes les méthodes const réentrantes pour qu'une hiérarchie d'objet (au sens relationnel, pas d'héritage) sur laquel on appelle une méthode const, toute la chaîne d'appel soit réentrante jusqu'au POD types qui constitueraient les membres les plus simples (d'où l'intéret de préciser que ca marche pour int. J'ai pas regardé la vidéo, mais il doit dire que ca marche pour les POD non?).
Ben tu fais comme tu veux.
Je te répondais parce que t'avais l'air de te fouttre de leur gueule, alors que je trouve que c'est aussi une très bonne solution qu'ils ont là.
Si tu écris encore des trucs non-réentrants en 2013, c'est que t'es suicidaire
Autant rendre une fonction thread-safe ça lui fait bouffer plus de ressources donc pas forcément conseillé partout, autant rendre une fonction réentrante faut le faire partout partout.
Rust fanboy
Je trouve aussi que c'est une très bonne idée, hein. C'est une étape dans le bon sens. S'il y a quelque chose à regretter, ça serait juste qu'il ait fallu attendre 2011 pour avoir ce genre de garantie. Mais comme dit Herb, les programmeurs n'ont pas attendu C++11 pour supposer que const implique thread-safe. On légitime une pratique existante et c'est très bien.