[Prog] C: variable naar 'commando'

[TechXP]

Ok even bezig met c progje...

stel:
het programma word gestart:
>> calc 2 5 * (calc a b c)
<< 10

Kortom moet met die drie dingen gevormt worden door een som.
2*5=10

Hoe kan je dat doen in c (of c++)?

Hoe kan je de input afhandelen als 'som'.
Ik kan ook wel doen dat ik kijk of ik een operator heb en dan met if-jes, maar ik denk dat het ook wel in 1 keer kan?

Dus niet:

if (c=="*") {
d = a * b;
} else if (c == "+") { ...

maar rechtstreeks:

d = a c b;

Iemand?

ik snap je vraag niet.

en dat zegt heel wat

[dafelix]

ik denk dat de TS dit wil

(bij gebrek aan C kennis kloot ik wat aan)

echo "Geef uw som op"
input<<
echo "Uw som is %d het antwoord is %d", input, calc(input)

[dragonstorm]

met een stack of lijst en een evaluator.

simpel gezegd: je analyseert de string.

er staat
"43 * 34"

dit moet je opsplitsten in:

"43" "*" "34"

dat kan met strtok, lees daar de manual page van.

"43" en "34" zet je met atoi om in integers.

dan maak je een stack. Een stack is domweg een lijst die je van FIFO (first in first out) evalueert. De functies in kwestie zijn 'pop' en 'push' - push doet er 1tje op, pop er 1tje af. Je maakt een lijst met de volgende volgorde:

* 43 34

je kunt in principe het eerste lijstelement een functie maken (die een de rest van de lijst evalueert) maar omdat je het zo simpel kunt maken kun je een evaluator als volgt maken:

struct geschakelde_lijst {
       void * data;
       struct geschakelde_lijst * next;
};

typedef struct geschakelde_lijst LINK;

int evaluate (LINK link) {
c = link -> *data; /* data is een void pointer */
a = link -> next -> *data;  /* variable a */
b = link -> next -> next -> *data; /* variable b */
switch(c) { /* c is de operator */
    case '*':
       return a * b;
}

mja, je moet t maar uitzoeken. stacks en dergelijke zijn de beste manier om het oplossen.

[TechXP]

Ok bedankt. Ik wist verder wel dat het met stacks het beste was enzo. Ik heb wel heel wat programmeerkennis. Maar het ging me om dat de input uitgevoerd kon worden eigenlijk als commando.

Dat kon met PHP wel gedaan worden. Maar ik hoopte dat het ook kon met C, maar ik moet het dus gewoon uitschrijven.

Nogmaals iig bedankt voor de reacties.

[McMotion]

dragonstorm schreef op 12-09-2005 @ 14:06 :
dan maak je een stack. Een stack is domweg een lijst die je van FIFO (first in first out) evalueert.

zou je dit verhaal misschien willen illustreren met behulp van een stapel pannekoeken?

[hemhemhem]

McMotion schreef op 18-09-2005 @ 01:15 :
zou je dit verhaal misschien willen illustreren met behulp van een stapel pannekoeken?

hmm...
wel functioneel

[McMotion]

hemhemhem schreef op 18-09-2005 @ 09:35 :

hmm...
wel functioneel

dat wel, maar niet erg praktisch.. zeker als de pannekoeken klef zijn doe mij maar gewoon een LIFO pannekoeken

[Marcade]

McMotion schreef op 19-09-2005 @ 11:54 :
dat wel, maar niet erg praktisch.. zeker als de pannekoeken klef zijn doe mij maar gewoon een LIFO pannekoeken

FIFO is gewoon beter voor het behandelen van expressies. Daar hoef je geen pannenkoeken voor te gebruiken om dat te snappen.

[McMotion]

Marcade schreef op 19-09-2005 @ 13:13 :
FIFO is gewoon beter voor het behandelen van expressies. Daar hoef je geen pannenkoeken voor te gebruiken om dat te snappen.

dan is het toch geen stack?

[Marcade]

McMotion schreef op 19-09-2005 @ 13:34 :
dan is het toch geen stack?

Nee dan is het een queue; maar dat kon je ook gelijk zeggen zonder met pannenkoeken aan te komen zetten.

[McMotion]

Marcade schreef op 19-09-2005 @ 13:59 :
Nee dan is het een queue; maar dat kon je ook gelijk zeggen zonder met pannenkoeken aan te komen zetten.

hallo ik zit hier voor m'n lol maargoed, jij zegt dat je een expressie het makkelijkst met een FIFO kan oplossen.. dat mag je ook wel gelijk uitleggen dan

[Marcade]

McMotion schreef op 19-09-2005 @ 14:06 :
hallo ik zit hier voor m'n lol maargoed, jij zegt dat je een expressie het makkelijkst met een FIFO kan oplossen.. dat mag je ook wel gelijk uitleggen dan

Het makkelijkst om expressies op te lossen is de expressie eerst op te delen en in een FIFO queue te stoppen in reversed polish notation (sp?). RPN is handig omdat je daardoor van een LIFO stack kan gebruiken en je ook geen last meer hebt van brackets. Daarnaast houd het ook rekening met 'meneervandalewachtopantwoord'.

vandaar uit is 't een kwestie van elementen uit de queue nemen en eventueel in een LIFO stack te stoppen en daarmee de bewerkingen te doen.

Practisch voorbeeld. Als je 1 + 1 hebt, stop je het in een FIFO queue in RPN:

1 1 +

Daarna begin je ze er een voor een uit te halen

1 .. Stop je in een LIFO stack
1 .. Stop je ook in een LIFO stack
+ .. Je pop'd twee uit de LIFO stack en bewerkt ze en pusht het resultaat terug de LIFO stack in.

Aan het einde kan je de uitslag van de expressie uit je LIFO stack halen.

Zo ongeveer werkt het geloof ik als ik 't goed onthouden hebt. Maar in den beginne heb je dus een FIFO queue.

[McMotion]

Marcade schreef op 19-09-2005 @ 14:14 :
Het makkelijkst om expressies op te lossen is de expressie eerst op te delen en in een FIFO queue te stoppen in reversed polish notation (sp?). RPN is handig omdat je daardoor van een LIFO stack kan gebruiken en je ook geen last meer hebt van brackets. Daarnaast houd het ook rekening met 'meneervandalewachtopantwoord'.

vandaar uit is 't een kwestie van elementen uit de queue nemen en eventueel in een LIFO stack te stoppen en daarmee de bewerkingen te doen.

Practisch voorbeeld. Als je 1 + 1 hebt, stop je het in een FIFO queue in RPN:

1 1 +

Daarna begin je ze er een voor een uit te halen

1 .. Stop je in een LIFO stack
1 .. Stop je ook in een LIFO stack
+ .. Je pop'd twee uit de LIFO stack en bewerkt ze en pusht het resultaat terug de LIFO stack in.

Aan het einde kan je de uitslag van de expressie uit je LIFO stack halen.

Zo ongeveer werkt het geloof ik als ik 't goed onthouden hebt. Maar in den beginne heb je dus een FIFO queue.

ja ok maar dan zet je het om naar RPN.. om een infix expressie in een keer op te lossen kan je het beste een een recursieve functie gebruiken (en om het om te zetten naar RPN gebruik je ook een FILO... je kan inderdaad tijdelijk je postfix expressie in een FIFO zetten, maar je kan ook gelijk doorgaan met de evaluatie van dat stukje van je RPN expressie)

[Marcade]

McMotion schreef op 19-09-2005 @ 14:24 :
ja ok maar dan zet je het om naar RPN.. om een infix expressie in een keer op te lossen kan je het beste een een recursieve functie gebruiken (en om het om te zetten naar RPN gebruik je ook een FILO... je kan inderdaad tijdelijk je postfix expressie in een FIFO zetten, maar je kan ook gelijk doorgaan met de evaluatie van dat stukje van je RPN expressie)

Persoonlijk vermijd ik recursieve functies liever om het geheel overzichtelijk te houden en geen eventuele stack overflows toe te laten. Daarnaast lijkt het me handiger in sommige gevallen om je expressie om te zetten naar RPN en dat te bewaren in een FIFO; zoals als je de expressie meerdere keren gaat uitvoeren en snelheid belangrijk is.

Maar daar heb ik vooralsnog weinig practische ervaring mee.

Blijft 't feit dat je niet betweterig met pannenkoeken aan moet komen zetten als je ook gewoon kan helpen. Voor lol kan je bij onzin terecht.

[McMotion]

Marcade schreef op 19-09-2005 @ 14:39 :
Blijft 't feit dat je niet betweterig met pannenkoeken aan moet komen zetten als je ook gewoon kan helpen. Voor lol kan je bij onzin terecht.

jamaar op onzin is iedereen zo serieus

[dragonstorm]

ahem, my bad.

Ja, een stack is idd FILO of LIFO. Maar met een queue is het in ieder geval ook wel op te lossen.

Ik heb een (incomplete) s-expressie evaluator gemaakt .

lisp_exp.tar.bz2

zou redelijk portable moeten zijn, en er zijn geen bugs bekend.

compilatie doe je zo:

# cc main.c printlist.c lisp_func.c lisp_input.c

is niet ubersimpel, werkt wel redelijk aardig
werkt met domme lijsten.