常用：基本数据类型、指针类型、构造类型
数据类型.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;
}
