Mehrfachbelegung in einer Zeile

Ich stoße gerade auf die Anweisung in eingebettetem c (dsPIC33)

sample1 = sample2 = 0;

Würde dies bedeuten

sample1 = 0;

sample2 = 0;

Warum schreiben sie es so? Ist das gute oder schlechte Codierung?

Denken Sie daran, dass die Zuweisung von rechts nach links erfolgt und dass es sich um normale Ausdrücke handelt. Aus Sicht des Compilers also die Zeile

sample1 = sample2 = 0;

ist das gleiche wie

sample1 = (sample2 = 0);

was dasselbe ist wie

sample2 = 0;
sample1 = sample2;

Das ist, sample2 wird dann Null zugeordnet sample1 wird der Wert von zugewiesen sample2. In der Praxis dasselbe wie das Zuweisen von beiden zu Null, wie Sie es erraten haben.

Formal für zwei Variablen t und u des Typs T und U beziehungsweise

T t;
U u;

die Zuordnung

t = u = X;

(wo X ein Wert ist) wird interpretiert als

t = (u = X);

und entspricht einem Paar unabhängiger Zuweisungen

u = X;
t = (U) X;

Beachten Sie, dass der Wert von X soll Variable erreichen t “als ob” es die Variable durchlaufen hat u zuerst, aber es gibt keine Voraussetzung dafür, dass es buchstäblich so geschieht. X muss einfach in type of konvertiert werden u vor der Zuweisung t. Der Wert muss nicht zugewiesen werden u zuerst und dann kopiert von u zu t. Die beiden oben genannten Zuweisungen sind eigentlich nicht sequenziert und können in beliebiger Reihenfolge erfolgen, was bedeutet, dass

t = (U) X;
u = X;

ist auch ein gültiger Ausführungszeitplan für diesen Ausdruck. (Beachten Sie, dass diese Sequenzierungsfreiheit spezifisch für die C-Sprache ist, in der das Ergebnis einer Zuweisung ein R-Wert ist. In C++ wird die Zuweisung zu einem L-Wert ausgewertet, was erfordert, dass “verkettete” Zuweisungen sequenziert werden.)

Es gibt keine Möglichkeit zu sagen, ob es sich um eine gute oder schlechte Programmierpraxis handelt, ohne mehr Kontext zu sehen. In Fällen, in denen die beiden Variablen eng miteinander verbunden sind (z x und y Koordinate eines Punktes), sie mit “verketteter” Zuweisung auf einen gemeinsamen Wert zu setzen, ist eigentlich eine absolut gute Praxis (ich würde sogar “empfohlene Praxis” sagen). Wenn die Variablen jedoch völlig unabhängig voneinander sind, ist es definitiv keine gute Idee, sie in einer einzigen “verketteten” Zuweisung zu mischen. Vor allem, wenn diese Variablen unterschiedliche Typen haben, was zu unbeabsichtigten Konsequenzen führen kann.

Ich denke, es gibt keine gute Antwort auf C-Sprache ohne tatsächliche Assembly-Liste 🙂

Also für ein vereinfachtes Programm:

int main() {
        int a, b, c, d;
        a = b = c = d = 0;
        return a;
}

Ich habe diese Assembly (Kubuntu, gcc 4.8.2, x86_64) mit -O0 Option natürlich 😉

main:
        pushq   %rbp
        movq    %rsp, %rbp

        movl    $0, -16(%rbp)       ; d = 0
        movl    -16(%rbp), %eax     ; 

        movl    %eax, -12(%rbp)     ; c = d
        movl    -12(%rbp), %eax     ;

        movl    %eax, -8(%rbp)      ; b = c
        movl    -8(%rbp), %eax      ;

        movl    %eax, -4(%rbp)      ; a = b
        movl    -4(%rbp), %eax      ;

        popq    %rbp

        ret                         ; return %eax, ie. a

gcc ist also eigentlich das ganze Zeug verketten.

Sie können selbst entscheiden, ob diese Art der Codierung gut oder schlecht ist.

1. Sehen Sie sich einfach den Assembler-Code für die folgenden Zeilen in Ihrer IDE an.

2. Ändern Sie dann den Code in zwei separate Zuweisungen und sehen Sie sich die Unterschiede an.

Darüber hinaus können Sie auch versuchen, Optimierungen (sowohl Größen- als auch Geschwindigkeitsoptimierungen) in Ihrem Compiler ein- und auszuschalten, um zu sehen, wie sich dies auf den Assemblercode auswirkt.

Die Ergebnisse sind die gleichen. Einige Leute ziehen es vor, Zuweisungen zu verketten, wenn sie alle den gleichen Wert haben. An diesem Ansatz ist nichts auszusetzen. Ich persönlich finde das vorzuziehen, wenn die Variablen eng verwandte Bedeutungen haben.

Wie bereits bemerkt,

sample1 = sample2 = 0;

ist gleich

sample2 = 0;
sample1 = sample2;

Das Problem ist, dass riskant fragte nach eingebettetem c, die häufig verwendet wird, um Register direkt anzusteuern. Viele der Register des Mikrocontrollers haben einen anderen Zweck bei Lese- und Schreibvorgängen. Also im Allgemeinen Es ist nicht das Gleichewie

sample2 = 0;
sample1 = 0;

Sei beispielsweise UDR ein UART-Datenregister. Das Lesen von UDR bedeutet, den empfangenen Wert aus dem Eingangspuffer zu erhalten, während das Schreiben in UDR bedeutet, den gewünschten Wert in den Sendepuffer zu stellen und die Kommunikation herzustellen. In diesem Fall,

sample = UDR = 0;

bedeutet folgendes: a) Wert Null per UART übertragen (UDR = 0;) und b) Eingabepuffer lesen und Daten darin platzieren sample Wert (sample = UDR;).

Sie konnten sehen, dass das Verhalten eingebetteter Systeme viel komplizierter sein könnte, als der Codeschreiber erwarten würde. Verwenden Sie diese Schreibweise beim Programmieren von MCUs sorgfältig.

sample1 = sample2 = 0;

bedeutet

sample1 = 0;
sample2 = 0;  

dann und nur dann, wenn sample2 früher erklärt wird.
So geht das nicht:

int sample1 = sample2 = 0; //sample1 must be declared before assigning 0 to it