Ist der #pragma-Direktiven-Compiler abhängig?

Question

Ich weiß, und ich habe #pragma startup und #pragma exit vorher verwendet, aber wenn ich den folgenden Code ausführen, gibt es nur In main aus. Kann mir jemand sagen, was hier passiert?

#include<stdio.h> 
#pragma startup A 110 
#pragma startup B 
#pragma exit A 
#pragma exit B 110 

int main() 
{ 
    printf("\nIn main"); 
    return 0; 
} 

void A() 
{ 
    printf("\nIn A"); 
} 

void B() 
{ 
    printf("\nIn B"); 
} 

Oder ist es Compiler abhängig? Ich benutze den GCC-Compiler.

Answer 1

Alle #pragma Direktiven Compiler-abhängig sind, und ein Compiler es zu ignorieren verpflichtet, alle nicht erkennt (ISO-9899: 2011, s6.10.6: „Eine solche Pragma, die nicht durch die Implementierung erkannt wird, wird ignoriert . "). Deshalb kompiliert Ihr Programm erfolgreich. Die Funktionen A und B werden nicht aufgerufen, weil ... Sie sie nicht anrufen. Entschuldigung, wenn Sie das ganz gut verstehen, aber: Ein C-Programm wird durch Aufruf der Funktion main ausgeführt. Wenn Sie möchten, dass die Funktionen A und B aufgerufen werden, müssen Sie dies innerhalb der main Funktion tun.

(In der Tat, die jüngsten Versionen des C-Standard haben eine kleine Anzahl von STDC pragmas eingeführt, die Implementierungen zu erkennen verpflichtet, aber das vor allem wirkt sich nicht auf die Antwort)

Answer 2

Ja, die #pragma Direktive ist vom Compiler abhängig.

Genauer gesagt sind die unterstützten Optionen Compiler-spezifisch. Einige Optionen werden möglicherweise von vielen oder den meisten Compilern unterstützt, aber in vielen Fällen sind die Optionen für jeden Compiler spezifisch.

Answer 3

Alle #pragma Direktiven sind Implementierung definiert. Zu einer Zeit reagierte gcc auf alle #pragma Direktiven in der gleichen (allgemein unerwünschten) Weise.

Answer 4

Soweit ich weiß, gcc unterstützt einfach nicht das Start/Exit-Pragma. Sie müssen Attribut verwenden, damit es mit gcc funktioniert.

__attribute__((constructor)) 
__attribute__((destructor)) 
__attribute__((constructor (PRIORITY))) 
__attribute__((destructor (PRIORITY))) 

Dies funktioniert:

#include<stdio.h> 
    void A() __attribute__((constructor(110))); 
    void B() __attribute__((constructor)); 
    void A() __attribute__((destructor)); 
    void B() __attribute__((destructor(110))); 

    int main() 
    { 
     printf("\nIn main"); 
     return 0; 
    } 

    void A() 
    { 
     printf("\nIn A"); 
    } 

    void B() 
    { 
     printf("\nIn B"); 
    }