Ich habe viele Programme gesehen, die aus Strukturen wie der folgenden bestehen

typedef struct 
{
    int i;
    char k;
} elem;

elem user;

Warum wird es so oft gebraucht? Gibt es einen bestimmten Grund oder einen bestimmten Bereich?

Wie Greg Hewgill sagte, bedeutet das typedef, dass Sie nicht mehr structüberall schreiben müssen . Das spart nicht nur Tastenanschläge, sondern kann auch den Code sauberer machen, da es eine smidgen mehr Abstraktion bietet.

Zeug wie

typedef struct {
  int x, y;
} Point;

Point point_new(int x, int y)
{
  Point a;
  a.x = x;
  a.y = y;
  return a;
}

wird sauberer, wenn Sie das Schlüsselwort "struct" nicht überall sehen müssen. Es sieht eher so aus, als ob es in Ihrer Sprache wirklich einen Typ namens "Point" gibt. Was nach dem wohl typedefder Fall ist.

Beachten Sie auch, dass Ihr Beispiel (und mein Beispiel) das Benennen des struct selbst selbst weggelassen hat, das tatsächliche Benennen jedoch auch nützlich ist, wenn Sie einen undurchsichtigen Typ angeben möchten. Dann hätten Sie Code wie diesen in der Kopfzeile, zum Beispiel:

typedef struct Point Point;

Point * point_new(int x, int y);

und geben Sie dann die structDefinition in der Implementierungsdatei an:

struct Point
{
  int x, y;
};

Point * point_new(int x, int y)
{
  Point *p;
  if((p = malloc(sizeof *p)) != NULL)
  {
    p->x = x;
    p->y = y;
  }
  return p;
}

In diesem letzteren Fall können Sie den Punkt nicht nach Wert zurückgeben, da seine Definition für Benutzer der Header-Datei nicht sichtbar ist. Dies ist beispielsweise eine in GTK + weit verbreitete Technik .

UPDATE Beachten Sie, dass es auch hoch angesehene C-Projekte gibt, bei denen diese Verwendung typedefzum Verbergen structals schlechte Idee angesehen wird. Der Linux-Kernel ist wahrscheinlich das bekannteste Projekt dieser Art. In Kapitel 5 des Linux Kernel CodingStyle-Dokuments finden Sie Linus 'verärgerte Worte. :) Mein Punkt ist, dass das "sollte" in der Frage vielleicht doch nicht in Stein gemeißelt ist.

Es ist erstaunlich, wie viele Leute das falsch verstehen. BITTE geben Sie keine Strukturen in C ein, sondern verschmutzen unnötigerweise den globalen Namespace, der normalerweise bereits in großen C-Programmen stark verschmutzt ist.

Typedef'd-Strukturen ohne Tag-Namen sind auch eine Hauptursache für das unnötige Auferlegen von Ordnungsbeziehungen zwischen Header-Dateien.

Erwägen:

#ifndef FOO_H
#define FOO_H 1

#define FOO_DEF (0xDEADBABE)

struct bar; /* forward declaration, defined in bar.h*/

struct foo {
  struct bar *bar;
};

#endif

Mit einer solchen Definition, bei der keine typedefs verwendet werden, kann eine Compiland-Einheit foo.h einschließen, um zur FOO_DEFDefinition zu gelangen . Wenn nicht versucht wird, das ' foobar' -Mitglied der Struktur zu dereferenzieren, muss die Datei "bar.h" nicht eingefügt werden.

Da sich die Namespaces zwischen den Tag-Namen und den Mitgliedsnamen unterscheiden, ist es auch möglich, gut lesbaren Code zu schreiben, wie z.

struct foo *foo;

printf("foo->bar = %p", foo->bar);

Da die Namespaces getrennt sind, besteht kein Konflikt bei der Benennung von Variablen, die mit ihrem Struktur-Tag-Namen übereinstimmen.

Wenn ich Ihren Code pflegen muss, werde ich Ihre typedef'd Strukturen entfernen.

