array in include

[Salvatore Di Fazio]

Hi,
I've an array in an include that is used everywhere in the project.

So to avoid the problem of declaration I made the following solution:

ifndef __UNWALKABLETIL ES__
#define __UNWALKABLETIL ES__

#define UNWALKABLETILES 16 /*!< Number of elements in UnwalkableTiles
array. */

/** List of unwalkable tiles. */
char rgUnwalkableTil es[] =
{
18, 19, 20, 21, 22, 23, 24, 25, 55, 56, 57, 60, 61, 62, 63, 64
};
#endif

But it doesn't works.
Why?
Tnx

[Eric Sosman]

Salvatore Di Fazio wrote:

Hi,
I've an array in an include that is used everywhere in the project.

So to avoid the problem of declaration I made the following solution:

ifndef __UNWALKABLETIL ES__
#define __UNWALKABLETIL ES__

#define UNWALKABLETILES 16 /*!< Number of elements in UnwalkableTiles
array. */

/** List of unwalkable tiles. */
char rgUnwalkableTil es[] =
{
18, 19, 20, 21, 22, 23, 24, 25, 55, 56, 57, 60, 61, 62, 63, 64
};
#endif

Your program's modules can *declare* rgUnwalkableTil es[]
as often as you like, but must *define* it exactly once. The
usual way of doing this is to put the declaration in a header
file that you #include in all the source modules:

/* tiles.h */
#define UNWALKABLETILES 16
extern char rgUnwalkableTil es[UNWALKABLETILES];

.... and then place the definition in exactly one source file:

/* somefile.c */
#include "tiles.h"
char rgUnwalkableTil es[] = { ... as above ... };

Note that somefile.c #includes tiles.h; this is a very
good idea because it lets the compiler "see" the declaration
and the definition at the same time, which means it can detect
any inadvertent mis-matches.

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

[Keith Thompson]

"Salvatore Di Fazio" <sa************ ***@gmail.comwr ites:

I've an array in an include that is used everywhere in the project.

So to avoid the problem of declaration I made the following solution:

ifndef __UNWALKABLETIL ES__
#define __UNWALKABLETIL ES__

#define UNWALKABLETILES 16 /*!< Number of elements in UnwalkableTiles
array. */

/** List of unwalkable tiles. */
char rgUnwalkableTil es[] =
{
18, 19, 20, 21, 22, 23, 24, 25, 55, 56, 57, 60, 61, 62, 63, 64
};
#endif

But it doesn't works.
Why?

Eric Sosman already answered the question you asked, so I'll answer
some questions you didn't ask.

