Pragma

[muttaa]

Hello all,

I'm a beginner in C...May i like to know the difference between a
#pragma and a #define....
Also,yet i'm unclear what a pragma is all about as i can find topics on
it only in high-standard books...
Thanks in advance!

[Eric Sosman]

muttaa wrote:

Hello all,

I'm a beginner in C...May i like to know the difference between a
#pragma and a #define....
Also,yet i'm unclear what a pragma is all about as i can find topics on
it only in high-standard books...

For a beginner, the difference is simple: #define is
something you use, but #pragma is something you avoid.

#define creates a macro. When the macro name appears
later on in the program, the text of the macro definition
replaces the name. (That's a loose description, not perfect
but good enough for all but language lawyers.) A macro is
a kind of shorthand; using the shorthand, you may be able
to write your program more briefly and more clearly.

#pragma tells the compiler to do something peculiar. It
may tell the compiler to allocate a variable on an 8192-byte
boundary, or to use a non-standard mechanism for calling a
function, or that some special action is to be taken before
main() is called, or ... With a very few exceptions, the
effect of a #pragma directive is entirely defined by the
particular compiler you happen to be using; switch to a
different compiler and the same #pragma in your source code
may have an entirely different effect. In other words, #pragma
ties your code to just one compiler, thus giving up nearly all
the portability C is famous for.

Use #define when it seems useful. When #pragma seems like
a good idea, you are probably hallucinating and should get some
bed rest.

--
Eric Sosman
es*****@acm-dot-org.invalid

[swengineer001]

Eric Sosman wrote:

When #pragma seems like
a good idea, you are probably hallucinating and should get some
bed rest.

So what would you suggest when stucture packing is required for a
program. As far as I know there is no standar C way to do it but it is
often required in embedded systems. Am I wrong on this?

[Gordon Burditt]

>> When #pragma seems like

a good idea, you are probably hallucinating and should get some
bed rest.
So what would you suggest when stucture packing is required for a

structure packing is NOT required for a C program. I don't know
what kind of program it is, but it's not C.
program. As far as I know there is no standar C way to do it but it is
often required in embedded systems. Am I wrong on this?

Gordon L. Burditt

[Ian Collins]

Gordon Burditt wrote:

When #pragma seems like
a good idea, you are probably hallucinating and should get some
bed rest.

So what would you suggest when stucture packing is required for a

structure packing is NOT required for a C program. I don't know
what kind of program it is, but it's not C.

It may not be required, but it is often used in embedded environments.
Packing might even be required, if its use reduced code size.

--
Ian Collins.

[Tomás]

So what would you suggest when stucture packing is required for a
program. As far as I know there is no standar C way to do it but it is
often required in embedded systems. Am I wrong on this?

If you're looking for a TRULLY portable method, you can use pointer
trickery.

All the three "char" types are guaranteed to use all of their bits in
their value representation. Armed with this knowledge, plus with the help
of CHAR_BIT, you can manipulate the bits in memory directly.

If CHAR_BIT != 8, then it will be a little harder... but not impossible.

I posted an example of this within the last two days on this newsgroup. If
you want to use Google to search, search for "pointer trickery" in a post
by me.

-Tomás

[Eric Sosman]

Ian Collins wrote:

Gordon Burditt wrote:

When #pragma seems like
a good idea, you are probably hallucinating and should get some
bed rest.
So what would you suggest when stucture packing is required for a

structure packing is NOT required for a C program. I don't know
what kind of program it is, but it's not C.

It may not be required, but it is often used in embedded environments.
Packing might even be required, if its use reduced code size.

Structure packing (if it can be done at all) seldom if
ever reduces code size. In my experience, it either increases
code size and slows the program down a little, or leaves code
size unchanged and slows the program down a lot.

Structure packing can reduce data size, which is another
matter. However, there are other ways to reduce data size if
that's a concern. For example, one might transform

struct {
char x;
double y;
} thing[BIG_COUNT];

to

char thing_x[BIG_COUNT];
double thing_y[BIG_COUNT];

Structure packing is also used to make a struct match an
externally-imposed format like a packet header or some such.
This is a snare and a delusion; in the long run, It Doesn't Work.

--
Eric Sosman
es*****@acm-dot-org.invalid

[pete]

Tomás wrote:

All the three "char" types are guaranteed to use all of their bits in
their value representation.

The signed char type isn't guaranteed to be padding free.
I don't think there's ever been a case where
there has been padding in a signed char,
but there's no guarantee.

--
pete

[Ian Collins]

Eric Sosman wrote:

Ian Collins wrote:

Gordon Burditt wrote:

> When #pragma seems like
> a good idea, you are probably hallucinating and should get some
> bed rest.
>

So what would you suggest when stucture packing is required for a

structure packing is NOT required for a C program. I don't know
what kind of program it is, but it's not C.

It may not be required, but it is often used in embedded environments.
Packing might even be required, if its use reduced code size.

Structure packing is also used to make a struct match an
externally-imposed format like a packet header or some such.
This is a snare and a delusion; in the long run, It Doesn't Work.

It does if the externally imposed format is hardware registers.

--
Ian Collins.

[swengineer001]

Eric Sosman wrote:

Structure packing can reduce data size, which is another
matter. However, there are other ways to reduce data size if
that's a concern. For example, one might transform

struct {
char x;
double y;
} thing[BIG_COUNT];

to

char thing_x[BIG_COUNT];
double thing_y[BIG_COUNT];
While this does reduce data size it does nothing to maintain data
encapsulation which can be a very useful thing in increasing the
readability of the code.
Structure packing is also used to make a struct match an
externally-imposed format like a packet header or some such.
This is a snare and a delusion; in the long run, It Doesn't Work.

I am not sure that I understand why you think this. I have used, and
probably will again, structure packing for both externally imposed data
structures such as headers and to overlay something on a specific piece
of hardware. I have never had a problem with this, although I have not
had change compilers either which I will admit could cause some
problems but I was not suggesting that i would be portable. Why is it
that you say it does not work.