20-typedef

一、typedef作用简介

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

 1 #include <stdio.h>
 2 
 3 typedef int Integer;
 4 typedef unsigned int UInterger;
 5 
 6 typedef float Float;
 7 
 8 int main(int argc, const char * argv[]) {
 9     Integer i = -10;
10     UInterger ui = 11;
11     
12     Float f = 12.39f;
13     
14     printf("%d  %d  %.2f", i, ui, f);
15     
16     return 0;
17 }

在第3、第4、第6行分别给int、unsigned int、float起了个别名，然后在main函数中使用别名定义变量，用来跟原来的基本类型是完全一样的。输出结果： image

当然，给类型起别名后，原来的int、float还是可以正常使用的：

int i = 10;

float f = 10.0f;

• 也可以在别名的基础上再起一个别名

typedef int Integer;

typedef Integer MyInteger;

二、typedef与指针

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

 1 #include <stdio.h>
 2 
 3 typedef char *String;
 4 
 5 int main(int argc, const char * argv[]) {
 6     // 相当于char *str = "This is a string!";
 7     String str = "This is a string!";
 8     
 9     printf("%s", str);
10     
11     return 0;
12 }

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

三、typedef与结构体

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

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

 1 // 定义一个结构体
 2 struct MyPoint {
 3     float x;
 4     float y;
 5 };
 6 
 7 int main(int argc, const char * argv[]) {
 8     // 定义结构体变量
 9     struct MyPoint p;
10     p.x = 10.0f;
11     p.y = 20.0f;
12     
13     return 0;
14 }

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

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

 1 // 定义一个结构体
 2 struct MyPoint {
 3     float x;
 4     float y;
 5 };
 6 
 7 // 起别名
 8 typedef struct MyPoint Point;
 9 
10 int main(int argc, const char * argv[]) {
11     // 定义结构体变量
12     Point p;
13     p.x = 10.0f;
14     p.y = 20.0f;
15     
16     return 0;
17 }

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

其实第1~第8行的代码可以简写为：

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

甚至可以省略结构体名称：

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

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

typedef可以给指针、结构体起别名，当然也可以给指向结构体的指针起别名

 1 #include <stdio.h>
 2 
 3 // 定义一个结构体并起别名
 4 typedef struct {
 5     float x;
 6     float y;
 7 } Point;
 8 
 9 // 起别名
10 typedef Point *PP;
11 
12 int main(int argc, const char * argv[]) {
13     // 定义结构体变量
14     Point point = {10, 20};
15     
16     // 定义指针变量
17     PP p = &point;
18     
19     // 利用指针变量访问结构体成员
20     printf("x=%f，y=%f", p->x, p->y);
21     return 0;
22 }

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

输出结果： image

五、typedef与枚举类型

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

 1 // 定义枚举类型
 2 enum Season {spring, summer, autumn, winter};
 3 // 给枚举类型起别名
 4 typedef enum Season Season;
 5 
 6 int main(int argc, const char * argv[]) {
 7     // 定义枚举变量
 8     Season s = spring;
 9     
10     return 0;
11 }

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

第1行~第4行代码可以简化为：

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

甚至可以省略枚举名称，简化为：

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

六、typedef与指向函数的指针

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

 1 #include <stdio.h>
 2 
 3 // 定义一个sum函数，计算a跟b的和
 4 int sum(int a, int b) {
 5     int c = a + b;
 6     printf("%d + %d = %d", a, b, c);
 7     return c;
 8 }
 9 
10 int main(int argc, const char * argv[]) {
11     // 定义一个指向sum函数的指针变量p
12     int (*p)(int, int) = sum;
13     
14     // 利用指针变量p调用sum函数
15     (*p)(4, 5);
16     
17     return 0;
18 }

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

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

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

 1 #include <stdio.h>
 2 
 3 // 定义一个sum函数，计算a跟b的和
 4 int sum(int a, int b) {
 5     int c = a + b;
 6     printf("%d + %d = %d", a, b, c);
 7     return c;
 8 }
 9 
10 typedef int (*MySum)(int, int);
11 
12 int main(int argc, const char * argv[]) {
13     // 定义一个指向sum函数的指针变量p
14     MySum p = sum;
15     
16     // 利用指针变量p调用sum函数
17     (*p)(4, 5);
18     
19     return 0;
20 }

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

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

七、typedef与#define

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

• 第1段

1 typedef char *String;
2 
3 int main(int argc, const char * argv[]) {
4     String str = "This is a string!";
5     return 0;
6 }

• 第2段

1 #define String char *
2 
3 int main(int argc, const char * argv[]) {
4     String str = "This is a string!";
5     return 0;
6 }

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

但它们的实现方式是不一样的：

第1段代码是用typedef给char *定义别名为String
第2段代码是用char *代替代码中的宏名String
只看上面两段代码，似乎看不太出typedef和#define的区别。

2.再来看一段代码

 1 typedef char *String1;
 2 
 3 #define String2 char *
 4 
 5 int main(int argc, const char * argv[]) {
 6     String1 str1, str2;
 7     
 8     String2 str3, str4;
 9     return 0;
10 }

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

