Welche Verwendung findet Typedef in der C-Sprache?

Die Verwendung von typedef ist: 1. Definieren Sie neue Typnamen für grundlegende Datentypen. 2. Definieren Sie prägnante Typnamen für benutzerdefinierte Datentypen (Strukturen, Unions und Aufzählungstypen). ; 4. Definieren Sie prägnante Namen für Zeiger.

C-Sprache ermöglicht es Benutzern, das Schlüsselwort typedef zu verwenden, um ihre eigenen benutzerdefinierten Datentypnamen zu definieren, um die standardmäßigen Basistypnamen, Array-Typnamen und Zeiger des Systems zu ersetzen Namen und benutzerdefinierte Strukturnamen, gemeinsame Namen, Aufzählungsnamen usw.

Sobald der Benutzer seinen eigenen Datentypnamen im Programm definiert, kann er seinen eigenen Datentypnamen im Programm verwenden, um den Typ von Variablen, Array-Typen, Zeigervariablentypen, Funktionstypen usw. zu definieren.

Zum Beispiel stellte die Sprache C vor C99 keinen booleschen Typ bereit, aber wir können das Schlüsselwort typedef verwenden, um einen einfachen booleschen Typ zu definieren, wie im folgenden Code gezeigt:

typedef int BOOL;
#define TRUE 1
#define FALSE 0

Definition Danach können Sie es wie grundlegende Typdaten verwenden, wie im folgenden Code gezeigt:

BOOL bflag=TRUE;

4 Verwendungen von typedef

In der Tat Bei der Verwendung gibt es hauptsächlich vier Arten von Typedef-Anwendungen.

1. Definieren Sie neue Typnamen für Basisdatentypen

Mit anderen Worten, alle Standard-Basistypen des Systems können das Schlüsselwort typedef verwenden, um den Typnamen neu zu definieren Der Beispielcode lautet wie folgt:

typedef unsigned int COUNT;

Darüber hinaus können wir diese Methode auch verwenden, um plattformunabhängige Typen zu definieren. Um beispielsweise einen Gleitkommatyp namens REAL auf der Zielplattform eins zu definieren, lassen Sie ihn den Typ mit der höchsten Genauigkeit darstellen, das heißt:

typedef long double REAL;

Ändern Sie ihn auf Plattform zwei, die Long Double nicht unterstützt, in:

typedef double REAL;

kann sogar geändert werden in:

typedef float REAL;

auf Plattformen, die Double nicht unterstützen. Auf diese Weise müssen wir beim Transplantieren eines Programms über Plattformen hinweg nur die Definition von typedef und ändern Es sind keine Änderungen am anderen Quellcode erforderlich. Tatsächlich wird diese Technik in der Standardbibliothek häufig verwendet. Die Definition von size_t in der Datei crtdefs.h von VC++2010 lautet beispielsweise wie folgt:

#ifndef _SIZE_T_DEFINED
#ifdef  _WIN64
typedef unsigned __int64    size_t;
#else
typedef _W64 unsigned int   size_t;
#endif
#define _SIZE_T_DEFINED
#endif

2. Es ist ein Benutzerdefinierter Datentyp (Strukturkörper, Vereinigungen und Aufzählungstypen) Definieren Sie prägnante Typnamen

Am Beispiel der Struktur definieren wir unten eine Struktur mit dem Namen Point:

struct Point
{
    double x;
    double y;
    double z;
};

Beim Aufruf Struktur, wir müssen diese Struktur wie den folgenden Code aufrufen:

struct Point oPoint1={100，100，0};
struct Point oPoint2;

Hier ist die Struktur struct Point ein neuer Datentyp, und beim Definieren von Variablen müssen wir dieselbe Aufrufmethode wie oben verwenden. Es gibt ein reserviertes Wort struct, aber Point kann nicht direkt zum Definieren von Variablen wie int und double verwendet werden. Jetzt verwenden wir typedef, um diese Struktur zu definieren, wie im folgenden Code gezeigt:

typedef struct tagPoint
{
    double x;
    double y;
    double z;
} Point;

Im obigen Code sind tatsächlich zwei Vorgänge abgeschlossen:

1) Definieren eines neuen Strukturtyps Der Code lautet wie folgt:

struct tagPoint
{
    double x;
    double y;
    double z;
} ;

Unter diesen bilden das Schlüsselwort struct und tagPoint zusammen diesen Strukturtyp. Diese Struktur existiert unabhängig davon, ob das Schlüsselwort typedef vorhanden ist oder nicht.

2) Verwenden Sie typedef, um dieser neuen Struktur einen Alias ​​namens Point zu geben, das heißt:

typedef struct tagPoint Point

Daher können Sie Point jetzt direkt verwenden, um Variablen wie int und double zu definieren, wie im gezeigt folgender Code:

Point oPoint1={100，100，0};
Point oPoint2;

Um unser Verständnis von typedef zu vertiefen, schauen wir uns ein Strukturbeispiel an, wie im folgenden Code gezeigt:

