[C#] Netter programmeren

[Possstema]

Hallo, ik ben een programma in C-Sharp aan het maken, alleen heb ik een stuk code wat ik niet netjes vind, alleen kom ik er niet uit hoe dat anders te doen:

if (Operator_Stack.Count > 0 && (Operator_Stack.Peek() == "+" | Operator_Stack.Peek() == "-" | Operator_Stack.Peek() == "*" | Operator_Stack.Peek() == "/" | Operator_Stack.Peek() == "^"))

Dat kan natuurlijk niet, bij delphi zou ik iets doen als : if ( Operator_Stack.Peek in ['+','-','*','/'] ) then
Alleen heeft C# niet zoiets, ik heb het al geprobeerd met enum maar + - enz. mogen er niet in als waardes. Ook in een array stoppen en dan array.exists werkt ook niet ( exists ) herkent ie oeoa manier niet.

Kan iemand me helpen ?

[ Voor 22% gewijzigd door Possstema op 01-05-2006 15:20 ]

[NMe]

Een functie maken die een string afloopt en een peek doet voor elke char in die string?

[DroogKloot]

code:

    int c = Operator_Stack.Count();
    char op = Operator_Stack.Peek();

    if (c > 0 && (op == "+" || op == "-" || op == "*" || op == "/" || op == "^")) {
        ...
    }

of

code:

public void foo(Stack Operator_Stack) {
    int c = Operator_Stack.Count();
    char op = Operator_Stack.Peek();

    if (c > 0 && isOperator(op)) {
        ...
    }
    ...
}

private boolean isOperator(char c) {
    return (c == "+" || c == "-" || c == "*" || c == "/" || c == "^");
}

[ Voor 169% gewijzigd door DroogKloot op 01-05-2006 15:42 ]

[prototype]

Uhm, misschien niet direct relevant, maar mag ik vragen waarom je een binary or gebruikt? Ik zie niet waarom het nodig is om elke term in de rechter operand te evalueren, als je misschien al weet wat het is, immers kan de bovenste element van een stack zonder hem te verwijderen altijd maar 1 ding tegelijk zijn? Een short-circuit or is volgens mij beter?

[H!GHGuY]

C#:

if (stack.Count > 0 && "^*+-/".IndexOf(stack.Peek()) >= 0)
  doeiets();

edit:
aangepast, was idd uit de losse pols

[ Voor 65% gewijzigd door H!GHGuY op 02-05-2006 09:32 ]

[DoubleTweak]

ArrayList al = new ArrayList(new string[] {"+","-","*","/","^"});

if (Operator_Stack.Count > 0 && (al.IndexOf(Operator_Stack.Peek()) != -1))
{
MessageBox.Show("Hij zit erin!");
}

Ik weet niet of Peek een string of een char teruggeeft dus ik ben er vanuit gegaan dat het een string is.

[Verwijderd]

HIGHGuY, je bedoelt toch >= 0?
Pascal strings beginnen bij 1, C-like strings/pchars bij 0.

[Possstema]

Bedankt voor de reacties, de oplossing van HIGHGuY lijkt me de mooiste.
Prototype: Ik wist niet dat die or speciaal is, ik zal even kijken wat het verschil is ( ben nog maar beginnend programmeur ).

Ik zal ook even uitleggen wat het is. Ik maak een InFix naar PostFix convertor. En ik moet vergelijken of het element token minder "sterk" is dan de laatste operator in de stack.
Sterk: */ is sterker dan +- enz...

Edit:

Ik heb trouwens ff geprobeert om && te vervangen in &, maar dan krijg ik een error. Ik denk dat C# bij && het 2e item niet meer probeert als de eerste al false is ( Wat dus de bedoeling is )

[ Voor 21% gewijzigd door Possstema op 01-05-2006 16:55 ]

[prototype]

Possstema schreef op maandag 01 mei 2006 @ 16:41:
Bedankt voor de reacties, de oplossing van HIGHGuY lijkt me de mooiste.
Prototype: Ik wist niet dat die or speciaal is, ik zal even kijken wat het verschil is ( ben nog maar beginnend programmeur ).

Hehe, let wel op dat je bij highguy's oplossing dus >= 0 moet gebruiken
Wat betreft die or, daar zit wel een verschil in ja, dat je performancewise ook het e.e.a. kan opleveren De binary or wordt gebruikt voor bitwise operaties, en verschilt van de shortcircuit or, i.e. ||, in dat hij beide operanden evalueert. Als voorbeeld:

Java:

public static boolean links()
{
    System.out.println("Links");
    return true;
}

public static boolean rechts()
{
    System.out.println("Rechts");
    return false;
}

Elders in je code:

Java:

if (links() || rechts())
{
    //Links() is true, en volgens de waarheidstabel van een or, is dit voldoende om de expressie links() or rechts() naar true te evalueren. De short-circuit or hoeft dus niet meer rechts() te evalueren, want dat is een 'dont-care'.
    //"Links" zal weggeschreven worden naar de standaard uitvoer.
}

if (links() | rechts())
{
    //De binairy or zal ongeacht dat links() true is, en dus de expressie bij voorbaat al true is, alsnog rechts() evalueren. Dit is o.a. nodig bij bitwise operaties, i.e. bitmasken.
    //"LinksRechts" zal weggeschreven worden naar de standaard uitvoer, omdat nu beide methoden links() en rechts(), respectievelijk "Links" en "Rechts" wegschrijven.
}

Geen reden overigens om je excuses aan te bieden, was behulpzaam bedoeld, en geenzins aanvallend Iedereen is beginner geweest.

[whoami]

Possstema schreef op maandag 01 mei 2006 @ 16:41:

Ik heb trouwens ff geprobeert om && te vervangen in &, maar dan krijg ik een error. Ik denk dat C# bij && het 2e item niet meer probeert als de eerste al false is ( Wat dus de bedoeling is )

&& is een logische and operator; & is een bitwise and. Dat is dus heel iets anders, en deze 2 zijn dan ook niet 'te verwisselen'. Ik bedoel: het doel van && is heel anders dan het doel van &

De && operator gaat idd de 2de expressie niet meer evalueren, als de eerste al false is.

[Possstema]

prototype schreef op maandag 01 mei 2006 @ 16:55:
[...]

Hehe, let wel op dat je bij highguy's oplossing dus >= 0 moet gebruiken

Jep was k ook achter anders vergeet hij de ^ .

Wat betreft die or, daar zit wel een verschil in ja, dat je performancewise ook het e.e.a. kan opleveren De binary or wordt gebruikt voor bitwise operaties, en verschilt van de shortcircuit or, i.e. ||, in dat hij beide operanden evalueert. Als voorbeeld:

enz ...

Thnx, voor de duidelijke uitleg , mocht ik jullie nog ergens anders mee kunnen helpen ...