Flüchtige Funktion

Question

Zusammenfassung: Was bewirkt das Schlüsselwort volatile, wenn es auf eine Funktionsdeklaration in C und C++ angewendet wird?

Einzelheiten:

Ich sehe, dass es möglich ist, eine Funktion zu erstellen, die als volatile markiert. Ich bin mir jedoch nicht sicher, welche Compiler-Optimierung (falls vorhanden) dies verhindert. Zum Beispiel habe ich den folgenden Testfall:

volatile int foo() { 
    return 1; 
} 

int main() { 
    int total = 0; 
    int i = 0; 
    for(i = 0; i < 100; i++) { 
    total += foo(); 
    } 

    return total; 
} 

Wenn ich mit clang -emit-llvm -S -O3 test.c kompilieren (gcc auch funktionieren würde, aber das llvm IR ist besser lesbar meiner Meinung nach) erhalte ich:

target triple = "x86_64-unknown-linux-gnu" 

define i32 @foo() #0 { 
    ret i32 1 
} 

define i32 @main() #0 { 
    ret i32 100 
} 

So offensichtlich die Compiler war in der Lage, die Aufrufe zu Funktion foo() zu optimieren, so dass main() eine Konstante zurückgibt, obwohl foo() als volatile markiert ist. Meine Frage ist also, ob volatile überhaupt etwas tut, wenn es auf eine Funktionsdeklaration angewendet wird, um Compileroptimierungen einzuschränken.

(Hinweis in dieser Frage mein Interesse ist vor allem Neugier zu verstehen, was volatile tut, anstatt irgendeine spezifisches Problem zu lösen.)

(Auch ich markiert habe diese Frage, da beide C und C++ nicht, weil ich denke, sie sind die gleiche Sprache, aber weil ich interessiert zu wissen, ob es Unterschiede gibt in was in diesem Fall in diesen beiden Sprachen).

Answer 1

In Ihrem Code, der volatile Schlüsselwort für die Funktion findet keine Anwendung, sondern auf die Rückgabetyp, es ist das Äquivalent von:

typedef volatile int Type; 
Type foo(); 

nun in C++ Sie eine Mitglied Funktion machen kann volatile , in der gleichen Art und Weise, dass die const Qualifier und das Verhalten ist das gleiche:

struct test { 
    void vfunction() volatile; 
}; 

Grundsätzlich können Sie rufen nicht einen nichtflüchtigen (alterantively nicht konstante) Funktion auf einem flüchtige (const) Instanz des Typs:

struct test { 
    void vfunction() volatile; 
    void function(); 
}; 
volatile test t; 
t.vfunction();  // ok 
t.function();  // error 

Answer 2

foo() ist nicht flüchtig.

Es ist eine Funktion, die eine volatile int zurückgibt.

Welches ist legal. Aber seltsam für eine Rückkehr int.

Mitgliederfunktionen können andererseits volatile aus dem gleichen Grund sein, die sie const sein können.