C Code mit CC65 - nächste DAU-Frage

[matashen]

ich machs kurz

wie definiere ich zwei Bedingungen

wie
if (i=1) and (j=0) anweisung1;

Das and will der CC65 nicht akzeptieren also geh ich davon aus das C-Code hier wieder irgend einen Blödsinn vorschreibt und mit den drei Buchstaben und nix anfangen kann.

Noch ne Frage wäre.
Wie mach ich nen Zufallsgenerator?

Schon mal danke für die Hilfe

Gruß Matthias

[tuxie]

SO?

if (i=1) && (j=0) anweisung1;

[Dennis Schulmeister]

Ingo hat Recht. In C-ähnlichen Sprachen werden die Operatoren nicht ausgeschrieben. Stattdessen gibt es Symbole

& bzw. && - AND
| bzw. || - OR
! - NOT
== - Prüfung auf Gleichheit !!!!! (Bitte nicht = verwenden, da das der Zuweisungsoperator ist!!!)

Der Unterschied zwischen &, | und &&, || ist, dass im letzteren Fall die Auswertung des Ausdrucks (von links nach rechts) abbricht, sobald das Ergebnis klar ist. z.B. false && true wertet nur den linken Teil aus, da durch den AND-Operator der Ausdruck nicht mehr true werden kann ...

Im Übrigen kann ich nur empfehlen, auch einzeilige Blöcke als Blöcke zu definieren. Also so:

if ((i == 1) && (j == 0)) {
  Anweisung;
  Anweisung;
  ...
}

Alles Andere ist meiner Meinung nach sclechter Stil und führt nur zu schwer zu findenden Fehlern!

Wg. dem Zufallsgenerator könntest du mal nach einer Funktion rand() suchen. Hat CC65 eine math.h? Da ist der sicher drin.

Gruß,
Dennis

[matashen]

Danke für die ausführliche Darlegung.

Ein Math.h hat der CC65 nicht.

Gruß Matthias

[Dennis Schulmeister]

Einen für den Hausgebrauch ausreichenden Zufalszahlengenerator kann man einfach selbst programmieren als:

(Primzahl ^ k) mod n;  k bei jedem Zug hochziehen, n = Maximum

Meine ich zumindest, im Hinterkopf zu haben ...

Gruß,
Dennis

[matashen]

Ich zähl momentan einfach die Schleifendurchläufe bis eine Taste gedrückt wird. Funktioniert momentan auch ganz brauchbar...

Aber danke. Werds mir mal notieren und testen...

[gstoll]

Leer

[gstoll]

Leer

[Dennis Schulmeister]

Hallo Gerhard,

du hast schon recht. & bzw. | nehmen eine Bit-Weise verknüpfung vor. Die Auswirkung ist, dass ein Ausdruck

op1 & op2 & op3 ...

komplett ausgewertet wird.

&&, || gehen aber nicht Bit-Weise vor. Das heißt, folgende Ausdrücke werden nicht vollständig ausgewertet.

true || false || true ...  ===> true, gleich nach dem ersten true.
false && true && true ... ===> false, gleich nach dem ersten false.

Für ein ODER genügt es, wenn ein Operand true ist, damit der komlette Ausdruck true wird. Umgekehrt verhält sich UND. Wenn mind. ein Operand false ist, ist der gesamte Ausdruck false. Das heißt, der Computer kann ein wenig Rechenzeit sparen, wenn er mit der Auswertung abbricht, sobald das Ergebnis des Ausdrucks ohnehin feststeht.

So ist folgender Code z.B. sicher, das heißt, es findet kein Zugriff auf ein nicht initialisiertes Array-Element statt.

Code: [Auswählen]

int i = 0;
int array[5] = {1, 1, 0, 1, 1};

for (i = 0; i < 100; i++) {
  if ((i < 5) && (array[i] == 1)) {
    // Irgendwas ...
  }
}

Obwohl i bis 100 hochgezählt wird, wird der Ausdruck (array[ i ] == 1) nur ausgewertet für (i < 5). Würde statt && auf & zurückgegriffen werden, wäre dem nicht so.

