how to interprete this signature..

node=struct node
so every time i see node i need to think as if it was

struct node

but this kind of function signature makes no sense to me :
struct node *what(node *tree)

Code:

---

typedef struct node node;
struct node{
    int value,count;
    node *lc,*rc;
};

node *what(node *tree){
    node *save,*temp;
    int flag;
    if(!tree)return NULL;
    if(!tree->lc && !tree->rc){
          free(tree);
          return NULL;
    }
    save=temp=tree;
    if(save->lc) {flag=1;
                  save=save->lc;
                  while(save->rc){
                      flag=0;
                      temp=save;
                      save=save->rc;
                  }
    }
    else{ flag=0;
          save=save->rc;
          while(save->lc){
              flag=0;
              temp=save;
              save=save->rc;
          }

    }
    if(!flag)
          temp->rc=save->lc;
    else
          temp->lc=save->rc;
    tree->value=save->value;
    return tree;
}

---

It's a function that takes a pointer-to-node and returns a pointer-to-node.

Code:

---

struct node *what(struct node *tree)

---

If you replace "node" with "struct node", then you should do it in ALL of the places.

--
Mats

i know that if i will not replace then it will mean
a function that takes a node pointer and returns a node pointer

but because of the typedef line i have to think of each node as struct node

this kind of function signature makes no sense to me :

Code:

---

struct node *what(struct node *tree)

---

I'm not sure what part of "struct node" and "node" are EXACTLY the same thing that is so hard to EXPLAIN (as we're now on the third or fourth thread, and several posts into the third one). Typedef in this case is simply making it easier to type things by some 6 characters. No other meaning, hidden or visible, is in the typedef statement in this example.

The function accepts a pointer to a (struct )node and returns a pointer to a (struct )node. The (struct )node contains four elements, a value and a count, which are both integers, and a pair of left/right pointers to other nodes. This makes it a form of binary tree.

If I've missed something here, can you please clarify what part of this that I've not explained clearly.

--
Mats

what is the normal way of using a variable in C
do you add struct near every variable
when do you add the word struct??
i thought you put struct only when we create a new variable
not in the signature of a function

??

struct means that it's "compound type", meaning that it's not a simple variable that has only one content (one value at any given time) - char or int would be typical simple variables.

