C语言基础-15-typedef

这讲介绍C语言中很经常使用的一个关键字---typedef。

1、typedef做用简介

* 咱们可使用typedef关键字为各类数据类型定义一个新名字(别名)。

#include <stdio.h>

typedef int Integer;
typedef unsigned int UInterger;

typedef float Float;

int main(int argc, const char * argv[]) {
    Integer i = -10;
    UInterger ui = 11;
    
    Float f = 12.39f;
    
    printf("%d  %d  %.2f", i, ui, f);
    
    return 0;
}

在第三、第四、第6行分别给int、unsigned int、float起了个别名，而后在main函数中使用别名定义变量，用来跟原来的基本类型是彻底同样的。输出结果：

固然，给类型起别名后，原来的int、float仍是能够正常使用的：

int i = 10;
float f = 10.0f;

 

* 也能够在别名的基础上再起一个别名

typedef int Integer;
typedef Integer MyInteger;

 

2、typedef与指针

除开能够给基本数据类型起别名，typedef也能够给指针起别名

#include <stdio.h>

typedef char *String;

int main(int argc, const char * argv[]) {
    // 至关于char *str = "This is a string!";
    String str = "This is a string!";
    
    printf("%s", str);
    
    return 0;
}

在第3给指针类型char *起别名为String，而后在第7行使用String定义了一个字符串，是否是有点Java的感受？

3、typedef与结构体

给结构体起别名可使代码更加简洁明

1.默认状况下结构体变量的使用

// 定义一个结构体
struct MyPoint{
  float x;
  float y;
};

int main(int argc, const char *arg[]){
  // 定义结构体的变量
  struct MyPoint p;
  p.x = 10.0f;
  p.y = 20.2f;
  
  return 0;
  }

默认状况下，咱们定义结构体变量须要带个struct关键字，看第9行

2.使用typedef给结构体起别名

// 定义一个结构体
struct MyPoint {
    float x;
    float y;
};

// 起别名
typedef struct MyPoint Point;

int main(int argc, const char * argv[]) {
    // 定义结构体变量
    Point p;
    p.x = 10.0f;
    p.y = 20.0f;
    
    return 0;
}

咱们在第8行给结构体MyPoint起了个别名叫作Point，而后在12行使用Point定义了一个结构体变量p，不用再带上struct关键字了

其实第1~第8行的代码能够简写为：

// 定义一个结构体，顺便起别名
typedef struct MyPoint {
float x;    float y;
} Point;

甚至能够省略结构体名称：

typedef struct { 
 float x;    float y;
} Point;

3、typedef与指向结构体的指针

typedef能够给指针、结构体起别名，固然也能够给指向结构体的指针起别名

#include <stdio.h>

// 定义一个结构体并起别名
typedef struct {
    float x;
    float y;
} Point;

// 起别名
typedef Point *PP;

int main(int argc, const char * argv[]) {
    // 定义结构体变量
    Point point = {10, 20};
    
    // 定义指针变量
    PP p = &point;
    
    // 利用指针变量访问结构体成员
    printf("x=%f，y=%f", p->x, p->y);
    return 0;
}

在第4行定义了一个结构体，顺便起了个别名叫Point，第10行为指向结构体的指针定义了别名PP。而后在main函数中使用这2个别名。

输出结果：

4、typedef与枚举类型

使用typedef给枚举类型起别名也可使代码简洁。

// 定义枚举类型
enum Season {spring, summer, autumn, winter};
// 给枚举类型起别名
typedef enum Season Season;

int main(int argc, const char * argv[]) {
    // 定义枚举变量
    Season s = spring;
    
    return 0;
}

在第2行定义了枚举类型，在第4行起了别名为Season，而后在第8行直接使用别名定义枚举变量，不用再带上enum关键字了。

第1行~第4行代码能够简化为：

// 定义枚举类型，而且起别名typedef enum Season {spring, summer, autumn, winter} Season

 甚至能够省略枚举名称，简化为：

typedef enum {spring, summer, autumn, winter} Season;

5、typedef与指向函数的指针

1.先来回顾下函数指针的知识

#include <stdio.h>

// 定义一个sum函数，计算a跟b的和
int sum(int a, int b) {
    int c = a + b;
    printf("%d + %d = %d", a, b, c);
    return c;
}

int main(int argc, const char * argv[]) {
    // 定义一个指向sum函数的指针变量p
    int (*p)(int, int) = sum;
    
    // 利用指针变量p调用sum函数
    (*p)(4, 5);
    
    return 0;
}

 在第4行定义了一个sum函数，第12行定义了一个指向sum函数的指针变量p，能够发现，这个指针变量p的定义比通常的指针变量看来复杂多了，不利于理解。

* 第15行调用了p指向的sum函数，输出结果：

 

2.为了简化代码和方便理解，咱们可使用typedef给指向函数的指针类型起别名

#include <stdio.h>

// 定义一个sum函数，计算a跟b的和
int sum(int a, int b) {
    int c = a + b;
    printf("%d + %d = %d", a, b, c);
    return c;
}

typedef int (*MySum)(int, int);

int main(int argc, const char * argv[]) {
    // 定义一个指向sum函数的指针变量p
    MySum p = sum;
    
    // 利用指针变量p调用sum函数
    (*p)(4, 5);
    
    return 0;
}

* 看第10行，意思是：给指向函数的指针类型，起了个别名叫MySum，被指向的函数接收2个int类型的参数，返回值为int类型。

* 在第14行直接用别名MySum定义一个指向sum函数的指针变量p，这样看起来简单舒服多了。第17行的函数调用是同样的。

 

6、typedef与#define

1.先来看看下面的两段代码有什么区别(注意每一段的第1行代码)

* 第1段

typedef char *String;

int main(int argc, const char * argv[]) {
    String str = "This is a string!";
    return 0;
}

#define String char *

int main(int argc, const char * argv[]) {
    String str = "This is a string!";
    return 0;
}

上面的两段代码只是第1行代码不同，运行的效果都是同样的：定义了一个字符串"This is a string!"。

但它们的实现方式是不同的：

• 第1段代码是用typedef给char *定义别名为String

• 第2段代码是用char *代替代码中的宏名String

只看上面两段代码，彷佛看不太出typedef和#define的区别。

2.再来看一段代码

typedef char *String1;

#define String2 char *

int main(int argc, const char * argv[]) {
    String1 str1, str2;
    
    String2 str3, str4;
    return 0;
}

第1行给char *起了个别名String1，第2行定义了宏String2。而后在第六、第8行定义了4个变量。

重点来了，注意：在这种状况下，只有str一、str二、str3才是指向char类型的指针变量，str4只是个char类型的变量。

 

下面简单分析一下缘由：

* 若是连续声明两个int类型的变量，咱们能够这样写：

int a, b;

上面的代码至关于：

int a;int b;

* 以此类推

1 typedef char *String1;2     3 String1 str1, str2;

通过typedef处理后，String1也算是一种数据类型，因此第3行代码至关于

1 String1 str1;2 String1 str2;

因为String1就是char *，因此上面的两行代码等于

char *str1;char *str2;

 

* 再看看宏定义的状况

1 #define String2 char *2 3 String2 str3, str4;

由于宏定义纯粹是字符串替换，用char *代替String2，因此第3行代码至关于

char * str3, str4;

其实也就至关于：

char * str3;char str4;

能够看出，只有str4是基本数据类型，str一、str二、str3都是指针类型。

因此，之后给类型起别名，最好使用typedef，而不是使用#define

注：本文转自M了个J的博客。