Gruß,
Dennis

[simonsunnyboy]

Ist dieses Verhalten im Standard für ANSI C enthalten?
Ich würde nämlich per se von einem solchen Verhalten niemals ausgehen wollen...praktisch ist das nur, solange sich wirklich _jeder_ Compiler daran hält, und genau das ist das Problem.

[Dennis Schulmeister]

Nicht nur in C selbst, sondern in allen C-ähnlichen Sprachen ist das so. Das ist ja gerade der Witz an den logischen Operatoren verglichen mit den Bit-Operatoren.

Code: [Auswählen]

/* C-Version */
#include <stdio.h>

int f1() {
    printf("f1: false\n");
    return 0;
}

int f2() {
    printf("f2: true\n");
    return 1;
}

int main() {
    if (f1() && f2()) {
        printf("Beide true!\n");
    }

    printf("Ende!\n");

    return 0;
}


Code: [Auswählen]

/* Java-Version */
public class logAnd {
    public static boolean f1() {
        System.out.println("f1: false");
        return false;
    }

    public static boolean f2() {
        System.out.println("f2: true");
        return true;
    }

    public static void main(String[] sArgs) {
        if (f1() && f2()) {
            System.out.println("Beide true...");
        }

        System.out.println("Ende!");
    }
}


Code: [Auswählen]

/* PHP-Version */
<?php
    function f1() {
        echo "f1: false<br/>";
        return false;
    }

    function f2() {
        echo "f2: true<br/>";
        return true;
    }

    if (f1() && f2()) {
        echo "Beide true<br/>";
    }

    echo "Ende<br/>";
?>

Verhalten sich alle gleich. Die Ausgabe ist immer:


f1: false
Ende!


Gruß,
Dennis

[Dennis Schulmeister]

BTW: http://en.wikipedia.org/wiki/Iso646.h

Könnte man auch ganz easy selber machen

#define and &&
...

Gruß,
Dennis

[matashen]

Na da hab ich ja wieder was ausgelöst...

[Dennis Schulmeister]

Hehehe, ja und?

[simonsunnyboy]

Nicht nur in C selbst, sondern in allen C-ähnlichen Sprachen ist das so. Das ist ja gerade der Witz an den logischen Operatoren verglichen mit den Bit-Operatoren.

Code: [Auswählen]

/* C-Version */
#include <stdio.h>

int f1() {
    printf("f1: false\n");
    return 0;
}

int f2() {
    printf("f2: true\n");
    return 1;
}

int main() {
    if (f1() && f2()) {
        printf("Beide true!\n");
    }

    printf("Ende!\n");

    return 0;
}


Code: [Auswählen]

/* Java-Version */
public class logAnd {
    public static boolean f1() {
        System.out.println("f1: false");
        return false;
    }

    public static boolean f2() {
        System.out.println("f2: true");
        return true;
    }

    public static void main(String[] sArgs) {
        if (f1() && f2()) {
            System.out.println("Beide true...");
        }

        System.out.println("Ende!");
    }
}


Code: [Auswählen]

/* PHP-Version */
<?php
    function f1() {
        echo "f1: false<br/>";
        return false;
    }

    function f2() {
        echo "f2: true<br/>";
        return true;
    }

    if (f1() && f2()) {
        echo "Beide true<br/>";
    }

    echo "Ende<br/>";
?>

Verhalten sich alle gleich. Die Ausgabe ist immer:


f1: false
Ende!


Gruß,
Dennis

Ich meinte eher das Verhalten mit dem Schleifenzähle rund dem Array.

[Dennis Schulmeister]

Wieso? Kommt duch aufs gleiche heraus.

Wenn der Ausdruck

((i < 5) && (array[ i ])) lautet, wird array[ i ] nicht ausgewertet, wenn (i < 5) nicht zutrifft.

Dem Operator && bzw. || ist es ja egal, woher die Werte kommen, die er verknüpft. Ob das nun eine Funktion ist, ein logischer Ausdruck, eine Konstante, ...

Gruß,
Dennis