2016-04-12 11 views
2

Lassen Sie uns sagen, ich habe zwei SubroutinenALLGEMEINEN Block gemeinsam genutzte Variablen

SUBROUTINE S2909              
    COMMON X,Y 
    X =2; 
    Y =3; 
    END 

    SUBROUTINE S2900              
    COMMON X,Y 
    //display X and Y 
    END 

einem gemeinsamen Block zur gemeinsamen Nutzung Variablen verwendet wird, so bedeutet das, wenn der Wert von X, Y, die in dem Unterprogramm aktualisiert wird S2909 gleiche sein wird wie im Unterprogramm S2900?

Antwort

1

Aus meinem Verständnis, ja, die Variablen sind im gesamten Programm geteilt. Ihre Werte hängen von der Reihenfolge ab, mit der die Subroutinen aufgerufen werden.

Das folgende Programm

program test 
real x,y 
common x,y 

x = 1 
y = 2 

write(*,*) x,y 
call changevals 
write(*,*) x,y 

end program test 


subroutine changevals 
real x,y 
common x,y 

x = 12 
y = 13 

end subroutine changevals 

Ausgänge

1.00000 2.00000 
12.00000 13.00000 
1

Dieser Austausch ist in der Tat der Punkt der gemeinsamen Blöcke. Insbesondere erlaubt die common-Anweisung so genannte Speicherverknüpfung zwischen verschiedenen Entitäten in einem Programm.

Also, die Entitäten X und Y im Unterprogramm S2909 sind Speicher mit den Organisationen, die X und Y im Unterprogramm S2900. Änderungen an dem Wert in einer Entität X werden durch die andere Entität X widergespiegelt.

Es gibt jedoch ein paar Dinge zu beachten.

In den common Aussagen der Frage stützt sich dies auf das, was als blank common bekannt ist. Dies ist, was passiert, wenn es kein Name für einen gemeinsamen Block, wie in der Erklärung

common /named/ x, y 

Dies ist bemerkenswert, weil Sie versuchen, zu verallgemeinern, das Verhalten in dieser Frage zu named common blocks may be troublesome angegeben ist.

Die Entitäten an den verschiedenen Stellen, an denen die allgemeinen Blöcke referenziert werden, sind nicht nach Namen, sondern nach Reihenfolge in der Speichersequenz verknüpft. Das bedeutet, dass die Pflege mit sagen gemacht werden müssen

SUBROUTINE S2909 
COMMON X,Y 
END 

SUBROUTINE S2900 
COMMON Y,X 
END 

Aber meine Antwort hat wirklich zwei Punkte zu machen, und die oben war nur eine Präambel es Antwort artig zu machen.

Zuerst werde ich einen pathologischen Fall erwähnen, den ich nicht in der Wildnis erwarten würde.

Die Frage beruht auf impliziter Typisierung. Stellen Sie sich folgendes vor:

subroutine S2909 
    common x, y 
    x = 2. 
    y = 3. 
end subroutine S2909 

implicit integer (a-z) 

call S2909 
call S2900 

contains 
    subroutine S2900 
    common x, y 

    print*, x, y 
    end subroutine 
end 

Dies ist ein Beispiel für uncivil Code schreiben, aber es veranschaulicht eine wichtige Sache. Weil die Entitäten x in den S2909 und x in der Unterroutine S2900 verschiedene Typen sind, die einen von ihnen definieren, bewirkt, dass der andere undefiniert wird. Das heißt: Wenn der Wert von eins aktualisiert wird, wird der Wert des anderen nicht aktualisiert.Bei expliziter Typisierung könnte man dasselbe sehen, oder wenn es implizite Typisierung mit Standardregeln und Entities i und j, sagen wir, in einem Unterprogramm gibt.

Und das letzte, was ich sagen möchte, ist: es gibt much better ways of sharing data "globally" without common blocks.

Verwandte Themen