Aus einem alten Artikel von Dan Saks ( http://www.ddj.com/cpp/184403396?pgno=3 ):

Die C-Sprachregeln für die Benennung von Strukturen sind etwas exzentrisch, aber ziemlich harmlos. Wenn sie jedoch auf Klassen in C ++ erweitert werden, öffnen dieselben Regeln kleine Risse, durch die Fehler kriechen können.

In C erscheint der Name in

struct s
    {
    ...
    };

ist ein Tag. Ein Tag-Name ist kein Typname. In Anbetracht der obigen Definition können Erklärungen wie

s x;    /* error in C */
s *p;   /* error in C */

sind Fehler in C. Sie müssen sie schreiben als

struct s x;     /* OK */
struct s *p;    /* OK */

Die Namen von Gewerkschaften und Aufzählungen sind ebenfalls Tags und keine Typen.

In C unterscheiden sich Tags von allen anderen Namen (für Funktionen, Typen, Variablen und Aufzählungskonstanten). C-Compiler verwalten Tags in einer Symboltabelle, die konzeptionell, wenn nicht physisch, von der Tabelle getrennt ist, die alle anderen Namen enthält. Somit ist es möglich, dass ein C-Programm sowohl ein Tag als auch einen anderen Namen mit derselben Schreibweise im selben Bereich hat. Zum Beispiel,

struct s s;

ist eine gültige Deklaration, die Variable s vom Typ struct s deklariert. Es ist möglicherweise keine gute Praxis, aber C-Compiler müssen dies akzeptieren. Ich habe nie eine Begründung dafür gesehen, warum C so entworfen wurde. Ich habe immer gedacht, dass es ein Fehler war, aber da ist es.

Viele Programmierer (einschließlich Ihrer wirklich) ziehen es vor, Strukturnamen als Typnamen zu betrachten, daher definieren sie einen Alias ​​für das Tag mithilfe eines typedef. Zum Beispiel definieren

struct s
    {
    ...
    };
typedef struct s S;

Ermöglicht die Verwendung von S anstelle von Strukturen wie in

S x;
S *p;

Ein Programm kann S nicht als Namen eines Typs und einer Variablen (oder einer Funktion oder Aufzählungskonstante) verwenden:

S S;    // error

Das ist gut.

Der Tag-Name in einer Struktur-, Vereinigungs- oder Aufzählungsdefinition ist optional. Viele Programmierer falten die Strukturdefinition in das typedef und verzichten ganz auf das Tag, wie in:

typedef struct
    {
    ...
    } S;

Der verlinkte Artikel enthält auch eine Diskussion darüber, wie das C ++ - Verhalten, kein zu benötigen, typedefsubtile Probleme beim Ausblenden von Namen verursachen kann. Um diese Probleme zu vermeiden, ist es auch für typedefIhre Klassen und Strukturen in C ++ eine gute Idee , auch wenn dies auf den ersten Blick unnötig erscheint. In C ++ wird das typedefAusblenden des Namens zu einem Fehler, über den der Compiler informiert, und nicht zu einer versteckten Quelle potenzieller Probleme.

Wenn Sie a verwenden, typedefmüssen structSie nicht jedes Mal schreiben, wenn Sie eine Variable dieses Typs deklarieren:

struct elem
{
 int i;
 char k;
};
elem user; // compile error!
struct elem user; // this is correct

Ein weiterer guter Grund, immer Aufzählungen und Strukturen einzugeben, ergibt sich aus diesem Problem:

enum EnumDef
{
  FIRST_ITEM,
  SECOND_ITEM
};

struct StructDef
{
  enum EnuumDef MyEnum;
  unsigned int MyVar;
} MyStruct;

Beachten Sie den Tippfehler in EnumDef in der Struktur (Enu u mDef)? Dies wird ohne Fehler (oder Warnung) kompiliert und ist (abhängig von der wörtlichen Interpretation des C-Standards) korrekt. Das Problem ist, dass ich gerade eine neue (leere) Aufzählungsdefinition in meiner Struktur erstellt habe. Ich verwende nicht (wie beabsichtigt) die vorherige Definition EnumDef.

Bei einem typdef hätte eine ähnliche Art von Tippfehlern zu Compilerfehlern bei der Verwendung eines unbekannten Typs geführt:

typedef 
{
  FIRST_ITEM,
  SECOND_ITEM
} EnumDef;

typedef struct
{
  EnuumDef MyEnum; /* compiler error (unknown type) */
  unsigned int MyVar;
} StructDef;
StrructDef MyStruct; /* compiler error (unknown type) */

Ich würde IMMER befürworten, Strukturen und Aufzählungen zu tippen.

Nicht nur, um etwas zu tippen (kein Wortspiel beabsichtigt;)), sondern weil es sicherer ist.

