c 语言

变量定义

int a1 ; // 定义一个变量
//printf("%d\n",sizeof(a1)); //4
int *a2 ; // 定义一个指针，指向int 类型
//printf("%d\n",sizeof(a2)); //8
int **a3; // 定义一个指正，指向一个int 类型的指针
//printf("%d\n",sizeof(a3)); //8
int a4[10] ; // 定义一个数组，数组有10个元素，每个元素时int类型 
//printf("%d\n",sizeof(a4)); //10
int *a5[10]; //定义一个数组，该数组有10个元素，每个元素指向一个int类型的指针
printf("%d\n",sizeof(a5)); //80
int (*a6)[10] ;//定义一个指针，该指针指向数组
//printf("%d\n",sizeof(a6)); //80
int (*a7)(int); // 定义一个指针，指向一个返回值是int 的函数
printf("%d\n",sizeof(a7)); //8
int (*a8[10])(int); //定义一个数组，该数组的元素指向int,返回是int的函数指针 
printf("%d\n",sizeof(a8)); //80

int (*p)(int,int);
//定义了一个指针变量 p，该指针变量可以指向返回值类型为 int 型，且有两个整型参数的函数。
//p 的类型为 int(*)(int，int)。	
char *email;
printf("%d\n",sizeof(email)); // 8

char *e[8];
printf("%d\n",sizeof(e)); // 64	

union

union tel_num{
	int tel;  // 4
	char *email; //
}; 
// printf --> union
void func(union tel_num info){
	printf("%s\n",info.email);
}
// main |||||
union tel_num info;



info.email = "keyboard@163.com";
// printf  --> info.email
func(info);  // keyboard@163.com
// sizeof --> union
printf("%d\n",sizeof(info)); // 8

union --> sizeof

union u               //u的大小是其中最大的double类型成员a，所以sizeof(u) = sizeof(double) = 8;
{
 double a;
 int b;
};

union u1           // u1的大小是char[15] 类型的数组，但由于另一个成员int b ,所以要以4对齐，15以4对齐就是补1位到16；
{
 char a[15];
 int b;
};

union u2          // u2的大小是char[13]类型的数组，不需要补齐，所以长度为13；
{
 char a[13];
 char b;
};

4.static

1. static修饰局部变量时，会影响局部变量的生命周期，本质上改变了局部变量的存储位置，生命周期变长，为整个周期。静态局部变量存储于进程中的全局数据区
2. 全局变量具有外部链接属性。而static修饰全局变量时，这个全局变量的外部链接属性变为内部链接属性，是其他源文件（.c）文件就可以再使用这个全局变量了。则使用时我们会感觉到该全局变量作用域变小。
3. 函数同样具有外部属性。而static修饰函数时，这个函数的外部链接属性变为内部链接属性，是其他源文件（.c）文件就可以再使用这个函数了。则使用时我们会感觉到该函数作用域变小

#include <stdio.h>
#include <stdlib.h>

static int  add(int a,int b){
	return a+b;
}
int a_up(){
	static int a= 1;
	printf("%d ",a);
	a++;
	printf("%d ",a);
} 
// 1 2 2 3 3 4 4 5
int b_up(){
	int b =1;
	printf("%d ",b);
	b++;
	printf("%d ",b);
}
// 1 2 1 2 1 2 1 2

int main(){
	int i ;
	for(i=0;i<4;i++){
		a_up();	
	}	
	printf("\n");
	for(i=0;i<4;i++){
		b_up();
		
	}
	printf("\n");
	printf("%d\n",add(1,2));
	printf("1232");
	return 0 ;
}

5. unsigned int // int

隐式转换。当unsigned int类型与int类型运算时，如果没有指出转换的类型，它会进行“隐式转换”转换为unsigned int类型，也可以记住，不同类型进行运算时，没指出转换的类型时，它会往容量大的那总类型转换，因为这样可以更加容易避免溢出

#include <stdio.h>
#include <stdlib.h>

int main(){
	int i_i = -2;
	unsigned int u_i = -2;
	printf("%d\n",i_i+u_i); // -2+-2 = -4
	return 0 ;
}

int类型和unsigned int类型的差别。unsigned int类型比int类型的容量大是因为，unsigned int是无符号类型的，所以最高位不表示正负，而int类型的最高位是表示正负的，1表示负数，0表示正数。

6. register

for(int i=1;i<=1000000;i++)
{
		......	
}
// 变量 i 存储在内存中，cpu 每次要从内存中取出变量 i，这样 cpu 就要来回读取10000次，只是很低效的
for(register int i=1;i<=1000000;i++)
{
	......
}	
// cpu每次都会直接去寄存器上读取变量i，而不用再去内存读取，因此，代码的效率也会大大提高

7 . enum

enum DAY
{
      MON=1, TUE, WED, THU, FRI, SAT, SUN
};

第一个枚举成员的默认值为整型的 0，后续枚举成员的值在前一个成员上加 1。我们在这个实例中把第一个枚举成员的值定义为 1，第二个就为 2

enum season {spring, summer=3, autumn, winter};

没有指定值的枚举元素，其值为前一元素加 1。也就说 spring 的值为 0，summer 的值为 3，autumn 的值为 4，winter 的值为 5

8. switch

#include <stdio.h>
#include <stdlib.h>
int main()
{
 
    enum color { red=1, green, blue };
 
    enum  color favorite_color;
 
    /* 用户输入数字来选择颜色 */
    printf("请输入你喜欢的颜色: (1. red, 2. green, 3. blue): ");
    scanf("%u", &favorite_color);
 
    /* 输出结果 */
    switch (favorite_color)
    {
    case red:
        printf("你喜欢的颜色是红色");
        break;
    case green:
        printf("你喜欢的颜色是绿色");
        break;
    case blue:
        printf("你喜欢的颜色是蓝色");
        break;
    default:
        printf("你没有选择你喜欢的颜色");
    }
 
    return 0;
}

9. & * &&

& 位与，取指针地址
&& 逻辑运算符 A&&B --> A,B–>T -->A&B—>T

10. null nullptr

null – >空 空地址，宏
nullptr --> 空指针

11. 宏

	#define PI 3.14
	#define Print printf("hello world")
	#define Print(str1,str2) printf(#str1"%s",str2)
	#undef PI

12. strlen

    char *p = "hello";
    printf("strlen         :%d\n",strlen(p)); //5