重点来了，注意：在这种情况下，只有str1、str2、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是基本数据类型，str1、str2、str3都是指针类型。

所以，以后给类型起别名，最好使用typedef，而不是使用#define

八、数据类型总结

一、基本数据类型
1.int
1> long int、long：8个字节  %ld
2> short int、short：2个字节 %d %i
3> unsigned int、unsigned：4个字节 %zd 
4> signed int、signed、int：4个字节 %d %i

2.float\double
1> float ：4个字节 %f
2> double：8个字节 %f

3.char
1> 1个字节 %c %d
2> char类型保存在内存中的是它的ASCII值
 'A' --> 65

二、构造类型
1.数组
1> 只能由同一种类型的数据组成
2> 定义：数据类型 数组名[元素个数];

2.结构体
1> 可以由不同类型的数据组成
2> 先定义类型，再利用类型定义变量

三、指针类型
1.变量的定义
int *p;

2.间接操作变量的值
int a = 10;
p = &a;
*p = 20;

四、枚举类型
使用场合：当一个变量只允许有几个固定取值时

---

---

---

九、程序实现

01-typedef

typedef int MyInt;
typedef MyInt MyInt2;

// 给指针类型char *起一个新的类型名称String
typedef char * String;

/*
 struct Student
 {
 int age;
 };
 typedef struct Student MyStu;
 */

/*
 typedef  struct Student
 {
 int age;
 } MyStu;
 */

typedef struct
{
    int age;
} MyStu;

/*
 enum Sex {Man, Woman};
 typedef enum Sex MySex;
 */

typedef enum {
    Man,
    Woman
} MySex;

typedef int (*MyPoint)(int, int);

int typedef_practice_minus(int a, int b) {
    return a - b;
}

int typedef_practice_sum(int a, int b) {
    return a + b;
}
/*
 struct Person
 {
 int age;
 };
 
 typedef struct Person * PersonPoint;
 */

typedef struct Person
{
    int age;
} * PersonPoint;
void typedef_practice(void) {
    
    /*
     1.作用：给已经存在的类型起一个新的名称
     
     2.使用场合：
     1> 基本数据类型
     2> 指针
     3> 结构体
     4> 枚举
     5> 指向函数的指针
     */
    
    // 定义结构体变量
    struct Person p = {20};
    
    PersonPoint p2 = &p;
    printf("p2.age = %d\n", p2->age);
    
    //struct Person *p2 = &p;
    
    //MyPoint p = sum;
    //MyPoint p2 = minus;
    //int (*p)(int, int) = sum;
    
    //int (*p2)(int, int) = minus;
    
    //p(10, 11);
    
    
    //MySex s = Man;
    //enum Sex s = Man;
    //enum Sex s2 = Woman;
    
    // struct Student stu3;
    //MyStu stu = {20};
    //MyStu stu2= {21};
}

void typedef_practice_test2() {
    String name = "jack";
    printf("%s\n", name);
}

void typedef_practice_test() {
    int a;
    MyInt i = 10;
    MyInt2 c = 20;
    
    MyInt b1, b2;
    printf("c = %d\n", c);
}

02-typedef使用注意

// #define Integer int
// typedef int Integer;
// typedef unsigned long int MyInt;
#define String2 char *
typedef char * String;
void typedef_uses_notice(void) {
    
    /*
     int a,b;
     int a;
     int b;
     */
    
    //s1、s2是char *指针
    String s1, s2;
    /*
     String s1;
     String s2;
     */
    s1 = "jack";
    s2 = "rose";
    
    // s3才是char *指针，s4只是char
    String2 s3, s4;
    /*
     char *s3, s4;
     char *s3;
     char s4;
     */
    //String2 s3 = "jake";
    
    /*
     String s1;
     String s2;
     */
    
    //Integer i = 10;
}

03-用递归的方式编写一个函数实现n的阶乘

// 提示用户输入一个正整数n，求出并输出其阶乘值n! = 1*2*3*4*...n
int factorial_recursively(int n);
void write_function_implements_factorial_recursively(void) {
    
    // 1.定义变量存储用户输入的整数
    int n = 0;
    
    // 2.判断n是否为正整数
    while (n <= 0) {
        
        // 2.1 提示输入
        printf("输入一个正整数：\n");
        // 2.2 让用户输入
        scanf("%d", &n);
    }
    
    // 3.计算阶乘
    int result = factorial_recursively(n);
    printf("%d! = %d\n", n, result);
}
int factorial_recursively(int n) {
    
    // 如果n为1，那么阶乘值就是1
    if (n == 1) return 1;
    
    // factorial_recursively(n) = n! = 1*2*3*...*(n-1)*n
    // factorial_recursively(n-1) = (n-1)! = 1*2*3*...*(n-1)
    // factorial_recursively(n) = factorial_recursively(n-1) * n
    return factorial_recursively(n-1) * n;
}

04-阶乘之和