Linux-Kernel-Codierungsstil Kapitel 5 bietet große Vor- und Nachteile (meistens Nachteile) der Verwendung typedef.

Bitte verwenden Sie keine Dinge wie "vps_t".

Es ist ein Fehler , typedef für Strukturen und Zeiger zu verwenden. Wenn Sie eine sehen

vps_t a;

Was bedeutet es in der Quelle?

Im Gegensatz dazu, wenn es heißt

struct virtual_container *a;

Sie können tatsächlich sagen, was "a" ist.

Viele Leute denken, dass Typedefs "die Lesbarkeit verbessern". Nicht so. Sie sind nur nützlich für:

(a) völlig undurchsichtige Objekte (wobei das typedef aktiv verwendet wird, um zu verbergen, was das Objekt ist).

Beispiel: "pte_t" usw. undurchsichtige Objekte, auf die Sie nur mit den richtigen Zugriffsfunktionen zugreifen können.

HINWEIS! Undurchsichtigkeit und "Zugriffsfunktionen" sind an sich nicht gut. Der Grund, warum wir sie für Dinge wie pte_t usw. haben, ist, dass es dort wirklich absolut keine tragbaren Informationen gibt.

(b) Löschen Sie ganzzahlige Typen, wobei die Abstraktion dazu beiträgt , Verwirrung zu vermeiden, ob sie "int" oder "long" ist.

u8 / u16 / u32 sind vollkommen feine Typedefs, obwohl sie besser in Kategorie (d) passen als hier.

HINWEIS! Wieder - es muss einen Grund dafür geben. Wenn etwas "lange nicht signiert" ist, gibt es keinen Grund dazu

typedef unsigned long myflags_t;

Wenn es jedoch einen klaren Grund dafür gibt, warum es unter bestimmten Umständen ein "unsigned int" und unter anderen Konfigurationen ein "unsigned long" sein kann, dann verwenden Sie auf jeden Fall ein typedef.

(c) Wenn Sie mit sparse buchstäblich einen neuen Typ für die Typprüfung erstellen .

(d) Neue Typen, die unter bestimmten außergewöhnlichen Umständen mit Standard-C99-Typen identisch sind.

Obwohl es nur eine kurze Zeit dauern würde, bis sich Augen und Gehirn an die Standardtypen wie 'uint32_t' gewöhnt haben, lehnen manche Leute ihre Verwendung trotzdem ab.

Daher sind die Linux-spezifischen Typen 'u8 / u16 / u32 / u64' und ihre signierten Entsprechungen zulässig, die mit den Standardtypen identisch sind - obwohl sie in Ihrem eigenen neuen Code nicht obligatorisch sind.

Wenn Sie vorhandenen Code bearbeiten, der bereits den einen oder anderen Satz von Typen verwendet, sollten Sie die vorhandenen Auswahlmöglichkeiten in diesem Code einhalten.

(e) Typen, die für die Verwendung im Benutzerbereich sicher sind.

