常用：基本数据类型、指针类型、构造类型

数据类型.png

一、 基本数据类型

1. int

• 类型说明符，修饰int
  1> long int == long: 8个字节（％Id）
  2> short int == short: 2个字节 （％d、%i）
  3> unsigned int == unsigned: 4个字节（％zd、％zi）
  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. 指针变量的定义：
   int *p;

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

三、 构造类型

• 由基本数据类型组合构成

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

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

3. 枚举 enum

• 使用场合：当某个变量只允许有固定的几个取值时

四、 typedef

• 作用：给 已经存在的类型 起一个 新的名称

• 使用场合
  1> 基本数据类型
  2> 结构体
  3> 枚举
  4> 指向函数的 指针
  5> 指向结构体的 指针

• typedef- 基本数据类型

- 给 int 类型 起个别名
typedef int MyInt；

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

int main()
{
  - 定义 整型变量
  int a = 10;
  MyInt b = 20;
  printf("a = %d b = %d \n", a, b); - 输出 10 20

  - 定义 指针变量
  String name = "VampireJune";
  printf("%s \n", name); - 输出 VampireJune
}

• typedef - 结构体

- 先定义 结构体类型 VampireJune
struct VampireJune {
  int age;
};
- 再给 结构体类型 VampireJune 起一个别名 VamJ
typedef struct VampireJune VamJ;

- 利用 typedef 给 这个结构体类型，起了一个 新的类型名称 VV
typedef struct VampireJune{
  int num;
}VV;
- 这种写法，还可以用原来的写法 定义结构体变量，比较灵活

- 省略 结构体类型名称
typedef struct{
  int num;
}VampireJune;
- 这种写法不能再用原来的写法 定义结构体变量

int main()
{
  - 定义 结构体变量
  struct VampireJune vam = {21};
  VamJ v = {20};
  VV v = {20};

  - 使用 省略 结构体类型名称 定义 结构体变量 
  VampireJune va = {10};
}

• typedef - 枚举

- 先定义 枚举类型
enum Sex {Man, Woman};
- 再利用 typedef 定义 枚举类型
typedef enum Sex JuneS;

- 结合成一句 ，利用 typedef 定义 枚举类型 并起别名 JuneSS
typedef enum Sex {
  Man, 
  Woman
}JuneSS;

- 省略 枚举类型名称
typedef enum {
  Man, 
  Woman
}JuneSex;

int main()
{
  - 定义 枚举类型变量
  enum Sex s = Man;
  JuneSS js = Woman;

  - 使用 省略枚举类型名称 定义 枚举类型变量
  JuneSex juneS = Woman;
}

• typedef - 指向函数的指针

- 定义一个 返回 和 的函数
int sum(int a, int b)
{
  return a + b;
}

- 定义一个 返回 差 的函数
int minus(int a, int b)
{
  return a - b;
}

- 利用 typedef 给 指向函数的指针 起一个新的类型名称
- VampireJune 就是类型名称
typedef int(*VampireJune)(int, int);

int main()
{
  - 定义 指向 sum 函数的指针
  int(*vs)(int, int) = sum;
  vs(10, 11);

  - 定义 指向 minus 函数的指针
  int(*vm)(int, int) = minus;
  vm(10, 11);

  - 使用 VampireJune 名称 定义 指向函数的 指针变量
  VampireJune va = sum;
  VampireJune vam = minus;
}

• typedef 指向结构体 的 指针

- 定义 结构体类型
struct VampireJune{
  int num;
};

- 利用 typedef 给 指向 结构体的 指针 起别名 Vv
typedef struct VampireJune *Vv;

- 结合成一句 Vvam
typedef struct VampireJune{
  int num;
}*Vvam;

int main()
{
  - 定义 结构体变量
  struct VampireJune vam = {21};
  - 定义 指向 结构体的 指针 
  struct VampireJune *v = &vam;

  - 使用 指向 结构体的 指针 的别名 定义 指向 结构体的 指针
  Vv vpv = &vam;
  Vvam vpvv = &vam;
}

五、宏定义 预处理指令：所有的预处理指令，都是以 # 开头

• 在代码翻译成 '0' '1' 之前 执行的指令

• 预处理指令的位置可以随便写，但是有作用域

• 定义格式，没有分号，一定要有空格

  • #define 宏名 值
  • 一般 宏名 要 大写 或者，以 k开头
  • 使用 #undef 宏名，取消宏定义
  • 使用时，会把宏名 替换成 右边的 值
  • 宏定义，纯粹是 文本替换，没有任何运算

• 带参数的 宏定义， 效率比函数 高

• 无参数 宏定义

#define COUNT 3
#define kCount 3

int main()
{
  - 这种情况 不会 把 COUNT 替换成 3
  char *name = "COUNT";

  int ages[COUNT] = {12, 52, 36};

  #define NUM 2

  for (int i = 0; i < COUNT; i++){
  print(" %d \n",ages[i]);

  - 从这个行开始，NUM 这个宏就失效
  #undef NUM
};

  return 0;
}

• 带参数 宏定义
• 结果处，一定有个 ()
• 而且，每个参数 都要有个 ()

- 定义一个 返回 和 的函数
int sum (int a, int b)
{
  return a + b;
}

#define sum(v1, v2) ((v1)+(v2))

#define pingfang(a) ((a)*(a))

int main()
{
  int a = 10;
  int b = 20;

  - sum(v1, v2) ((v1)+(v2))
  - 会转成
  - sum(a, b) ((a)+(b))
  int c = sum(a, b);

  print(" %d \n",c); - 30

  return 0;
}

六、typedef 与 宏定义 使用上的区别

#define String2 char *

typedef char * String;

int main()
{
  int a,b;
  int a;
  int b;

  - s1、s2是 char * 指针
  String si, s2;
  si = "jack";
  s2 = "rose";

  - s3 才是 char * 指针，s4 只是 char
  String2 s3, s4;
  /*
  char *s3, s4;
  char *s3;
  char s4;
  */
  return 0;
}