C语言学习笔记(02)——关键字概念

sizeof

编译器给我们查看内存空间容量的一个工具

不存在函数实现，在任何情况下都可以使用

int a：
printf("the a is %d\n",sizeof(a));
printf("the a is %lu\n",sizeof(a));			//最好使用%lu打印，因为sizeof默认返回的是unsigned long类型的
>>>4

char：硬件处理的最小单位；8bit=1B，8bit是硬件层面上的，1B是软件层面上的

8bit ---> 256

char a=300; 出现溢出问题 300l 或 300L 代表使用long类型来描述数字

整型常量一般情况下都默认用十进制来描述

int a = 010;	//8
八进制的语法就是以0开头，所以010是八进制的，就是十进制当中的8；
int a = 0x10;	//16
同理十六进制的0x10,就是十进制当中的16；

数据类型定义时默认都是有符号数

unsigned：无符号，更多偏向数据的意义

signed： 有符号，更多偏向数字的意义

char a = -1;		0xff
a>>1 
右移8位之后不会变成0，因为是有符号数，最高位被符号位占着

unsigned char b= -1;		0xff
b>>1 
右移8位之后会变成0

浮点型常量

1.0 1.1 这样的写法，实际上占用的内存空间是double，即8B

1.0f 表示数据为float型常量

	float a,b,c,d;
	a = 7 / 2;
	b = 7.0 / 2;
	c = 7 / 2.0;
	d = 7.0 / 2.0;
	printf("p is %f\n",a);
	printf("p is %f\n",b);
	printf("p is %f\n",c);
	printf("p is %f\n",d);
输出：
p is 3.000000
p is 3.500000
p is 3.500000
p is 3.500000

void a； 实际上是没有任何意义的，更多的是一种占位标识，申请一种变量名

自定义数据类型

struct：结构体，内存地址首尾相接

//声明结构体
struct myabc{
    unsigned int a;
    unsigned int b;
    unsigned int c;
    unsigned int d;
};
int					i；
//定义结构体
struct myabc 	mybuf；
//struct myabc就相当于是int型变量类型

union：共用体，共用起始地址的一段内存

//声明共用体
union myabc{
    char a;
    int b;
};
int					i；
//定义共用体
union myabc 	mybuf；
//union myabc就相当于是int型变量类型

enum

被命名的整型常数的集合

enum 枚举名称{ 常量列表 }；

#define MON 0
#define TUE 1
#define WED 2

enum abc{ MON,TUE,WED }		//跟上面的宏定义写法没有什么区别
//默认情况下MON=0，TUE=1，WED=2；若定义MON=100，则TUE=101，WED=102
==================================================================

enum abc{MOD=100,TUE,WED};
int main()
{
    enum abc a1 = 800;			//这样定义a1=800也是可以的，本质上就是整型常量
    printf("the a1 is %lu: %d\n",sizeof(a1),a1);	//a1的内存大小就是4个字节
    printf ("the %d\n",WED);
    return 0;
}
>>>the a1 is 4: 800
>>>the 102

typedef

数据类型的别名

int a = 170;
int b = 3600;

len_t a = 170;
time_t b = 3600;


int a;				a是一个int类型的变量
typedef int a_t;		a_t是一个int类型的外号，此时并没有内存空间生成；a_t只是和int类型一模一样的代名词而已

a_t mysize;		此时mysize就是int类型的变量
    
    
一般情况下：
xxx_t : 有 _t 都是通过typedef给别名了一下  

逻辑结构关键字

switch(整型数字) 只能是整型数字，不能跟浮点数

switch(a){
	case 1.0;
        break;
	case 2.0;
        break;
}
××× 这样是不允许的 ×××

类型修饰符

对内存资源存放位置的限定

资源属性中位置的限定

auto char a;	//其实就是平时写的 char a;	默认情况下实现的
auto int a;		//其实就是平时写的 int a;
告诉我们这是一个自动变量：在普通内存中（可读可写空间中）分配的一段区域
    
{
    auto char a;
}   
在大括号里头，就可以认为此时a的地址就在栈空间里

register int a;
限制变量定义在寄存器上的修饰符
定义一些快速访问的变量
编译器会尽量安排cpu的寄存器存放这个a，如果寄存器不足，那a还是放在存储器里
&这个符号对register不起作用    

================================================
内存（存储器）			寄存器
	0x100			 R0,R2   
内存中想找到它非常简单，但CPU的寄存器一般都是些特殊值，像ARM就对应R0,R2,R5等这些    

static：静态

修饰三种数据：
1）、函数内部的变量
int fun()
{
    int a; ===> static int a;
}   

2）、函数外部的变量    
int a; ===> static int a;
int fun()
{
    
}  

3）、函数    
int fun(); ===> static int fun();    

extern：外部声明

const

常量的定义

只读的变量

const int a = 100;

a = 200;	//虽然说这样子不能显示地修改a的值，编译器会不通过；但还是有办法能够把200写进a里面
			//a还是在内存中可读可写的变量空间

volatile

告知编译器编译方法的关键字，不优化编译

修饰变量的值得修改，不仅仅可以通过软件，也可以通过其他方式（硬件外部的用户）