c语言里面的宏定义和int区别,C语言-数据类型总结、typedef、宏定义

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

数据类型.png

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)

float \ double

1> float : 4个字节(％f)

2> double: 8个字节(％f)

char

1> 1个字节 (％c %d)

2> char 类型保存在内存中的是它的 ASCII值('A' --> 65)

根据地址找到对应存储空间，把里面的值拿出来，或者把新的值放进去，间接操作变量的值

指针变量的定义：

int *p;

间接操作变量的值

int a = 10;

p = &a;

*p = 20;

由基本数据类型组合构成

数组

1>只能由同一种类型的数据组成

2>定义：数据类型 数组名[元素个数]

结构体 struct

1>可以由不同类型的数据组成

2>先定义类型，再利用类型定义变量

枚举 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;

}