Quelles sont les utilisations de typedef en langage C ?

L'utilisation de typedef est la suivante : 1. Définir de nouveaux noms de types pour les types de données de base ; 2. Définir des noms de types concis pour les types de données personnalisés (structures, unions et types d'énumération) ; ; 4. Définissez des noms concis pour les pointeurs.

Le langage C permet aux utilisateurs d'utiliser le mot-clé typedef pour définir leurs propres noms de types de données personnalisés afin de remplacer les noms de types de base par défaut du système, les noms de types de tableaux et les pointeurs. types. Noms et noms structurels définis par l'utilisateur, noms partagés, noms énumérés, etc.

Une fois que l'utilisateur a défini son propre nom de type de données dans le programme, il peut utiliser son propre nom de type de données dans le programme pour définir le type de variables, les types de tableaux, les types de variables de pointeur, les types de fonctions, etc.

Par exemple, le langage C ne fournissait pas de type booléen avant C99, mais on peut utiliser le mot-clé typedef pour définir un type booléen simple, comme le montre le code suivant :

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

Définition Après cela, vous pouvez l'utiliser comme des données de type de base, comme indiqué dans le code suivant :

BOOL bflag=TRUE;

4 utilisations de typedef

En réalité utilisation, il existe principalement quatre types d’applications de typedef.

1. Définir de nouveaux noms de types pour les types de données de base

En d'autres termes, tous les types de base par défaut du système peuvent utiliser le mot-clé typedef pour redéfinir le nom du type, le L'exemple de code est le suivant :

typedef unsigned int COUNT;

De plus, nous pouvons également utiliser cette méthode pour définir des types indépendants de la plate-forme. Par exemple, pour définir un type à virgule flottante appelé REAL, sur la plateforme cible 1, laissez-le représenter le type de précision la plus élevée, c'est-à-dire :

typedef long double REAL;

Sur la plateforme deux qui ne prend pas en charge le double long, remplacez-le par :

typedef double REAL;

peut même être remplacé par :

typedef float REAL;

sur des plateformes qui ne prennent même pas en charge le double. De cette façon, lors de la transplantation d'un programme sur plusieurs plateformes, il suffit de modifier la définition de typedef, et Aucune modification d'un autre code source n'est requise. En fait, cette technique est largement utilisée dans la bibliothèque standard. Par exemple, la définition de size_t dans le fichier crtdefs.h de VC++2010 est la suivante :

#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. C'est un type de données personnalisé (corps de structure, type d'union et d'énumération) Définir des noms de types concis

En prenant la structure comme exemple, nous définissons ci-dessous une structure nommée Point :

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

Lors de l'appel de ceci structure, nous devons appeler cette structure comme le code suivant :

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

Ici, la structure struct Point est un nouveau type de données, et lors de la définition des variables, nous devons utiliser la même méthode d'appel que ci-dessus Il y a un mot réservé struct, mais Point ne peut pas être utilisé directement pour définir des variables comme int et double. Maintenant, nous utilisons typedef pour définir cette structure, comme le montre le code suivant :

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

Dans le code ci-dessus, deux opérations sont en fait effectuées :

1), définissant un Le nouveau type de structure , le code est le suivant :

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

Parmi eux, le mot-clé struct et tagPoint constituent ensemble ce type de structure. Cette structure existe indépendamment du fait que le mot-clé typedef existe ou non.

2) Utilisez typedef pour donner à cette nouvelle structure un alias appelé Point, c'est-à-dire :

typedef struct tagPoint Point

Par conséquent, vous pouvez désormais utiliser directement Point pour définir des variables comme int et double, comme indiqué dans le code suivant :

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

Afin d'approfondir notre compréhension de typedef, regardons un exemple de structure, comme indiqué dans le code suivant :

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

En apparence, ce qui précède L'exemple de code est défini de la même manière qu’avant, il ne devrait donc y avoir aucun problème. Mais le compilateur a signalé une erreur, pourquoi ? Se pourrait-il que le langage C ne permette pas aux structures de contenir des pointeurs vers elles-mêmes ?

En fait, le problème n'est pas la définition de la structure elle-même. Tout le monde devrait savoir que le langage C permet à la structure de contenir des pointeurs vers elle-même. Nous pouvons en voir beaucoup dans l'implémentation de structures de données telles que les listes chaînées. .exemple de classe. Alors quel est le problème ? En fait, le problème fondamental réside toujours dans l’application de typedef.

Dans le code ci-dessus, la déclaration pNext est rencontrée lors de l'établissement de la nouvelle structure, et son type est pNode. Il est important de noter ici que pNode représente le nouvel alias de la structure. Le problème se pose donc lorsque le type de structure lui-même n'a pas été créé, le compilateur ne connaît pas du tout pNode, car le nouvel alias de ce type de structure n'existe pas encore, il signalera donc naturellement une erreur. Par conséquent, nous devons apporter quelques ajustements appropriés, tels que modifier la déclaration pNext dans la structure comme suit :

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

ou définir la structure et le typedef séparément, comme indiqué dans le code suivant :

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

Dans le code ci-dessus, nous utilisons également typedef pour donner un nouvel alias à un type tagNode qui n'a pas été entièrement déclaré. Cependant, bien que cette pratique soit entièrement prise en charge par le compilateur C, elle n'est pas recommandée. Il est recommandé d'utiliser la méthode de définition standard suivante :

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语言教程》

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!