it-swarm.com.de

Verwendung von #pragma in C

Was sind einige Verwendungen von #pragma in C mit Beispielen?

107
srujan

#pragma ist für Compiler-Direktiven gedacht, die maschinenspezifisch oder betriebssystemspezifisch sind, dh, sie weisen den Compiler an, etwas zu tun, eine Option festzulegen, Maßnahmen zu ergreifen, Standardeinstellungen zu überschreiben usw., die möglicherweise für alle Maschinen gelten oder nicht und Betriebssysteme.

Siehe msdn für weitere Informationen.

60
Steven A. Lowe

#pragma Wird verwendet, um etwas Implementierungsspezifisches in C zu tun, d. H. Für den aktuellen Kontext pragmatisch und nicht ideologisch dogmatisch zu sein.

Die, die ich regelmäßig benutze, ist #pragma pack(1), bei der ich versuche, bei eingebetteten Lösungen mehr aus meinem Speicherplatz herauszuholen, mit Arrays von Strukturen, die andernfalls eine 8-Byte-Ausrichtung ergeben würden.

Schade, dass wir noch keinen #dogma Haben. Das würde Spaß machen ;)

52
SmacL

Ich würde generell versuchen, die Verwendung von # Pragmas zu vermeiden, da diese extrem compilerabhängig und nicht portierbar sind. Wenn Sie sie portabel verwenden möchten, müssen Sie jedes Pragma mit einem Paar #if/#endif Umgeben. GCC rät von der Verwendung von Pragmas ab und unterstützt nur einige von ihnen, um die Kompatibilität mit anderen Compilern zu gewährleisten. GCC hat andere Möglichkeiten, die gleichen Dinge zu tun, für die andere Compiler Pragmas verwenden.

So stellen Sie beispielsweise sicher, dass eine Struktur in MSVC dicht gepackt ist (d. H. Kein Auffüllen zwischen Elementen):

#pragma pack(Push, 1)
struct PackedStructure
{
  char a;
  int b;
  short c;
};
#pragma pack(pop)
// sizeof(PackedStructure) == 7

So machen Sie dasselbe in GCC:

struct PackedStructure __attribute__((__packed__))
{
  char a;
  int b;
  short c;
};
// sizeof(PackedStructure == 7)

Der GCC-Code ist portabler, denn wenn Sie ihn mit einem Nicht-GCC-Compiler kompilieren möchten, müssen Sie nur noch etwas tun

#define __attribute__(x)

Wenn Sie hingegen den MSVC-Code portieren möchten, müssen Sie jedes Pragma mit einem Paar #if/#endif Umgeben. Nicht hübsch.

32
Adam Rosenfield

Putting #pragma once am oberen Rand Ihrer Header-Datei wird sichergestellt, dass es nur einmal enthalten ist. Beachten Sie, dass #pragma once ist kein Standard-C99, wird aber von den meisten modernen Compilern unterstützt.

Eine Alternative ist die Verwendung von Include-Guards (z. B. #ifndef MY_FILE #define MY_FILE ... #endif /* MY_FILE */)

15
Schildmeijer

was ich fühle, ist #pragma ist eine Anweisung, bei der der Code ortsspezifisch sein soll. Soll der Programmzähler beispielsweise von der Adresse lesen, an der der ISR geschrieben ist, können Sie den ISR an dieser Stelle mit #pragma vector=ADC12_VECTOR und gefolgt von Interrupt dreht den Namen und seine Beschreibung

7
sandeep

Mein bester Rat ist, sich die Dokumentation Ihres Compilers anzusehen, da Pragmas per Definition implementierungsspezifisch sind. In eingebetteten Projekten habe ich sie beispielsweise verwendet, um Code und Daten in verschiedenen Abschnitten zu lokalisieren oder Interrupt-Handler zu deklarieren. d. h .:

#pragma code BANK1
#pragma data BANK2

#pragma INT3 TimerHandler
5
Justin Love

#pragma startup Ist eine Anweisung, die verwendet wird, um eine Funktion vor der Hauptfunktion und eine andere Funktion nach der Hauptfunktion aufzurufen, z.

#pragma startup func1
#pragma exit func2

Hier wird func1 Ausgeführt, bevor main und anschließend func2 Ausgeführt wird.

HINWEIS: Dieser Code funktioniert nur im Turbo-C-Compiler. Um diese Funktionalität in GCC zu erreichen, können Sie func1 Und func2 Wie folgt deklarieren:

void __attribute__((constructor)) func1();
void __attribute__((destructor)) func2();
3
Sparkzz

Dies ist eine Präprozessoranweisung, mit der bestimmte Funktionen aktiviert oder deaktiviert werden können.

Es gibt zwei Arten #pragma startup, #pragma exit und #pragma warn.

#pragma startup ermöglicht die Angabe von Funktionen, die beim Programmstart aufgerufen werden.

#pragma exit ermöglicht die Angabe von Funktionen, die beim Beenden des Programms aufgerufen werden.

#pragma warn weist den Computer an, Warnungen zu unterdrücken oder nicht.

Viele andere #pragma -Stile können zur Steuerung des Compilers verwendet werden.

3
suresh pareek

Alle Antworten oben geben nette Erklärungen für #pragma, Aber ich wollte ein kleines Beispiel hinzufügen

Ich möchte nur einen simple OpenMP example Erläutern, der einige Verwendungszwecke von #pragma Für die Ausführung seiner Arbeit demonstriert

OpenMp briefly ist eine Implementierung für die plattformübergreifende Parallelprogrammierung von Shared Memory (dann können wir sagen, es ist machine-specific Oder operating-system-specific)

gehen wir zum Beispiel

#include <stdio.h>
#include <omp.h>// compile with: /openmp

int main() {
   #pragma omp parallel num_threads(4)
   {
      int i = omp_get_thread_num();
      printf_s("Hello from thread %d\n", i);
   }
}

die Ausgabe ist

Hello from thread 0
Hello from thread 1
Hello from thread 2
Hello from thread 3

Note that the order of output can vary on different machines.

lass mich dir jetzt sagen, was #pragma getan hat ...

es weist das Betriebssystem an, einen Codeblock für 4 Threads auszuführen

dies ist nur einer von many many applications, die Sie mit dem kleinen #pragma machen können.

entschuldigung für die äußere Probe OpenMP

3

Um es zusammenzufassen, #pragma Weist den Compiler an, Dinge zu tun. Hier sind ein paar Möglichkeiten, wie ich es benutze:

  • #pragma Kann verwendet werden, um Compiler-Warnungen zu ignorieren. Um GCC beispielsweise über implizite Funktionsdeklarationen zum Schweigen zu bringen, können Sie Folgendes schreiben:

    #pragma GCC diagnostic ignored "-Wimplicit-function-declaration"
    

    Eine ältere Version von libportable macht dies portabel .

  • Wenn #pragma once Am Anfang einer Header-Datei geschrieben wird, wird diese Header-Datei einmal eingeschlossen. libportableprüft für Pragma einmalige Unterstützung.

2
MD XF