c structs

[ygfperson]

i'm used to using c++ classes and structs, and i don't know exaclty what to do with c-style structs.

typedef struct node_t {
  struct node* zero;
  struct node* one;
  struct node* parent;
  struct node* next;
  struct node* head;
  int frequency;
  int value;

  } node, *pnode;

this is what i have. it seems to work until i try to change the node pointers to anything but NULL. my compiler, gcc, complains about "Dereferencing pointer to incomplete type" and "warning: assignment from incompatable pointer type"

any ideas on what's wrong? i'm trying to create a linked list/binary tree. i don't know if i can use the pointers inside the struct because the struct hasn't yet been defined.

[no-one]

try

typedef struct node_t
{
    struct node_t* zero;
    struct node_t* one;
    struct node_t* parent;
    struct node_t* next;
    struct node_t* head;
    int frequency;
    int value;
} node, *pnode;

::edit:: you should also probably reverse the naming to

typedef struct node
{
    struct node* zero;
    struct node* one;
    struct node* parent;
    struct node* next;
    struct node* head;
    int frequency;
    int value;
} node_t, *pnode;

[ygfperson]

i got that part down. my problem now is in this function:

node_t* nth_node(node_t x[],int n) {
  node_t* temp;
  temp=x[0];
  while (n) {
    temp=temp->next;
    n--;

  }
  return temp;

}

i have an array declared like this:

node_t nodes[256];

and the prototype's like this:

node_t* nth_node(node_t[],int);

i'm calling the function like this:
[code]
nth_node(nodes,1)->left = nth_node(nodes,2);
it's giving me "invalid type argument of '->'" and "warning: passing arg1 of nth_node with incompatable pointer type", and also an lvalue error. any ideas? thanks in advance

[The Dog]

The problem could possibly be that
nth_node(nodes,1)->left
isn't returning the actual address of the original struct.

Try changing the declaration to this:
node_t* nth_node(node_t*,int);

I'm not 100% on this though.

[Shiro]

Note that temp is a pointer to struct and x[0] is a struct. You want temp to point to x[0], so it should be temp = &x[0].

[james012]

Regarding this line:

nth_node(nodes,1)->left = nth_node(nodes,2);

The reason that you are getting these errors is that the compiler is expecting a variable as the lvalue -- a function call cannot serve as the lvalue.

Another thing is that the '->' operator cannot have a function on its left side.

Alternatively, you can try this:

node_t Ptr_Temp = nth_node(nodes,1);
Ptr_Temp -> Left = nth_node(nodes,2);

[james012]

Sorry, that last line should be:

Ptr_Temp -> left = nth_node(nodes, 2);

[The Dog]

The reason that you are getting these errors is that the compiler is expecting a variable as the lvalue -- a function call cannot serve as the lvalue.

Another thing is that the '->' operator cannot have a function on its left side.

Hmmm......

Then I wonder why this works

#include <stdio.h>

typedef struct Person
{
	char name[20];
	char surname[20];
	struct Person* next;
}Person;

typedef Person* ptrPerson;

ptrPerson function(ptrPerson temp)
{
	return temp;
}

int main()
{
	ptrPerson one = new Person;
	
	function(one)->next = NULL;
	delete one;
	
	return 0;
}

[Hammer]

>Then I wonder why this works
Probably 'cos it's not C, its C++. (guessing here!)

[The Dog]

>> Probably 'cos it's not C, its C++. (guessing here!)

Close, but no cigar.

It works 'cos C says that there's nothing wrong with that.

I changed the code so it used malloc/free and changed the extension to ".C", and it still worked.

[no-one]

Shiro nailed it.

second reguarding,

nth_node(nodes,1)->left = nth_node(nodes,2);

this is a perfectly legal line of code in C and C++, here is why.

to break it down as simple as possible in sequence.

nth_node(nodes,1)->left = nth_node(nodes,2)

the functions nth_node() is called first, it now reads like this.

returned_pointer_to_1->left = returned_pointer_to_2;

where 'returned_pointer_*' is the node_t* returned by the function nth_node().

now,
'returned_pointer_to_1' is first deferenced by '->' operator
and then its member 'left' is accessed, it could be rewritten like so

(*returned_pointer_to_1).left = returned_pointer_to_2;

then asignment takes place, i think you understand the rest.

[james012]

Sorry, I got that one wrong. That was my mistake.