In bestimmten Strukturen, die für den Benutzerbereich sichtbar sind, können wir keine C99-Typen benötigen und das obige Formular 'u32' nicht verwenden. Daher verwenden wir __u32 und ähnliche Typen in allen Strukturen, die für den Benutzerbereich freigegeben sind.

Vielleicht gibt es auch andere Fälle, aber die Regel sollte grundsätzlich sein, NIEMALS ein typedef zu verwenden, es sei denn, Sie können einer dieser Regeln eindeutig entsprechen.

Im Allgemeinen sollte ein Zeiger oder eine Struktur mit Elementen, auf die vernünftigerweise direkt zugegriffen werden kann, niemals ein typedef sein.

Es stellt sich heraus, dass es Vor- und Nachteile gibt. Eine nützliche Informationsquelle ist das wegweisende Buch "Expert C Programming" ( Kapitel 3 ). Kurz gesagt, in C gibt es mehrere Namespaces: Tags, Typen, Mitgliedsnamen und Bezeichner . typedefFührt einen Alias ​​für einen Typ ein und sucht ihn im Tag-Namespace. Nämlich,

typedef struct Tag{
...members...
}Type;

definiert zwei Dinge. Ein Tag im Tag-Namespace und ein Typ im Typ-Namespace. Sie können also beides tun Type myTypeund struct Tag myTagType. Erklärungen wie struct Type myTypeoder Tag myTagTypesind illegal. In einer Erklärung wie dieser:

typedef Type *Type_ptr;

Wir definieren einen Zeiger auf unseren Typ. Also, wenn wir erklären:

Type_ptr var1, var2;
struct Tag *myTagType1, myTagType2;

dann var1, var2und myTagType1sind Zeiger aber auf Typ myTagType2nicht.

In dem oben erwähnten Buch wird erwähnt, dass Typedefing-Strukturen nicht sehr nützlich sind, da sie den Programmierer nur vor dem Schreiben der Wortstruktur bewahren. Ich habe jedoch einen Einwand, wie viele andere C-Programmierer. Obwohl es manchmal dazu führt, dass einige Namen verschleiert werden (deshalb ist es in großen Codebasen wie dem Kernel nicht ratsam), wenn Sie Polymorphismus in C implementieren möchten, hilft es hier sehr, nach Details zu suchen . Beispiel:

typedef struct MyWriter_t{
    MyPipe super;
    MyQueue relative;
    uint32_t flags;
...
}MyWriter;

du kannst tun:

void my_writer_func(MyPipe *s)
{
    MyWriter *self = (MyWriter *) s;
    uint32_t myFlags = self->flags;
...
}

Sie können also durch Casting auf ein äußeres flagsElement ( MyPipe) über die innere Struktur ( ) zugreifen . Für mich ist es weniger verwirrend, den gesamten Typ zu besetzen, als (struct MyWriter_ *) s;jedes Mal, wenn Sie solche Funktionen ausführen möchten. In diesen Fällen ist eine kurze Referenzierung eine große Sache, insbesondere wenn Sie die Technik in Ihrem Code stark einsetzen.

Zum Schluss noch der letzte Aspekt mit typedef ed-Typen die Unfähigkeit, sie im Gegensatz zu Makros zu erweitern. Wenn Sie zum Beispiel haben:

#define X char[10] or
typedef char Y[10]

Sie können dann deklarieren

unsigned X x; but not
unsigned Y y;

Dies ist für Strukturen nicht wirklich wichtig, da es nicht für Speicherspezifizierer ( volatileund const) gilt.

Ich denke nicht, dass Vorwärtsdeklarationen mit typedef überhaupt möglich sind. Die Verwendung von struct, enum und union ermöglicht das Weiterleiten von Deklarationen, wenn Abhängigkeiten (bekannt) bidirektional sind.

Stil: Die Verwendung von typedef in C ++ ist sehr sinnvoll. Dies kann fast erforderlich sein, wenn Vorlagen verwendet werden, für die mehrere und / oder variable Parameter erforderlich sind. Das typedef hilft dabei, die Benennung gerade zu halten.