int factorial_sum_pie_add(int n);
void factorial_sum(void) {
    
    /*
     提示用户输入一个正整数n，求出并输出下列结果：1! + 2! + 3! + 4! + ... + n!
     要求：用至少两种方式实现(函数名自拟，函数个数不限)
     1> 非递归
     2> 递归
     */
    
    // 1.定义变量存储用户输入的整数
    int n = 0;
    // 2.判断n是否为正整数
    while (n <= 0) {
        
        // 2.1 提示输入
        printf("输入一个正整数：\n");
        // 2.2 让用户输入
        scanf("%d", &n);
    }
    
    // 3.计算结果
    int result = factorial_sum_pie_add(n);
    printf("结果是:%d\n", result);
}

// ------------------非递归的方式----------------
int factorial_sum_pie_add(int n) {

    // 1.定义变量保存总和
    int sum = 0;

    // 2.需要累加n次，每次累加的都是一个阶乘值
    for (int i = 1; i<=n; i++) {

        // 3.计算阶乘i!
        // 3.1 定义变量保存阶乘的结果
        int multi = 1;
        for (int j = 1; j <= i; j++) {
            multi *= j;
        }

        // 4.累加每次的阶乘结果
        sum += multi;
    }

    // 5.返回和
    return sum;
}

/*
// ------------------递归的方式----------------
// 为了代码方便和性能，额外定义一个函数求阶乘
int factorial_sum_jieCheng(int n) {
    // 如果n为1，那么阶乘值就是1
    if (n == 1) return 1;
    
    // factorial_sum_jieCheng(n) = n! = 1*2*3*...*(n-1)*n
    // factorial_sum_jieCheng(n-1) = (n-1)! = 1*2*3*...*(n-1)
    // factorial_sum_jieCheng(n) = factorial_sum_jieCheng(n-1) * n
    return factorial_sum_jieCheng(n-1) * n;
}

int factorial_sum_pie_add(int n) {
    // 1.如果n是1，计算结果就是1
    if (n == 1) return 1;
    
    // factorial_sum_pie_add(n) = 1! + 2! + ... + (n-1)!+ n!
    // factorial_sum_pie_add(n-1) = 1! + 2! + ... + (n-1)!
    // factorial_sum_pie_add(n) = factorial_sum_pie_add(n-1) + n!
    return factorial_sum_pie_add(n - 1) + factorial_sum_jieCheng(n);
}
 */

05-提示输入5个学生的成绩(保证分数在0~100之间)，算出平均分、最高分、最低分，然后输出

// 学生的个数
#define kCount 5
void calculate_practice_score(void) {
    
    // 1.定义一个数组保存5个学生的分数
    // 初始化一下，默认都是-1分，只要默认值不是0~100都行
    int scores[kCount] = {-1, -1, -1, -1, -1};
    
    // 2.定义变量保存总分、最高分（默认是0分）、最低分（默认是100分）
    int sum = 0, max = 0, min = 100;
    
    // 3.提示输入
    for (int i = 0; i < kCount; i++) {
        
        // 3.1 如果学生的成绩不在0~100内，就重新提示输入
        while (scores[i]<0 || scores[i]>100) {
            
            // 3.1.1 提示输入
            printf("请输入第%d个学生的成绩（0~100）：\n", i + 1);
            
            // 3.1.2 接收输入
            scanf("%d", &scores[i]);
        }
        
        // 3.2 累加成绩
        sum += scores[i];
        
        // 3.3 判断最高分
        if (scores[i] > max) {
            max = scores[i];
        }
        
        // 3.4 判断最低分
        if (scores[i] < min) {
            min = scores[i];
        }
    }
    
    // 4.输出结果
    printf("平均分是%d，最高分是%d，最低分是%d\n", sum/kCount, max, min);
}

06-设计一个函数：将一维整型数组中的元素逆序存放。比如本来是1,3,4,2，逆序存放就变成了：2，4，3，1

void reverse_practice(int array[], int len);
void reverse_order_practice(void) {
    
    int ages[] = {32, 24, 21, 22, 76, 98, 12};
    
    int len = sizeof(ages)/sizeof(int);
    printf("len = %d\n", len);
    
    reverse_practice(ages, len);
    
    for (int i = 0; i < len; i++) {
        
        printf("%d ", ages[i]);
    }
    printf("\n");
}
// 第一个参数是数组，第二个参数是数组长度
// 不需要返回值
// 因为改变了形参数组就相当于修改了外面的实参数组
void reverse_practice(int array[], int len) {
    
    // 思路：以数组中间为轴，交换左右对称元素的值
    // 比如array[0] array[1] array[2] array[3] array[4] array[5]
    // 交换array[0]和array[5]的值
    // 交换array[1]和array[4]的值
    // 交换array[2]和array[3]的值
    
    // 左边元素的下标(默认是最左边)
    int left = 0;
    // 右边元素的下标(默认是最右边)
    int right = len - 1;
    
    // 如果左边元素的下标 < 右边元素的下标
    while (left < right) {
        
        // 利用中间变量交换两个元素的值
        int temp = array[left];
        array[left] = array[right];
        array[right] = temp;
        
        // 交换一次后，左边元素下标增加，右边元素下标减小
        left++;
        right--;
    }
}