howto init 2d structure to zero ?

[Stef]

Hello,

I have a question:

Is it possible to init a 2d array of structures to zero ?

For example with array I do.
int array[MAX] = {0}

but:
structure test bb[MAX][MAX] = {{0},{0}};

won't work.. ?

thank yoo.

Stef.

[bjrnove]

Hi.

This should work thow:
struct test bb[MAX][MAX] = {0};

If you put = {0}; as the initializer it will alway initialize the
entire thing to \0's.

--
bjrnove

[Stef]

On 24 May 2005 03:32:09 -0700, "bjrnove" <bj*****@gmail.com> wrote:

Hi.

This should work thow:
struct test bb[MAX][MAX] = {0};

If you put = {0}; as the initializer it will alway initialize the
entire thing to \0's.

But the compiler gives warnings then... like:
istrct.c: In function `main':
istrct.c:11: warning: missing braces around initializer
istrct.c:11: warning: (near initialization for `aaaa[0]')
istrct.c:12: warning: missing braces around initializer
istrct.c:12: warning: (near initialization for `bbbb[0]')
istrct.c:12: warning: unused variable `bbbb'
istrct.c:11: warning: unused variable `aaaa'

For completeness Here is small simple skeleton..
#include <stdio.h>

#define MAXTAB 100
#define MAXCOL 3

struct tab {
double freq;
};

int main(void) {
struct tab aaaa[MAXTAB][MAXCOL] = {0};
struct tab bbbb[MAXTAB][MAXCOL] = {0};

return 0;
}

[Jens.Toerring]

Stef <St*****@sirtakie.tk> wrote:

On 24 May 2005 03:32:09 -0700, "bjrnove" <bj*****@gmail.com> wrote:

Hi.

This should work thow:
struct test bb[MAX][MAX] = {0};

If you put = {0}; as the initializer it will alway initialize the
entire thing to \0's.

But the compiler gives warnings then... like:
istrct.c: In function `main':
istrct.c:11: warning: missing braces around initializer
istrct.c:11: warning: (near initialization for `aaaa[0]')
istrct.c:12: warning: missing braces around initializer
istrct.c:12: warning: (near initialization for `bbbb[0]')
istrct.c:12: warning: unused variable `bbbb'
istrct.c:11: warning: unused variable `aaaa' For completeness Here is small simple skeleton..
#include <stdio.h> #define MAXTAB 100
#define MAXCOL 3 struct tab {
double freq;
}; int main(void) {
struct tab aaaa[MAXTAB][MAXCOL] = {0};
struct tab bbbb[MAXTAB][MAXCOL] = {0};

Use instead

struct tab aaaa[MAXTAB][MAXCOL] = {{{0}}};

If you have e.g. a 2-dimensional arrays of ints you would do e.g.

int foo[ 2 ][ 2 ] = { { 1, 2 }, { 3, 4 } };

and since the initializer for a structure needs curly braces you need
another level of them for your 2-dimensional array of structures.

If the structure has more than a single member put in a value for
each member, i.e.

struct tab2 {
double freq;
int x;
}

struct tab2 ccc[MAXTAB][MAXCOL] = {{{0,0}}};

Regards, Jens
--
\ Jens Thoms Toerring ___ Je***********@physik.fu-berlin.de
\__________________________ http://www.toerring.de

[S.Tobias]

Stef <St*****@sirtakie.tk> wrote:

For example with array I do.
int array[MAX] = {0} but:
structure test bb[MAX][MAX] = {{0},{0}}; won't work.. ?

What makes you think it won't work, assuming all necessary
definitions are provided?

This compiled cleanly:
#define MAX 10
struct test { int x; };
struct test bb[MAX][MAX] = {{0},{0}};

--
Stan Tobias
mailx `echo si***@FamOuS.BedBuG.pAlS.INVALID | sed s/[[:upper:]]//g`

[Stef]

On 24 May 2005 10:54:17 GMT, Je***********@physik.fu-berlin.de wrote:

Stef <St*****@sirtakie.tk> wrote:

On 24 May 2005 03:32:09 -0700, "bjrnove" <bj*****@gmail.com> wrote:

Hi.

This should work thow:
struct test bb[MAX][MAX] = {0};

If you put = {0}; as the initializer it will alway initialize the
entire thing to \0's.

But the compiler gives warnings then... like:
istrct.c: In function `main':
istrct.c:11: warning: missing braces around initializer
istrct.c:11: warning: (near initialization for `aaaa[0]')
istrct.c:12: warning: missing braces around initializer
istrct.c:12: warning: (near initialization for `bbbb[0]')
istrct.c:12: warning: unused variable `bbbb'
istrct.c:11: warning: unused variable `aaaa'

For completeness Here is small simple skeleton..
#include <stdio.h>

#define MAXTAB 100
#define MAXCOL 3

struct tab {
double freq;
};

int main(void) {
struct tab aaaa[MAXTAB][MAXCOL] = {0};
struct tab bbbb[MAXTAB][MAXCOL] = {0};

Use instead

struct tab aaaa[MAXTAB][MAXCOL] = {{{0}}};

If you have e.g. a 2-dimensional arrays of ints you would do e.g.

int foo[ 2 ][ 2 ] = { { 1, 2 }, { 3, 4 } };

and since the initializer for a structure needs curly braces you need
another level of them for your 2-dimensional array of structures.

If the structure has more than a single member put in a value for
each member, i.e.

struct tab2 {
double freq;
int x;
}

struct tab2 ccc[MAXTAB][MAXCOL] = {{{0,0}}};

Regards, Jens

Ok thank yoo .. That worked !

Stef

[S.Tobias]

Stef <St*****@sirtakie.tk> wrote:

On 24 May 2005 03:32:09 -0700, "bjrnove" <bj*****@gmail.com> wrote:

This should work thow:
struct test bb[MAX][MAX] = {0};

If you put = {0}; as the initializer it will alway initialize the
entire thing to \0's.

But the compiler gives warnings then... like:
istrct.c: In function `main':
istrct.c:11: warning: missing braces around initializer
istrct.c:11: warning: (near initialization for `aaaa[0]')
istrct.c:12: warning: missing braces around initializer
istrct.c:12: warning: (near initialization for `bbbb[0]')
istrct.c:12: warning: unused variable `bbbb'
istrct.c:11: warning: unused variable `aaaa' For completeness Here is small simple skeleton..
#include <stdio.h> #define MAXTAB 100
#define MAXCOL 3 struct tab {
double freq;
}; int main(void) {
struct tab aaaa[MAXTAB][MAXCOL] = {0};
struct tab bbbb[MAXTAB][MAXCOL] = {0}; return 0;
}

The program is correct. Compiler may issue as many warnings it
feels like to. The extra warnings that you see are invoked
by "-Wall" option to gcc (since we already have "-pedantic", this
one could be called "-paranoic"); look into the gcc documentation.

--
Stan Tobias
mailx `echo si***@FamOuS.BedBuG.pAlS.INVALID | sed s/[[:upper:]]//g`

[Stef]

On 24 May 2005 11:06:31 GMT, "S.Tobias"
<si***@FamOuS.BedBuG.pAlS.INVALID> wrote:

Stef <St*****@sirtakie.tk> wrote:

For example with array I do.
int array[MAX] = {0}

but:
structure test bb[MAX][MAX] = {{0},{0}};

won't work.. ?

What makes you think it won't work, assuming all necessary
definitions are provided?

This compiled cleanly:
#define MAX 10
struct test { int x; };
struct test bb[MAX][MAX] = {{0},{0}};

~: cat strct.c
#include <stdio.h>

#define MAX 10

int main(void) {
struct test { int x; };
struct test bb[MAX][MAX] = {{0},{0}};

return 0;
}

~: gcc -Wall -pedantic strct.c -o strct
strct.c: In function `main':
strct.c:7: warning: missing braces around initializer
strct.c:7: warning: (near initialization for `bb[0][0]')
strct.c:7: warning: unused variable `bb'

That made me thinc it won't worked

Stef.

[Stef]

On 24 May 2005 11:14:49 GMT, "S.Tobias"
<si***@FamOuS.BedBuG.pAlS.INVALID> wrote:

Stef <St*****@sirtakie.tk> wrote:

On 24 May 2005 03:32:09 -0700, "bjrnove" <bj*****@gmail.com> wrote:

This should work thow:
struct test bb[MAX][MAX] = {0};

If you put = {0}; as the initializer it will alway initialize the
entire thing to \0's.

But the compiler gives warnings then... like:
istrct.c: In function `main':
istrct.c:11: warning: missing braces around initializer
istrct.c:11: warning: (near initialization for `aaaa[0]')
istrct.c:12: warning: missing braces around initializer
istrct.c:12: warning: (near initialization for `bbbb[0]')
istrct.c:12: warning: unused variable `bbbb'
istrct.c:11: warning: unused variable `aaaa'

For completeness Here is small simple skeleton..
#include <stdio.h>

#define MAXTAB 100
#define MAXCOL 3

struct tab {
double freq;
};

int main(void) {
struct tab aaaa[MAXTAB][MAXCOL] = {0};
struct tab bbbb[MAXTAB][MAXCOL] = {0};

return 0;
}

The program is correct. Compiler may issue as many warnings it
feels like to. The extra warnings that you see are invoked
by "-Wall" option to gcc (since we already have "-pedantic", this
one could be called "-paranoic"); look into the gcc documentation.

I know what flags I am passing, even tho the program might be correct
I still feel it's proper custom to have code compiled cleanly without
any warnings..

Stef

[Michael Knaup]

Je***********@physik.fu-berlin.de wrote:

Stef <St*****@sirtakie.tk> wrote:

On 24 May 2005 03:32:09 -0700, "bjrnove" <bj*****@gmail.com> wrote:

Hi.

This should work thow:
struct test bb[MAX][MAX] = {0};

If you put = {0}; as the initializer it will alway initialize the
entire thing to \0's.

But the compiler gives warnings then... like:
istrct.c: In function `main':
istrct.c:11: warning: missing braces around initializer
istrct.c:11: warning: (near initialization for `aaaa[0]')
istrct.c:12: warning: missing braces around initializer
istrct.c:12: warning: (near initialization for `bbbb[0]')
istrct.c:12: warning: unused variable `bbbb'
istrct.c:11: warning: unused variable `aaaa'

For completeness Here is small simple skeleton..
#include <stdio.h>

#define MAXTAB 100
#define MAXCOL 3

struct tab {
double freq;
};

int main(void) {
struct tab aaaa[MAXTAB][MAXCOL] = {0};
struct tab bbbb[MAXTAB][MAXCOL] = {0};

Use instead

struct tab aaaa[MAXTAB][MAXCOL] = {{{0}}};

If you have e.g. a 2-dimensional arrays of ints you would do e.g.

int foo[ 2 ][ 2 ] = { { 1, 2 }, { 3, 4 } };

and since the initializer for a structure needs curly braces you need
another level of them for your 2-dimensional array of structures.

If the structure has more than a single member put in a value for
each member, i.e.

struct tab2 {
double freq;
int x;
}

struct tab2 ccc[MAXTAB][MAXCOL] = {{{0,0}}};

Regards, Jens

Even int the case of a struct with more than one component,
this should be enough to init the whole array to "zero"

struct tab2 ccc[MAXTAB][MAXCOL] = {{{ 0 }}};

--
Michael Knaup

[S.Tobias]

Stef <St*****@sirtakie.tk> wrote:

On 24 May 2005 11:14:49 GMT, "S.Tobias"
<si***@FamOuS.BedBuG.pAlS.INVALID> wrote:

The program is correct. Compiler may issue as many warnings it
feels like to. The extra warnings that you see are invoked
by "-Wall" option to gcc (since we already have "-pedantic", this
one could be called "-paranoic"); look into the gcc documentation.

I know what flags I am passing, even tho the program might be correct
I still feel it's proper custom to have code compiled cleanly without
any warnings..

I agree. But there must be some limit to the warnings level beyond
which they don't help you write better code, but just annoy you and
force you to keep unnecessary clutter.
I have tried to use "-Wall" for some time, but dropped it, because
it didn't give me any useful information.
For example, I often use this idiom:
struct object { /*...*/ };
const struct object object_zero = {0}; /* a typed "constant" */
which is perfectly correct and clean code. With "-Wall" I would
have to write:
const struct object object_zero = {{{0,{0,{0,0},0},{0,{0,0}},0},.....etc}};
which doesn't look as good for me.
(There were also other reasons to get rid of "-Wall".)

--
Stan Tobias
mailx `echo si***@FamOuS.BedBuG.pAlS.INVALID | sed s/[[:upper:]]//g`

[Flash Gordon]

Stef wrote:

On 24 May 2005 03:32:09 -0700, "bjrnove" <bj*****@gmail.com> wrote:

This should work thow:
struct test bb[MAX][MAX] = {0};

If you put = {0}; as the initializer it will alway initialize the
entire thing to \0's.

But the compiler gives warnings then... like:
istrct.c: In function `main':
istrct.c:11: warning: missing braces around initializer
istrct.c:11: warning: (near initialization for `aaaa[0]')
istrct.c:12: warning: missing braces around initializer
istrct.c:12: warning: (near initialization for `bbbb[0]')
istrct.c:12: warning: unused variable `bbbb'
istrct.c:11: warning: unused variable `aaaa'

The compiler is allowed to warn about anything it wants to, even
perfectly correct C. If you are using gcc you can disable the warning,
but the details of gcc are off topic here.
--
Flash Gordon
Living in interesting times.
Although my email address says spam, it is real and I read it.

[Flash Gordon]

Stef wrote:

Hello,

I have a question:

Is it possible to init a 2d array of structures to zero ?

For example with array I do.
int array[MAX] = {0}

but:
structure test bb[MAX][MAX] = {{0},{0}};

won't work.. ?

You can just use:
structure test bb[MAX][MAX] = {0};
--
Flash Gordon
Living in interesting times.
Although my email address says spam, it is real and I read it.

[Chris Torek]

In article <m2********************************@4ax.com>
Stef <St*****@sirtakie.tk> wrote:

... I still feel it's proper custom to have code compiled
cleanly without any warnings..

I agree with this sentiment, and in this case the "fix" was
clear enough (put in the right number of braces), but consider:
what will you do if you need to compile with both Compiler A
*and* Compiler B, and code of the form:

void f(short s) {
...
}

produces:

warning: function f will not be compatible with K&R C

from compiler A, so you try instead:

void f(int s0) {
short s = s0;
...
}

which produces:

warning: assignment to s may truncate s0

from Compiler B, so you try something else (such as a cast or a
mask), but no matter what you do, you always get at least one
warning from at least one of the two compilers?

In extreme cases, you might even find that a single compiler produces
a warning no matter what you do. Sometimes you have to live with
warnings. :-)

Ideally, there is some portable and clear way to write the code
that is warning-free, but sometimes "there just ain't". Occasionally
one can get rid of a warning by writing nonportable, convoluted,
fragile code instead of portable, simple, robust code; in this
case, eliminating the warning is not a good idea after all.
--
In-Real-Life: Chris Torek, Wind River Systems
Salt Lake City, UT, USA (40°39.22'N, 111°50.29'W) [phone]
email: forget about it http://web.torek.net/torek/index.html
Reading email is like searching for food in the garbage, thanks to spammers.

[Stef]

On 24 May 2005 16:29:10 GMT, Chris Torek <no****@torek.net> wrote:

In article <m2********************************@4ax.com>
Stef <St*****@sirtakie.tk> wrote:

... I still feel it's proper custom to have code compiled
cleanly without any warnings..

I agree with this sentiment, and in this case the "fix" was
clear enough (put in the right number of braces), but consider:
what will you do if you need to compile with both Compiler A
*and* Compiler B, and code of the form:

void f(short s) {
...
}

produces:

warning: function f will not be compatible with K&R C

from compiler A, so you try instead:

void f(int s0) {
short s = s0;
...
}

which produces:

warning: assignment to s may truncate s0

from Compiler B, so you try something else (such as a cast or a
mask), but no matter what you do, you always get at least one
warning from at least one of the two compilers?

In extreme cases, you might even find that a single compiler produces
a warning no matter what you do. Sometimes you have to live with
warnings. :-)

Ideally, there is some portable and clear way to write the code
that is warning-free, but sometimes "there just ain't". Occasionally
one can get rid of a warning by writing nonportable, convoluted,
fragile code instead of portable, simple, robust code; in this
case, eliminating the warning is not a good idea after all.

Roger.. And thank yoo for the complete answer.

Stef