Using an instance of a struct as a member of that struct

[dutchgoldtony]

Hi all,

I was just wondering if this is possible. I'm trying to implement a
viterbi decoder in C and am creating an array of nodes (the struct),
and an array of pointers to nodes (the member I'm worried about)
connecting to it like so:

// snippet start
typedef struct _node{
char state[2]; // The state of each node ("00","01","10" ,"11")
int status ; // 1: Node is on potential path (exists), 0: not
node* connectedNodes[2]; // Array of ptrs to nodes connected to
this node
int edgeCost[2]; // Cost of edges coming from nodes
int cost; // Cost associated with node:
} node;
node n[4][maxDepth];
//snippet end

Is this line "node* connectedNodes[2];" legal?

Thanks in advance for any help,
Cheers, Tony

[Gordon Burditt]

>I was just wondering if this is possible.

No, you cannot have an instance of a struct as a member of that
struct. Assuming that the struct has at least one other member,
that would require infinite memory.

You can, however, have a *pointer* to the struct as a member of
that struct. This is common with linked lists.

I'm trying to implement a
viterbi decoder in C and am creating an array of nodes (the struct),
and an array of pointers to nodes (the member I'm worried about)
connecting to it like so:

// snippet start
typedef struct _node{
char state[2]; // The state of each node ("00","01","10" ,"11")
int status ; // 1: Node is on potential path (exists), 0: not
node* connectedNodes[2]; // Array of ptrs to nodes connected to
The above should be a struct _node *, not a node *.
You haven't defined the typedef 'node' yet.
this node
int edgeCost[2]; // Cost of edges coming from nodes
int cost; // Cost associated with node:
} node;
node n[4][maxDepth];
//snippet end

Is this line "node* connectedNodes[2];" legal?

No. Not in context.

Gordon L. Burditt

[Mike Wahler]

"dutchgoldt ony" <du***********@ gmail.com> wrote in message
news:11******** *************@o 13g2000cwo.goog legroups.com...

Hi all,

Re: Using an instance of a struct as a member of the struct
I was just wondering if this is possible.
Of course not, and with a bit of thought, you should realize why.
But that's not what you're trying to do in your code below.
I'm trying to implement a
viterbi decoder in C and am creating an array of nodes (the struct),
and an array of pointers to nodes (the member I'm worried about)
connecting to it like so:

// snippet start
typedef struct _node{
char state[2]; // The state of each node ("00","01","10" ,"11")
int status ; // 1: Node is on potential path (exists), 0: not
node* connectedNodes[2]; // Array of ptrs to nodes connected to
this node
int edgeCost[2]; // Cost of edges coming from nodes
int cost; // Cost associated with node:
} node;
node n[4][maxDepth];
//snippet end

Is this line "node* connectedNodes[2];" legal?

What did your compiler say? Anyway, yes it's legal.
The member 'connectedNodes ' is not an array of
type 'struct _node' objects, but an array of type
'struct _node *' (pointer to 'struct _node') objects.

Reminder:
When you populate that array with pointers, be sure
it contains addresses of valid objects (i.e. you must
either allocate or define those objects somewhere first,
and if you allocate them, don't forget to free them
when you're done with them).

-Mike

[Jordan Abel]

On 2005-11-14, Gordon Burditt <go***********@ burditt.org> wrote:

I was just wondering if this is possible.
No, you cannot have an instance of a struct as a member of that
struct. Assuming that the struct has at least one other member,
that would require infinite memory.

You can, however, have a *pointer* to the struct as a member of
that struct. This is common with linked lists.

I'm trying to implement a
viterbi decoder in C and am creating an array of nodes (the struct),
and an array of pointers to nodes (the member I'm worried about)
connecting to it like so:

// snippet start
typedef struct _node{
char state[2]; // The state of each node ("00","01","10" ,"11")
int status ; // 1: Node is on potential path (exists), 0: not
node* connectedNodes[2]; // Array of ptrs to nodes connected to

The above should be a struct _node *, not a node *.
You haven't defined the typedef 'node' yet.
no, it shouldn't be struct _node *
it should be struct node *.

typedef struct node {
...
struct node *connectedNodes[2];
...
} node;
No. Not in context.

Gordon L. Burditt

[Default User]

Jordan Abel wrote:

On 2005-11-14, Gordon Burditt <go***********@ burditt.org> wrote:

The above should be a struct _node *, not a node *.
You haven't defined the typedef 'node' yet.

no, it shouldn't be struct _node *
it should be struct node *.

Depends on your definition of "should". What Gordon had was perfectly
legal. Some people object to having a tag name different from the
resulting typedef, but others find it promotes clarity. Some dislike
typedefs for structs, period.

Brian

[Gordon Burditt]

>> > The above should be a struct _node *, not a node *.

> You haven't defined the typedef 'node' yet.
no, it shouldn't be struct _node *
it should be struct node *.

Depends on your definition of "should".

I believe the point being brought up here is namespace issues.
What Gordon had was perfectly
I am not the original poster.
legal.
No, I don't believe it was. You can't use a typedef before
it's defined, and it's not defined until the *END* of the
definition.

typedef struct foo {
...
foo *x;
...
} foo;
isn't going to work. If you replace "foo *x;" with "struct foo *x;",
it will.
Some people object to having a tag name different from the
resulting typedef, but others find it promotes clarity. Some dislike
typedefs for structs, period.

Gordon L. Burditt

[Default User]

Gordon Burditt wrote:

> The above should be a struct _node *, not a node *.
> You haven't defined the typedef 'node' yet.

no, it shouldn't be struct _node *
it should be struct node *.
Depends on your definition of "should".

I believe the point being brought up here is namespace issues.

No, I don't think so.

What Gordon had was perfectly

I am not the original poster.

I know, you posted the original correct which changed the interior
declaration to struct _node *.

legal.

No, I don't believe it was. You can't use a typedef before
it's defined, and it's not defined until the END of the
definition.

Please reread the thread, and Jordan's comments.
typedef struct foo {
...
foo *x;
...
} foo;
isn't going to work. If you replace "foo *x;" with "struct foo *x;",
it will.

Who said it would?

Like I said, reread the thread, you've misinterpreted my remarks
entirely.

Brian

[Jordan Abel]

On 2005-11-14, Default User <de***********@ yahoo.com> wrote:

Jordan Abel wrote:

On 2005-11-14, Gordon Burditt <go***********@ burditt.org> wrote:

> The above should be a struct _node *, not a node *.
> You haven't defined the typedef 'node' yet.

no, it shouldn't be struct _node *
it should be struct node *.

Depends on your definition of "should". What Gordon had was perfectly
legal. Some people object to having a tag name different from the
resulting typedef, but others find it promotes clarity. Some dislike
typedefs for structs, period.

His use of the identifier "_node" is not legal.

[Default User]

Jordan Abel wrote:

On 2005-11-14, Default User <de***********@ yahoo.com> wrote:

Depends on your definition of "should". What Gordon had was
perfectly legal. Some people object to having a tag name different
from the resulting typedef, but others find it promotes clarity.
Some dislike typedefs for structs, period.

His use of the identifier "_node" is not legal.

Oh, right. That's reserved in tag name space as well as file scope.

Brian

[Jordan Abel]

On 2005-11-15, Default User <de***********@ yahoo.com> wrote:

Jordan Abel wrote:

On 2005-11-14, Default User <de***********@ yahoo.com> wrote:

> Depends on your definition of "should". What Gordon had was
> perfectly legal. Some people object to having a tag name different
> from the resulting typedef, but others find it promotes clarity.
> Some dislike typedefs for structs, period.

His use of the identifier "_node" is not legal.

Oh, right. That's reserved in tag name space as well as file scope.

I thought it was reserved everywhere full stop. Because even block scope
names could collide with an internal name used in a macro expansion.