Nicht so in der Programmiersprache C. Die Verwendung von typedef dient meist keinem anderen Zweck, als die Verwendung der Datenstruktur zu verschleiern. Da nur {struct (6), enum (4), union (5)} Anzahl von Tastenanschlägen verwendet wird, um einen Datentyp zu deklarieren, wird das Aliasing der Struktur fast nicht verwendet. Ist dieser Datentyp eine Union oder eine Struktur? Wenn Sie die einfache, nicht typdefinierte Deklaration verwenden, wissen Sie sofort, um welchen Typ es sich handelt.

Beachten Sie, wie Linux unter strikter Vermeidung dieses Aliasing-Unsinns geschrieben wird, den typedef mit sich bringt. Das Ergebnis ist ein minimalistischer und klarer Stil.

Beginnen wir mit den Grundlagen und arbeiten uns nach oben.

Hier ist ein Beispiel für die Strukturdefinition:

struct point
  {
    int x, y;
  };

Hier ist der Name pointoptional.

Eine Struktur kann während oder nach ihrer Definition deklariert werden.

Deklarieren während der Definition

struct point
  {
    int x, y;
  } first_point, second_point;

Nach Definition deklarieren

struct point
  {
    int x, y;
  };
struct point first_point, second_point;

Beachten Sie nun sorgfältig den letzten Fall oben; Sie müssen schreiben struct point, um Strukturen dieses Typs zu deklarieren, wenn Sie diesen Typ zu einem späteren Zeitpunkt in Ihrem Code erstellen möchten.

Geben Sie ein typedef. Wenn Sie beabsichtigen, zu einem späteren Zeitpunkt in Ihrem Programm eine neue Struktur (Struktur ist ein benutzerdefinierter Datentyp) mit demselben Entwurf zu erstellen, ist die Verwendung typedefwährend der Definition möglicherweise eine gute Idee, da Sie einige Eingaben in Zukunft sparen können.

typedef struct point
  {
    int x, y;
  } Points;

Points first_point, second_point;

Ein Wort der Vorsicht bei der Benennung Ihres benutzerdefinierten Typs

Nichts hindert Sie daran, das Suffix _t am Ende Ihres benutzerdefinierten Typnamens zu verwenden, aber der POSIX-Standard behält sich die Verwendung des Suffixes _t zur Bezeichnung von Standardbibliothekstypnamen vor.

Der Name, den Sie (optional) der Struktur geben, wird als Tag-Name bezeichnet und ist, wie bereits erwähnt, kein Typ für sich. Um zum Typ zu gelangen, ist das Strukturpräfix erforderlich.

Abgesehen von GTK + bin ich mir nicht sicher, ob der Tagname so häufig wie ein Typedef für den Strukturtyp verwendet wird. In C ++ wird dies erkannt, und Sie können das Schlüsselwort struct weglassen und den Tagnamen auch als Typnamen verwenden:

    struct MyStruct
    {
      int i;
    };

    // The following is legal in C++:
    MyStruct obj;
    obj.i = 7;

typedef stellt keinen co-abhängigen Satz von Datenstrukturen bereit. Dies kann man mit typdef nicht machen:

struct bar;
struct foo;

struct foo {
    struct bar *b;
};

struct bar {
    struct foo *f;
};

Natürlich können Sie immer hinzufügen:

typedef struct foo foo_t;
typedef struct bar bar_t;

Was genau ist der Sinn davon?

A> a typdef hilft bei der Bedeutung und Dokumentation eines Programms, indem aussagekräftigere Synonyme für Datentypen erstellt werden . Darüber hinaus helfen sie bei der Parametrisierung eines Programms gegen Portabilitätsprobleme (K & R, S. 147, C prog lang).

B> Eine Struktur definiert einen Typ . Structs ermöglicht die bequeme Gruppierung einer Sammlung von Variablen zur Vereinfachung der Handhabung (K & R, S. 127, C prog lang.) Als eine Einheit

