Gast
#284666
Hallo,
wer kann mir sagen was der unerscied zwischen folgendnen structs ist?
struct test
{
.
.
.
};
struct
{
.
.
.
}test;
Das eine ist eine benannte Struktur, das andere ist eine unbenannte Struktur mit gleichzeitiger Definition einer Variablen dieses namenlosen Typs.
Gast
#284668
Ok aber was passiert wenn ich es so mach
typedef struct
{
.....
}test;
test variablenname
So habe ich es nämlich gemacht.
Das würde ja dann heisen ich habe ein Variable von einer Variable
angelegt oder?
Nein, du hast einen Typ test angelegt, der eine namenlose Struktur bezeichnet, und dann von diesem Typen eine Variable.
Gast
#284670
Weis jemand eine Internet seite wo man das komplett mit den structs nachlesen kann und auch Beispiel dabei sind? Ich blicke mit den structs nicht kann durch
Das steht im K&R (Kernighan & Ritchie, "Programmieren in C", zweite Auflage, Hanser Verlag). Ist allerdings ein Buch, keine Internetseite.
Gast
#284672
Ist eigentlich ganz einfach.
struct blah { /* ... */ };
definiert eine struct mit Namen struct blah.
struct { /* ... */ };
definiert eine struct ohne Namen, die in dieser Form natürlich nicht
besonders nützlich ist.
typedef AlterName NeuerName;
Gibt dem Typ "AlterName" einen zweiten Namen "NeuerName", unter dem
er auch verwendbar ist. Die Syntax ist sehr ähnlich der zur Erzeugung
einer Variable des Typs, nur daß eben typedef davorsteht. Also:
int i; // Variable vom Typ int mit Namen i
typedef int j; // Alias für int mit Namen j
char c[100]; // Array aus 100 char
typedef char d[100]; // d ist nun ein anderer Name für so ein Array
struct x{ int i; }; // Eine struct mit Namen x.
struct x y; // Variable vom Typ struct x mit Namen y
typedef struct x z; // zweiter Name z für struct x
Und das kann man dann eben auch kombinieren:
struct { int i; } y; // neue unbenannte Struct mit gleichzeitiger
// Definition einer Variable y diesen Typs
struct x { int i; } y; // Genauso wie oben, nur daß die Struct den
// Namen x trägt
typedef struct x { int i } z; // neue struct x mit zweitem Namen z
Gast
#284673
Ja ok.
Ich habe ja folgendes gemacht:
typedef struct{.....}test
Diese Struktur ist in einer Header Datei.
Diese Binde ich dann in main.c ein.
In meiner main.c mach eich dann folgendes
static test name;
Mit name greife ich dann auf die Elemnte der Struktur zu.
Ist das dann überflüssig?
Ich kann doch dann auch direkt mit test auf die Elemnte zugreifen oder?
> Mit name greife ich dann auf die Elemnte der Struktur zu. > Ist das dann überflüssig? O nein static test name; definiert eine Variable vom Typ "test" mit dem Namen "name". Die Struktur selbst ist ja nur eine Vereinbarung, wie Daten organisiert werden, aber eben keine Variable. Das verhält sich bei den "eingebauten" Datentypen "int" etc. genauso. Mit Deinem typedef hast Du Dir also nur einen neuen Datentyp erzeugt; um was damit anfangen zu können, musst Du auch Variablen dieses Typs anlegen, und genau das hast Du mit static test name; auch gemacht.
Gast
#284675
@ Rufus
Aber oben wurde von Rolf geschrieben:
struct { int i; } y; // neue unbenannte Struct mit gleichzeitiger
// Definition einer Variable y diesen Typs
y ist eine Variable!!!!
Nach deinem post müsste dann aber y ein type von einer Structur sein
Gast
#284676
Ich schrieb aber auch:
typedef AlterName NeuerName;
Gibt dem Typ "AlterName" einen zweiten Namen "NeuerName", unter
dem
er auch verwendbar ist. Die Syntax ist sehr ähnlich der zur Erzeugung
einer Variable des Typs, nur daß eben typedef davorsteht.
Also:
struct{.....}test; // variable mit Namen test
typedef struct{.....}test; // Typ mit Namen test
Wenn ich's mir recht ansehe, verstehe ich schon, warum das
missverstanden werden konnte.
> Aber oben wurde von Rolf geschrieben: > > struct { int i; } y; // neue unbenannte Struct mit gleichzeitiger > // Definition einer Variable y diesen Typs > y ist eine Variable!!!! Das ist auch richtig so. Denn: Da steht kein typedef davor! Vielleicht verstehst Du es so besser. Nimm mal an Du hast die Definition einer Variablen: int xy; Dann ist xy eine Variable. Wenn Du da jetzt typedef davor schreibst, dann wird das ganze komplett modifiziert: Der Name der Variablen wird zum Namen des neuen Typs den Du einfuehren moechtest. Du definierst dann keine Variable mehr, sondern machst nur noch eine Aussage darueber, wie ein neuer Datentyp aussieht. typedef int xy; definiert also einen neuen Datentyp xy, der identisch ist zu int. Dementsprechend: struct { ... } ab; definiert eine Variable des Namens ab, die vom Typ der anbenannten struct ist. Ein typedef davor wandelt das ganze von einer Variablendefinition hin zu einer Typdefinition: typedef struct { ... } ab; definiert einen neuen Typ, der identisch ist mit dem der unbenannten struct. Das ist nur eine Vereinbarung, dass es einen Typ gibt, wie er heist und wie er aussieht. Aber keine Variablendefinition mehr. ab NeueVariable; hingegen, legt dann tatsaechlich die neue Variable an. Sie ist vom Typ ab, der ja durch den typedef definiert wurde als gleich zu struct { ... }
Gast
#284678
@Karl Heinz Vielen Dank. Jetzt habe ich es gerafft.
Antwort schreiben
Bitte melde dich an, um einen Beitrag zu schreiben.