Printable View
this is a code for the root of a treeCode:typedef struct object{
int data;
struct object *left;
struct object *right;
}object;
why do they add typedef
it makes no sense using it in the building of a data type
and there is no two names after the struct
The typedef allows you to refer to your struct later on as:
Otherwise you would have to use:Code:object something;
everytime you want to declare an object.Code:struct object something;
thats why they should write
but here typedef used in a very odd wayCode:typedef struct object object;
it makes no sense using it in the building of a data type
and there is no two names after the struct
??
eh ???
in order that we could do
like you saidCode:object something;
we need to write the code in this way
not like they didCode:typedef struct object object;
struct object{
int data;
struct object *left;
struct object *right;
}object;
why is it ok to do it in the way they write it??Code:typedef struct object{
int data;
struct object *left;
struct object *right;
}object;
Because the second form is entirely identical, but one line shorter? There is technically no difference between those two forms. It is however very much the convention to use one typedef/struct definition, rather than doing one typedef and one struct definition.
--
Mats
In fact, you can do this:Quote:
Originally Posted by transgalactic2
The datatype syntax is not half so dangerous as the poiner syntax ;)Code:typedef struct { int x; char *y; } odradek;
odradek actual_odek;
in the simple form of typedef we use two names.
Code:typedef struct first_name second_name;
i cant see those names in this code
Code:typedef struct object{
int data;
struct object *left;
struct object *right;
}object;
the "second_name" can (and often is) the same as "first_name".
is perfectly valid. There is no difference between that and defining the contents of the struct inside the typedef.Code:typdef struct object object;
--
Mats
in this code
where are the locations of the first and the second names in this code?Code:typedef struct object{
int data;
struct object *left;
struct object *right;
}object;
There is such a thing as an "anonymous" struct. It doesn't have a name. When I wrote you can do this:Quote:
Originally Posted by transgalactic2
It could have been:Code:typedef struct ?? { int x; char y; } odredek;
//don't really put ??
odradek actual_odek;
If you want to be able to use the two names, but usually there is no purpose to that, so you can use the first method, where the struct is anonymous.Code:typedef struct o_dek odradek;
struct o_dek { int x; char *y; };
odradek actual_odek;
i cant understand this code:
we create a data type using struct
we can create an alias for struct name1 usingCode:struct object{
int data;
struct object *left;
struct object *right;
}object;
but i dont know what the meaning of adding typedef to the codeCode:typedef struct name1 name2;
first you create some variable called odredek with type "??"(some_name)Code:typedef struct ?? {
int x;
char y;
} odredek;
odradek actual_odek;
but i cant understand why to add the word typedef because i cant see here the struct name1=name2 replacement issue
what its affect?
The "??" was just to indicate that you're right, there could be an object name there, but there does not have to be, which means the struct is anonymous. The only object name we need is the name of our new datatype (odradek), created with the command typedef. The base type of odradek was/is an anonymous struct.Quote:
Originally Posted by transgalactic2
Yes, you could have done much the same thing by just creating a struct, odradek. One advantage to creating a new datatype with typedef is that you can now have a function return it:
This works with a normal struct, too. Many, many library objects are actually structs of this sort, which I'm sure is part of the reason you can get around having to refer to "struct X" all the time.Code:#include <string.h>
#include <stdio.h>
#include <stdlib.h>
typedef struct { int x; char *y; } odradek;
odradek Example (int x, char *y) {
odradek a_odek;
a_odek.x=x;
a_odek.y=malloc(strlen(y)+1);
strcpy(a_odek.y, y);
return a_odek;
}
int main() {
int x=10;
char this[]="that would be";
odradek example=Example(x,this);
printf("%d: %s\n",example.x,example.y);
free(example.y);
}
The free() call demonstrates that main() did recieve a malloc'd object. Of course, you should do that anyway.
The first is in red, the second is in green.Quote:
Originally Posted by transgalactic2
You can define a struct like this:You can then define an instance of 'struct mytype' like this:Code:struct mytype {
int elem1, elem2;
char elem3;
};
You can do both of those things at once like this:Code:struct mytype myinstance;
myinstance.elem1 = 1;
myinstance.elem2 = 2;
You can make an instance of that struct without giving it's type a name. That's called an 'anonymous struct'.Code:struct mytype {
int elem1, elem2;
char elem3;
} myinstance;
myinstance.elem1 = 1;
myinstance.elem2 = 2;
typedef creates an alias of a typeCode:struct {
int elem1, elem2;
char elem3;
} myinstance;
myinstance.elem1 = 1;
myinstance.elem2 = 2;
struct mytype anotherinstance; /* error: no type 'struct mytype' */
You can use typedef to create aliases of structsCode:typedef int x;
x i;
int y;
y = 5;
i = y;
printf("%d", i);
You can declare the typedef and define the struct type in the same statementCode:struct mytype {
int elem1, elem2;
char elem3;
};
typedef struct mytype anothertype;
struct mytype myinstance; /* 'struct' keyword needed */
anothertype anotherinstance; /* 'struct' keyword not needed */
void f(struct mytype v1, anothertype v2);
f(myinstance, anotherinstance);
f(anotherinstance, myinstance);
struct anothertype evenanotherinstance; /* error: no type 'struct anothertype' */
This is equivalent to above. Note that in the context of a typedef statement, an identifier between the closing brace and the semicolon is the name of the new type, not the name of a struct instance.Code:typedef struct mytype {
int elem1, elem2;
char elem3;
} anothertype;
struct mytype myinstance;
anothertype anotherinstance;
You can make a typedef to a struct type that doesn't have a nameCode:typedef struct {
int elem1, elem2;
char elem3;
} anothertype;
anothertype anotherinstance;
struct mytype myinstance; /* error: no type 'struct mytype' */
i understood your anonymous struct
creating a data type from an anonymous name
but it not the case here:
i have a variable called "object"Code:typedef struct object{
int data;
struct object *left;
struct object *right;
}object;
but there is no anonimus struct
on the contrary i have the first name but not the alias second name
??
so the "object" in the last line unlike normal structs does not represent a variable but a variable type
an alias to
struct object
in a regular struct like this:
Code:struct mytype {
int elem1, elem2;
char elem3;
} object;
object.elem1 = 1;
object.elem2 = 2; //object represents a variable here unlike my example
Well, that's what a typedef does. Makes the second thing an alias for the first thing.Quote:
Originally Posted by transgalactic2
regarding this code:
i know that variable "this" is of type orbarekCode:#include <string.h>
#include <stdio.h>
#include <stdlib.h>
typedef struct { int x; char *y; } odradek;
odradek Example (int x, char *y) {
odradek a_odek;
a_odek.x=x;
a_odek.y=malloc(strlen(y)+1);
strcpy(a_odek.y, y);
return a_odek;
}
int main() {
int x=10;
char this[]="that would be";
odradek example=Example(x,this);
printf("%d: %s\n",example.x,example.y);
free(example.y);
}
but in order to assign values to "this" (in java i used a costructor)
where is it in this code?
this is an array of characters while a_odek is of the type odradek which is an alias of the complex type you have defined.
aahhh sorryy i thought there is "this" and constructors in C
The variable "this" is of type char[], and it is initialized (remember initialization?) right where it is declared, one line above the line you highlighted. To change its value, you should use strcpy, just as you did in the Example function.
thanks
> i have a variable called "object"
You have two things, and neither of them are objects.
The names in red are the structure tag name, which serves to identify the struct by name. You NEED a tag name if you're creating a self-referencing structure like you're doing here.Code:typedef struct object{
int data;
struct object *left;
struct object *right;
}object;
Much of the time, the tag name is omitted if the struct is embedded in a typedef declaration (such as this).
The blue name is the name of the typedef name for the struct.
It's a completely different name to the red one.
BOTH can be used to create objects, like so.
Code:object foo;
struct object bar;
You seem to misunderstand.Quote:
Originally Posted by transgalactic2
The "object" part at the end is part of the typedef, and does not create an instance of the struct.
The actual definition or declaration of the struct is ignored, so the above code would ultimately look like:
(Note that I just cut out the contents of the struct type.)Code:typedef struct object object;
If, on the other hand, we don't put typedef before the struct, so it becomes:
Then it does indeed create an instance of the struct called object.Code:struct object{
int data;
struct object *left;
struct object *right;
}object;