Putting #pragma once at the top of your header file will ensure that it is only included once. Note that #pragma once is not standard C99, but supported by most modern compilers.
An alternative is to use include guards (e.g. #ifndef MY_FILE #define MY_FILE ... #endif /* MY_FILE */)
I would generally try to avoid the use of #pragmas if possible, since they're extremely compiler-dependent and non-portable. If you want to use them in a portable fashion, you'll have to surround every pragma with a #if/#endif pair. GCC discourages the use of pragmas, and really only supports some of them for compatibility with other compilers; GCC has other ways of doing the same things that other compilers use pragmas for.
For example, here's how you'd ensure that a structure is packed tightly (i.e. no padding between members) in MSVC:
#pragma pack(push, 1)
struct PackedStructure
{
char a;
int b;
short c;
};
#pragma pack(pop)
// sizeof(PackedStructure) == 7
Here's how you'd do the same thing in GCC:
struct PackedStructure __attribute__((__packed__))
{
char a;
int b;
short c;
};
// sizeof(PackedStructure == 7)
The GCC code is more portable, because if you want to compile that with a non-GCC compiler, all you have to do is
#define __attribute__(x)
Whereas if you want to port the MSVC code, you have to surround each pragma with a #if/#endif pair. Not pretty.
Putting #pragma once at the top of your header file will ensure that it is only included once. Note that #pragma once is not standard C99, but supported by most modern compilers.
An alternative is to use include guards (e.g. #ifndef MY_FILE #define MY_FILE ... #endif /* MY_FILE */)
This is a preprocessor directive that can be used to turn on or off certain features.
It is of two types #pragma startup, #pragma exit and #pragma warn.
#pragma startup allows us to specify functions called upon program startup.
#pragma exit allows us to specify functions called upon program exit.
#pragma warn tells the computer to suppress any warning or not.
Many other #pragma styles can be used to control the compiler.
what i feel is #pragma is a directive where if you want the code to be location specific .say a situation where you want the program counter to read from the specific address where the ISR is written then you can specify ISR at that location using #pragma vector=ADC12_VECTOR and followd by interrupt rotines name and its description
#pragma startup is a directive which is used to call a function before the main function and to call another function after the main function, e.g.
#pragma startup func1
#pragma exit func2
Here, func1 runs before main and func2 runs afterwards.
NOTE: This code works only in Turbo-C compiler. To achieve this functionality in GCC, you can declare func1 and func2 like this:
void __attribute__((constructor)) func1();
void __attribute__((destructor)) func2();
I would generally try to avoid the use of #pragmas if possible, since they're extremely compiler-dependent and non-portable. If you want to use them in a portable fashion, you'll have to surround every pragma with a #if/#endif pair. GCC discourages the use of pragmas, and really only supports some of them for compatibility with other compilers; GCC has other ways of doing the same things that other compilers use pragmas for.
For example, here's how you'd ensure that a structure is packed tightly (i.e. no padding between members) in MSVC:
#pragma pack(push, 1)
struct PackedStructure
{
char a;
int b;
short c;
};
#pragma pack(pop)
// sizeof(PackedStructure) == 7
Here's how you'd do the same thing in GCC:
struct PackedStructure __attribute__((__packed__))
{
char a;
int b;
short c;
};
// sizeof(PackedStructure == 7)
The GCC code is more portable, because if you want to compile that with a non-GCC compiler, all you have to do is
#define __attribute__(x)
Whereas if you want to port the MSVC code, you have to surround each pragma with a #if/#endif pair. Not pretty.
To sum it up, #pragma tells the compiler to do stuff. Here are a couple of ways I use it:
#pragma can be used to ignore compiler warnings. For example, to make GCC shut up about implicit function declarations, you can write:
#pragma GCC diagnostic ignored "-Wimplicit-function-declaration"
An older version of libportable does this portably.
#pragma once, when written at the top of a header file, will cause said header file to be included once. libportable checks for pragma once support.
#pragma is used to do something implementation-specific in C, i.e. be pragmatic for the current context rather than ideologically dogmatic.
The one I regularly use is #pragma pack(1) where I'm trying to squeeze more out of my memory space on embedded solutions, with arrays of structures that would otherwise end up with 8 byte alignment.
Pity we don't have a #dogma yet. That would be fun ;)
This is a preprocessor directive that can be used to turn on or off certain features.
It is of two types #pragma startup, #pragma exit and #pragma warn.
#pragma startup allows us to specify functions called upon program startup.
#pragma exit allows us to specify functions called upon program exit.
#pragma warn tells the computer to suppress any warning or not.
Many other #pragma styles can be used to control the compiler.
I would generally try to avoid the use of #pragmas if possible, since they're extremely compiler-dependent and non-portable. If you want to use them in a portable fashion, you'll have to surround every pragma with a #if/#endif pair. GCC discourages the use of pragmas, and really only supports some of them for compatibility with other compilers; GCC has other ways of doing the same things that other compilers use pragmas for.
For example, here's how you'd ensure that a structure is packed tightly (i.e. no padding between members) in MSVC:
#pragma pack(push, 1)
struct PackedStructure
{
char a;
int b;
short c;
};
#pragma pack(pop)
// sizeof(PackedStructure) == 7
Here's how you'd do the same thing in GCC:
struct PackedStructure __attribute__((__packed__))
{
char a;
int b;
short c;
};
// sizeof(PackedStructure == 7)
The GCC code is more portable, because if you want to compile that with a non-GCC compiler, all you have to do is
#define __attribute__(x)
Whereas if you want to port the MSVC code, you have to surround each pragma with a #if/#endif pair. Not pretty.
#pragma is for compiler directives that are machine-specific or operating-system-specific, i.e. it tells the compiler to do something, set some option, take some action, override some default, etc. that may or may not apply to all machines and operating systems.
See msdn for more info.
To sum it up, #pragma tells the compiler to do stuff. Here are a couple of ways I use it:
#pragma can be used to ignore compiler warnings. For example, to make GCC shut up about implicit function declarations, you can write:
#pragma GCC diagnostic ignored "-Wimplicit-function-declaration"
An older version of libportable does this portably.
#pragma once, when written at the top of a header file, will cause said header file to be included once. libportable checks for pragma once support.
#pragma is for compiler directives that are machine-specific or operating-system-specific, i.e. it tells the compiler to do something, set some option, take some action, override some default, etc. that may or may not apply to all machines and operating systems.
See msdn for more info.
#pragma is used to do something implementation-specific in C, i.e. be pragmatic for the current context rather than ideologically dogmatic.
The one I regularly use is #pragma pack(1) where I'm trying to squeeze more out of my memory space on embedded solutions, with arrays of structures that would otherwise end up with 8 byte alignment.
Pity we don't have a #dogma yet. That would be fun ;)
I would generally try to avoid the use of #pragmas if possible, since they're extremely compiler-dependent and non-portable. If you want to use them in a portable fashion, you'll have to surround every pragma with a #if/#endif pair. GCC discourages the use of pragmas, and really only supports some of them for compatibility with other compilers; GCC has other ways of doing the same things that other compilers use pragmas for.
For example, here's how you'd ensure that a structure is packed tightly (i.e. no padding between members) in MSVC:
#pragma pack(push, 1)
struct PackedStructure
{
char a;
int b;
short c;
};
#pragma pack(pop)
// sizeof(PackedStructure) == 7
Here's how you'd do the same thing in GCC:
struct PackedStructure __attribute__((__packed__))
{
char a;
int b;
short c;
};
// sizeof(PackedStructure == 7)
The GCC code is more portable, because if you want to compile that with a non-GCC compiler, all you have to do is
#define __attribute__(x)
Whereas if you want to port the MSVC code, you have to surround each pragma with a #if/#endif pair. Not pretty.
#pragma startup is a directive which is used to call a function before the main function and to call another function after the main function, e.g.
#pragma startup func1
#pragma exit func2
Here, func1 runs before main and func2 runs afterwards.
NOTE: This code works only in Turbo-C compiler. To achieve this functionality in GCC, you can declare func1 and func2 like this:
void __attribute__((constructor)) func1();
void __attribute__((destructor)) func2();
#pragma is for compiler directives that are machine-specific or operating-system-specific, i.e. it tells the compiler to do something, set some option, take some action, override some default, etc. that may or may not apply to all machines and operating systems.
See msdn for more info.
My best advice is to look at your compiler's documentation, because pragmas are by definition implementation-specific. For instance, in embedded projects I've used them to locate code and data in different sections, or declare interrupt handlers. i.e.:
#pragma code BANK1
#pragma data BANK2
#pragma INT3 TimerHandler
All answers above make nice explanations for #pragma but I wanted to a add small example
I just want to explain a simple OpenMP example that demonstrate some uses of #pragma to doing its work
OpenMp
brieflyis an implementation for multi-platform shared-memory parallel programming (then we can say it'smachine-specificoroperating-system-specific)
let's go to the example
#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);
}
}
the output is
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.
now let me tell you what #pragma did...
it tells the OS to run the some block of code on 4 threads
this is just one of many many applications you can do with the little #pragma
sorry for the outside sample OpenMP
#pragma is for compiler directives that are machine-specific or operating-system-specific, i.e. it tells the compiler to do something, set some option, take some action, override some default, etc. that may or may not apply to all machines and operating systems.
See msdn for more info.
#pragma is used to do something implementation-specific in C, i.e. be pragmatic for the current context rather than ideologically dogmatic.
The one I regularly use is #pragma pack(1) where I'm trying to squeeze more out of my memory space on embedded solutions, with arrays of structures that would otherwise end up with 8 byte alignment.
Pity we don't have a #dogma yet. That would be fun ;)
what i feel is #pragma is a directive where if you want the code to be location specific .say a situation where you want the program counter to read from the specific address where the ISR is written then you can specify ISR at that location using #pragma vector=ADC12_VECTOR and followd by interrupt rotines name and its description
My best advice is to look at your compiler's documentation, because pragmas are by definition implementation-specific. For instance, in embedded projects I've used them to locate code and data in different sections, or declare interrupt handlers. i.e.:
#pragma code BANK1
#pragma data BANK2
#pragma INT3 TimerHandler
All answers above make nice explanations for #pragma but I wanted to a add small example
I just want to explain a simple OpenMP example that demonstrate some uses of #pragma to doing its work
OpenMp
brieflyis an implementation for multi-platform shared-memory parallel programming (then we can say it'smachine-specificoroperating-system-specific)
let's go to the example
#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);
}
}
the output is
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.
now let me tell you what #pragma did...
it tells the OS to run the some block of code on 4 threads
this is just one of many many applications you can do with the little #pragma
sorry for the outside sample OpenMP
#pragma is used to do something implementation-specific in C, i.e. be pragmatic for the current context rather than ideologically dogmatic.
The one I regularly use is #pragma pack(1) where I'm trying to squeeze more out of my memory space on embedded solutions, with arrays of structures that would otherwise end up with 8 byte alignment.
Pity we don't have a #dogma yet. That would be fun ;)
Putting #pragma once at the top of your header file will ensure that it is only included once. Note that #pragma once is not standard C99, but supported by most modern compilers.
An alternative is to use include guards (e.g. #ifndef MY_FILE #define MY_FILE ... #endif /* MY_FILE */)
My best advice is to look at your compiler's documentation, because pragmas are by definition implementation-specific. For instance, in embedded projects I've used them to locate code and data in different sections, or declare interrupt handlers. i.e.:
#pragma code BANK1
#pragma data BANK2
#pragma INT3 TimerHandler
Source: Stackoverflow.com