A struct is one or more instances of member variables. That may be one or two integers (x & y) in a coordinate struct, or a few dozen member variables describing a rental contract for a car hire company (typical thing you'd find there is a contract number, driver name, date&time out and date&time when it should be returned, the number of miles the car had done when it went out, just to give few examples).

You use struct whenever you refer to the struct type. However, the language has something called "typedef" which can give any type a different name. We can for example use:

Code:

---

typedef int INTEGER;

---

Now, everywhere we use "INTEGER", it will mean exactly the same thing as int (which is of course quite silly).

If we want to make a shorter name for "struct someverylongsillyname", we could use

Code:

---

typedef struct someverylongsillyname svlsn;

---

, and use "svlsn" instead of "struct someverylongsillyname".

It is just a convenient way to change the name of a type.

--
Mats

Simply put: you must add "struct" everywhere you refer to a type that is actually a struct. But, you can also make a typedef to create an alias to that struct and thus not having to type out "struct".
It is a C limitation, you could say, one of which I would believe many would be happy if removed. It does not exist in C++, either.

Code:

---

struct foo_ {};
struct foo_* foo_function(struct foo_* p) {} // foo is a struct; must add struct keyword
int* foo_function2(double* x) {} // int and double are not structs, so struct should not be used

typedef struct foo_ foo;
foo* foo_function3(foo* p) {} // Since "foo" is a typedef for "struct foo_", we're okay.

---

so in case of a complex variable i add struct (like node,array,string,pointer etc..)

but on variables like int,float,char then i write them without adding struct

Quote:

---

Originally Posted by transgalactic2

so in case of a complex variable i add struct (like node,array,string,pointer etc..)

---

No. On any struct.
Is node a struct in your example? Yes. Then it requires struct.
However, note that in the example, you have also made a typedef (or an alias) of node that means struct node. So you can use the alias, too.

Quote:

---

but on variables like int,float,char then i write them without adding struct

---

Yes, anything that is not a struct.

is there a list that specifies exactly
in what type of variables we have to use struct
??

and another question:
do i declare interger as

int i; (without struct at the start)

Quote:

---

Originally Posted by transgalactic2

is there a list that specifies exactly
in what type of variables we have to use struct
??

---

No, because they are infinite.
Seriously, what is the problem here?
A struct! Do you know what a struct is?

Quote:

---

and another question:
do i declare interger as

int i; (without struct at the start)

---

Yes!
It is not a struct, is it?

struct really means that it is a "structure consisting of", and then the components (member variables) that it consists of.

A complex number would be:

Code:

---

struct complex
{
  double real;
  double imag;
};

---

You use struct whenever you want to "make a package" of more than one variable that belong together. That may be a node in a linked list, binary tree or such, or a bunch of variables that define a car rental contract, a set of doubles to make up a complex number, the coordinates for a rectangle, or anything else where you want more than one thing in as something you can deal with as a "package".

Think of it as Mechano: The simple types (int, float, etc) are nuts and bolts. The bits with holes in them are arrays. Combine them correctly, and you can build complex things: structurs (structs). You can build small things (say a propeller) from a few things, and use that to complete your aeroplane that also is consisting of various components.

--
Mats

i know that we use struct when we are creating a new type of complex variable like node
or every other type of a complex variable

but in a case of a pointer
int * ptr; //we do not use struct

or in array
int arr[];
so i come to the conclusion that we use struct only when we have sub variables (like node)

"sub variables" as you call them is a design of a struct.
A struct is a type that you define, that can hold several variables inside.
And if you want to create a variable of that type, then you must use the keyword struct before. Plain and simple. You can get around that by creating an alias for it, a typedef and thus use the new alias for the type.

You didn't create a new type in int *. You didn't create a new type in int []. Since you didn't create it, it's not a struct type. Only you can create structs.

thanks i think i understood this struct thing

what this line means

Code:

---

if(!tree)return NULL;

---

i know that ! means differ but here they didnt mention
differ what??

Simple boolean magic.
Basic rules:
0 is false. Always.
Everything else is true. Always.

Basic if form:
if (!tree == true)

Let us assume that tree contains a value of NULL.
Thusly, tree is interpreted as false in boolean form (since NULL is one way or another 0).
Thus, we get:
if (!false == true)

The ! operator will invert the meaning of the value it is applied to, so we get:
if (true == true)

Or in other words, it's a short-hand for:
if (tree == NULL)

ok i understood this "!" thing
igot problem understanding something else
its a complex variable
inside this node variable we have two sub variables
data (which can be null or not)
so is the sub variable next

those two different sub variable

we cant see them as one

i dont know what the meaning of tree=null
regarding its subvariables
??

Quote:

---

Originally Posted by Elysia

Simple bool magic.
if ( !tree ) is actually if ( !tree == true )
So if tree == NULL, if (tree) would be false.
Add the ! operator to change that false to true and you get:
if (true == true)
Or in other words, it's a short-hand for:
if (tree == NULL)

---

true and tree being in the same conditional statement is hard for my simpleton brain to wrap around.

See them as one what? They already are one node.

what are the values of root.data and root.next

when we do

Code:

---

root=null;

---

Code:

---

if(!root)
{
  /* Not messing with members of root goes here!!!!! */
}

---

NULL pointers, as they are commonly referred to. Pointers pointing to "nothing."
They cannot be dereferenced, but it is an easy way to tell if they point to something valid or not.

root is a pointer. It is not a struct.

when we are doing

root=null
we treat it as if it was a simple variable

but its not

Code:

---

root=null;

---

what are the values of root.data and root.next

when we do

Quote:

---

Originally Posted by transgalactic2

when we are doing

root=null
we treat it as if it was a simple variable

---

That's because it is. It is a pointer.

Quote:

---

Originally Posted by transgalactic2

when we are doing

root=null
we treat it as if it was a simple variable

but its not

Code:

---

root=null;

---

what are the values of root.data and root.next

when we do

---

Again, and in english instead of C this time. If root is NULL (or root has NO value) then do NOT be trying to access its members. Unless the original question was how do I generate a seg fault with little effort, in which case be my guest, sport.

but its of a complex type

so i guess
it puts null on every sub variable of this type

Quote:

---

Originally Posted by master5001

true and tree being in the same conditional statement is hard for my simpleton brain to wrap around.

---

Updated example. Better now?

so when it null
we cant access the sub variables

Quote:

---

Originally Posted by transgalactic2

but its of a complex type

---

No. NO. And No. Root is NOT of a complex type. It is a pointer, which is a simple type. ALL it stores is an address. It does not have sub-fields, or anything like that.

Try using root.lc in your code somewhere. Notice how it doesn't work? That's because root is not a struct node. It is a pointer.

Quote:

---

Originally Posted by transgalactic2

so when it null
we cant access the sub variables

---

You cannot access any valid information or instance of the data because the pointer will not be pointing to a valid instance of the struct.
Or in other words - it is like having an address to a house in... nowhere. How do you get the information from within the house if you cannot find the house?
The pointer is the address and it points to the house.

thanks i understand this now

Wow... you made tabstop upset. Kudos to you for that.

Quote:

---

Originally Posted by Elysia

Updated example. Better now?

---

Much. Thanks. Its good to see code that is illiterate blond, friendly.

Quote:

---

Originally Posted by Elysia

Simple boolean magic.
Basic rules:
0 is false. Always.
Everything else is true. Always.

Basic if form:
if (!tree == true)

Let us assume that tree contains a value of NULL.
Thusly, tree is interpreted as false in boolean form (since NULL is one way or another 0).
Thus, we get:
if (!false == true)

The ! operator will invert the meaning of the value it is applied to, so we get:
if (true == true)

Or in other words, it's a short-hand for:
if (tree == NULL)

---

so
false=null
and when they say
(!tree) that means tree differs true
so they ask us if tree equals null

Quote:

---

Originally Posted by transgalactic2

so
false=null
and when they say
(!tree) that means tree differs true
so they ask us if tree equals null

---

Correct. (x == NULL) or (!x) is the same thing. It is fairly common to see (!x) rather than (x == NULL), but you will eventually see both at some point during your programming life.

--
Mats