typedef struct tagNode
{
    char *pItem;
    pNode pNext;
} *pNode;

Oberflächlich betrachtet ist der obige Beispielcode auf die gleiche Weise wie zuvor definiert, daher sollte es kein Problem geben. Aber der Compiler hat einen Fehler gemeldet, warum? Könnte es sein, dass die C-Sprache nicht zulässt, dass eine Struktur einen Zeiger auf sich selbst enthält?

Tatsächlich liegt das Problem nicht in der Definition der Struktur selbst. Jeder sollte wissen, dass die C-Sprache zulässt, dass die Struktur Zeiger auf sich selbst enthält. Wir können viele davon in der Implementierung von Datenstrukturen wie verknüpften Listen sehen . Klassenbeispiel. Was ist also das Problem? Tatsächlich liegt das grundlegende Problem immer noch in der Anwendung von typedef.

Im obigen Code wird die pNext-Deklaration während der Einrichtung der neuen Struktur angetroffen und ihr Typ ist pNode. Hierbei ist zu beachten, dass pNode den neuen Alias ​​der Struktur darstellt. Wenn der Strukturtyp selbst nicht erstellt wurde, kennt der Compiler pNode überhaupt nicht, da der neue Alias ​​dieses Strukturtyps noch nicht vorhanden ist, sodass er natürlich einen Fehler meldet. Daher müssen wir einige entsprechende Anpassungen vornehmen, wie zum Beispiel die pNext-Deklaration in der Struktur wie folgt ändern:

typedef struct tagNode
{
    char *pItem;
    struct tagNode *pNext;
} *pNode;

oder die Struktur und die Typedef separat definieren, wie im folgenden Code gezeigt:

typedef struct tagNode *pNode;
struct tagNode
{
    char *pItem;
    pNode pNext;
};

Im obigen Code verwenden wir auch typedef, um einem Typ tagNode, der noch nicht vollständig deklariert wurde, einen neuen Alias ​​zu geben. Obwohl diese Vorgehensweise vom C-Compiler vollständig unterstützt wird, wird sie jedoch nicht empfohlen. Es wird empfohlen, die folgende Standarddefinitionsmethode zu verwenden:

struct tagNode
{
    char *pItem;
    struct tagNode *pNext;
};
typedef struct tagNode *pNode;

3、为数组定义简洁的类型名称

它的定义方法很简单，与为基本数据类型定义新的别名方法一样，示例代码如下所示：

typedef int INT_ARRAY_100[100];
INT_ARRAY_100 arr;

4、为指针定义简洁的名称

对于指针，我们同样可以使用下面的方式来定义一个新的别名：

typedef char* PCHAR;
PCHAR pa;

对于上面这种简单的变量声明，使用 typedef 来定义一个新的别名或许会感觉意义不大，但在比较复杂的变量声明中，typedef 的优势马上就体现出来了，如下面的示例代码所示：

int *(*a[5])(int,char*);

对于上面变量的声明，如果我们使用 typdef 来给它定义一个别名，这会非常有意义，如下面的代码所示：

// PFun是我们创建的一个类型别名
typedef int *(*PFun)(int,char*);
// 使用定义的新类型来声明对象，等价于int*(*a[5])(int,char*);
PFun a[5];

小心使用 typedef 带来的陷阱

接下来看一个简单的 typedef 使用示例，如下面的代码所示：

typedef char* PCHAR;
int strcmp(const PCHAR,const PCHAR);

在上面的代码中，“const PCHAR” 是否相当于 “const char*” 呢？

答案是否定的，原因很简单，typedef 是用来定义一种类型的新别名的，它不同于宏，不是简单的字符串替换。因此，“const PCHAR”中的 const 给予了整个指针本身常量性，也就是形成了常量指针“char*const（一个指向char的常量指针）”。即它实际上相当于“char*const”，而不是“const char*（指向常量 char 的指针）”。当然，要想让 const PCHAR 相当于 const char* 也很容易，如下面的代码所示：

typedef const char* PCHAR;
int strcmp(PCHAR， PCHAR);

其实，无论什么时候，只要为指针声明 typedef，那么就应该在最终的 typedef 名称中加一个 const，以使得该指针本身是常量。

还需要特别注意的是，虽然 typedef 并不真正影响对象的存储特性，但在语法上它还是一个存储类的关键字，就像 auto、extern、static 和 register 等关键字一样。因此，像下面这种声明方式是不可行的：

typedef static int INT_STATIC;

不可行的原因是不能声明多个存储类关键字，由于 typedef 已经占据了存储类关键字的位置，因此，在 typedef 声明中就不能够再使用 static 或任何其他存储类关键字了。当然，编译器也会报错，如在 VC++2010 中的报错信息为“无法指定多个存储类”。

相关推荐：《c语言教程》

Das obige ist der detaillierte Inhalt vonWelche Verwendung findet Typedef in der C-Sprache?. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!