Das Schreiben einer Struktur wird in A oben erläutert.

D> Für mich sind Strukturen benutzerdefinierte Typen oder Container oder Sammlungen oder Namespaces oder komplexe Typen, während ein typdef nur ein Mittel ist, um mehr Spitznamen zu erstellen.

Es stellt sich heraus, dass in C99 typedef erforderlich ist. Es ist veraltet, aber viele Tools (ala HackRank) verwenden c99 als reine C-Implementierung. Und dort ist typedef erforderlich.

Ich sage nicht, dass sie sich ändern sollten (vielleicht zwei C-Optionen), wenn sich die Anforderung ändert. Diejenigen von uns, die für Interviews auf der Website studieren, wären SOL.

In der Programmiersprache 'C' wird das Schlüsselwort 'typedef' verwendet, um einen neuen Namen für ein Objekt (Struktur, Array, Funktion .. Aufzählungstyp) zu deklarieren. Zum Beispiel werde ich ein 'struct-s' verwenden. In 'C' deklarieren wir oft eine 'Struktur' außerhalb der 'Haupt'-Funktion. Zum Beispiel:

struct complex{ int real_part, img_part }COMPLEX;

main(){

 struct KOMPLEKS number; // number type is now a struct type
 number.real_part = 3;
 number.img_part = -1;
 printf("Number: %d.%d i \n",number.real_part, number.img_part);

}

Jedes Mal, wenn ich mich für die Verwendung eines Strukturtyps entscheide, benötige ich dieses Schlüsselwort 'struct' Something '' name '.' Typedef 'benennt diesen Typ einfach um und ich kann diesen neuen Namen jedes Mal in meinem Programm verwenden, wenn ich möchte. Unser Code lautet also:

typedef struct complex{int real_part, img_part; }COMPLEX;
//now COMPLEX is the new name for this structure and if I want to use it without
// a keyword like in the first example 'struct complex number'.

main(){

COMPLEX number; // number is now the same type as in the first example
number.real_part = 1;
number.img)part = 5;
printf("%d %d \n", number.real_part, number.img_part);

}

Wenn Sie ein lokales Objekt (Struktur, Array, wertvoll) haben, das in Ihrem gesamten Programm verwendet wird, können Sie ihm einfach mit einem 'typedef' einen Namen geben.

In der C-Sprache sind struct / union / enum Makrobefehle, die vom C-Sprach-Präprozessor verarbeitet werden (verwechseln Sie nicht den Präprozessor, der "#include" und andere behandelt).

damit :

struct a
{
   int i;
};

struct b
{
   struct a;
   int i;
   int j;
};

Struktur b wird wie folgt ausgegeben:

struct b
{
    struct a
    {
        int i;
    };
    int i;
    int j;
}

und so entwickelt es sich zur Kompilierungszeit auf dem Stapel wie folgt: b: int ai int i int j

das ist auch der Grund, warum es schwierig ist, selbstreferierende Strukturen zu haben, C-Präprozessor-Runde in einer Deklarationsschleife, die nicht beendet werden kann.

typedef sind Typspezifizierer, das heißt, nur der C-Compiler verarbeitet sie und kann sie so ausführen, wie er es für die Optimierung der Assembler-Code-Implementierung wünscht. Es verbraucht auch kein Mitglied vom Typ par dumm wie ein Vorprozessor mit Strukturen, sondern verwendet einen komplexeren Referenzkonstruktionsalgorithmus, also Konstruktion wie:

typedef struct a A; //anticipated declaration for member declaration

typedef struct a //Implemented declaration
{
    A* b; // member declaration
}A;

ist erlaubt und voll funktionsfähig. Diese Implementierung bietet auch Zugriff auf die Konvertierung des Compilatortyps und beseitigt einige Fehlereffekte, wenn der Ausführungsthread das Anwendungsfeld der Initialisierungsfunktionen verlässt.

Dies bedeutet, dass in C typedefs eher als C ++ - Klasse als als einsame Strukturen sind.