Include guards are an excellent idea, but you should avoid identifiers
starting with underscores; many of them are reserved to the
implementation. (There are rules that depend on whether the second
character is another underscore, an upper case letter, or a lower case
letter, but it's not really worth remembering the details.)

If the include guard is supposed to refer to the header, a good
convention is "H_" followed by the header name; for example:

#ifndef H_UNWALKABLETIL ES
#define H_UNWALKABLETIL ES
....
#endif

Also, long run-on identifiers like UNWALKABLETILES are difficult to
read. I suggest changing it to UNWALKABLE_TILE S.

--
Keith Thompson (The_Other_Keit h) ks***@mib.org <http://www.ghoti.net/~kst>
San Diego Supercomputer Center <* <http://users.sdsc.edu/~kst>
We must do something. This is something. Therefore, we must do this.

[Salvatore Di Fazio]

Eric Sosman wrote:

Your program's modules can *declare* rgUnwalkableTil es[]
as often as you like, but must *define* it exactly once.

Why?
I don't must define it exactly ...

The usual way of doing this is to put the declaration in a header
file that you #include in all the source modules:

/* tiles.h */
#define UNWALKABLETILES 16
extern char rgUnwalkableTil es[UNWALKABLETILES];

... and then place the definition in exactly one source file:

/* somefile.c */
#include "tiles.h"
char rgUnwalkableTil es[] = { ... as above ... };

Note that somefile.c #includes tiles.h; this is a very
good idea because it lets the compiler "see" the declaration
and the definition at the same time, which means it can detect
any inadvertent mis-matches.

But I prefere keep it in a header file.

Tnx

[Eric Sosman]

Salvatore Di Fazio wrote On 07/19/06 14:40,:

Eric Sosman wrote:

> Your program's modules can *declare* rgUnwalkableTil es[]
as often as you like, but must *define* it exactly once.

Why?
I don't must define it exactly ...

I misspoke: You do not need to define the array at all --
provided you never use it. Section 6.9, paragraph 5:

[...] If an identifier declared with external linkage
is used in an expression (other than as part of the
operand of a sizeof operator whose result is an integer
constant), somewhere in the entire program there shall
be exactly one external definition for the identifier;
otherwise, there shall be no more than one.

So if you intend to use any of the values in rgUnwalkableTil es[]
you must provide exactly one definition of the array; exactly
one compiled module must contain the array's definition. (If
you don't use the array, it's all right not to define it at all
but you still mustn't define it twice.)

>>The usual way of doing this is to put the declaration in a header
file that you #include in all the source modules:

/* tiles.h */
#define UNWALKABLETILES 16
extern char rgUnwalkableTil es[UNWALKABLETILES];

... and then place the definition in exactly one source file:

/* somefile.c */
#include "tiles.h"
char rgUnwalkableTil es[] = { ... as above ... };

Note that somefile.c #includes tiles.h; this is a very
good idea because it lets the compiler "see" the declaration
and the definition at the same time, which means it can detect
any inadvertent mis-matches.

But I prefere keep it in a header file.

Too bad. You can play games with macros so your single
header file compiles one way in one file and a different way
in all the others, but that's just a subterfuge.

"I accept the Universe." -- Margaret Fuller
"Gad! She'd better!" -- Thomas Carlyle

--
Er*********@sun .com

[Flash Gordon]

Salvatore Di Fazio wrote:

Eric Sosman wrote:

> Your program's modules can *declare* rgUnwalkableTil es[]
as often as you like, but must *define* it exactly once.

Why?
I don't must define it exactly ...

You must define it exactly once because that is how C is defined.

>The usual way of doing this is to put the declaration in a header
file that you #include in all the source modules:

/* tiles.h */
#define UNWALKABLETILES 16
extern char rgUnwalkableTil es[UNWALKABLETILES];

... and then place the definition in exactly one source file:

/* somefile.c */
#include "tiles.h"
char rgUnwalkableTil es[] = { ... as above ... };

Note that somefile.c #includes tiles.h; this is a very
good idea because it lets the compiler "see" the declaration
and the definition at the same time, which means it can detect
any inadvertent mis-matches.

But I prefere keep it in a header file.

The only way to do that is to use horrid tricks. Or use a language other
than C.
--
Flash Gordon, living in interesting times.
Web site - http://home.flash-gordon.me.uk/
comp.lang.c posting guidelines and intro:
http://clc-wiki.net/wiki/Intro_to_clc

[Salvatore Di Fazio]

Eric Sosman ha scritto:

>
I misspoke: You do not need to define the array at all --
provided you never use it. Section 6.9, paragraph 5:

okkey

Too bad. You can play games with macros so your single
header file compiles one way in one file and a different way
in all the others, but that's just a subterfuge.

So you suggest to me to no't put all the defines in one header but
divide these in the correct header file?

Another question, if I've something like it

-- myheader.h --
#ifndef H_MY_HEADER_
#define H_MY_HEADER_
#define A 12
#endif
-- myfirst.c --
#include <myheader.h>
....
-- mysecond.c --
#include <myheader.h>
the compiler defines twice the A?

[Salvatore Di Fazio]

Flash Gordon ha scritto:

The only way to do that is to use horrid tricks. Or use a language other
than C.

Thank you for your suggestion

[Salvatore Di Fazio]

Eric Sosman ha scritto:

I misspoke: You do not need to define the array at all --
provided you never use it. Section 6.9, paragraph 5:

okkey

Too bad. You can play games with macros so your single
header file compiles one way in one file and a different way
in all the others, but that's just a subterfuge.

So you suggest to me to no't put all the defines in one header but
divide these in the correct header file?

Another question, if I've something like it

-- myheader.h --
#ifndef H_MY_HEADER_
#define H_MY_HEADER_
#define A 12
#endif

-- myfirst.c --
#include <myheader.h>
....

-- mysecond.c --
#include <myheader.h>

the compiler defines twice the A?

I wrote this question because I don't understand why the array was
multiple-defineted in all the files that include the myheader.h

[Thomas J. Gritzan]

Salvatore Di Fazio schrieb:

Another question, if I've something like it

-- myheader.h --
#ifndef H_MY_HEADER_
#define H_MY_HEADER_
#define A 12
#endif

-- myfirst.c --
#include <myheader.h>
...

-- mysecond.c --
#include <myheader.h>

the compiler defines twice the A?

I wrote this question because I don't understand why the array was
multiple-defineted in all the files that include the myheader.h

Well,

1) With #define you define a preprocessor macro,
2) With

extern char rgUnwalkableTil es[UNWALKABLETILES];

you declare (means: tell the compiler that there is a rgUnwalkableTil es
and what type it hat, anywhere in any other file) the variable,

3) with

char rgUnwalkableTil es[] = { 1, 2, 3, ... };

you declare and define (means: tell the compiler, what rgUnwalkableTil es
actually is, what values it has) the variable.

You can do as many of 2) as you like in different compilation files (*.c
files) with the same name, but only one of 3) with the same name in all
compilation units that are linked together.

Macros you define with #define are another thing.

--
Thomas