目录

1.常见关键字

1.auto,break

2.switch,case,default,break

3.char，int等类型关键字

4.const

5.continue

6.extern

7.typedef

8.struct结构体

 9.sizeof

10.static

​编辑

2.define（标识符常量 or 宏定义）

1.标识符常量

2.宏定义

3.指针

1.指针具体内容：

2.指针与数组的关联

3.指针+-整数

4.指针和指针类型

5.指针解引用

6.野指针

7.二级指针

4.结构体

1.结构体的声明

2.结构体的使用

你好，本期芝士正是标题所展示的内容，如何考验一个人是否比普通的聪明人更聪明，方法之一即注意力比其他人更集中，那么，和我一起投入到知识的海洋里吧,让我们扬帆起航~

1.常见关键字

 看起来挺多，不先学走而学跑，从来都不是问题，先问问自己是不是天才。咱需要了解其中一些就ok了。

1.auto,break

1.常用在循环语句中，用来终止break所在作用域的循环体；

2.也用在switch语句中，用来结束case语句所要执行结果的后面。

#include <stdio.h>
int main()
{
	auto int a = 0;/*默认auto是不显示的，自动化类型为int，一般不写auto*/
	scanf("%d", &a);
	switch (a)
	{
	case 1:
               //case 1 后不写break继续下面的代码执行，遇到break停止
	case 2:
		printf("a=2'n"); break;   //输入1打印a=2

	default:
		printf("a=3\n"); break; //输入非1非2则打印a=3
	}
	return 0;
}

2.switch,case,default,break

switch中case和default的位置可以任意，为了规范建议使用正常格式

咱们看一下下面的小题，并告诉我 a 的结果:

int main()
{
	int a = 10;
	switch (a)
	{
	case 5:a = 1;
	case 10:a = 2;
	case 15:a = 3;
	}
	return 0;
}

这一题考察的是break的运用，最终的结果是case 15中a赋值后的结果，正确用法是:

int main()
{
	int a = 10;
	switch (a)
	{
	case 5:a = 1; break;
	case 10:a = 2; break;
	case 15:a = 3; break;
	}
	return 0;
}

注意：1.switch()括号内必须为变量名，变量类型可以为int，char，long，但不能为浮点型：float、double类型。

2.case+常量或常量表达式。

3.break来终止语句的执行。

3.char，int等类型关键字

所有的关键字都不能被当做变量名来使用。

4.const

将变量附上常属性，变为常变量，常量不能被赋值(赋值与初始化不同,初始化是定义时所给的值，赋值是使用时所给的值)

5.continue

用在循环语句中，跳过continue下面语句的执行，执行下一次循环。

那么好，给你一道题，告诉我你的答案。

#include <stdio.h>
int main()
{
	int a = 0;

	for (a = 0; a < 10; a++)
	{

		if (5 == a)
		{
			continue;
		}
		printf("%d ", a);
	}
	return 0;
}

执行结果是：打印0~9的数字，不包括5。

6.extern

声明外部符号。一个文件中有头文件(.h为后缀)和源文件(.c为后缀)，用法：

extern 类型 变量名

1.两个源文件的创建

2.定义a变量到test2.c

 3.声明外部符号int类型变量a到test.c

 注意：头文件一般用来变量、函数、常变量等的定义,源文件则用来写变量、函数等的实现，所以源文件使用来写源代码的。

7.typedef

名为类型重命名，用法：

此时的us_t与unsigned int一样，只是名字改了

其中的unsigned名为无符号，即只有正号 a 初始化的值只能为正数。

8.struct结构体

用法：

#include <stdio.h>
struct Stu
{
    char name[20];//名字
    int age;      //年龄
    char sex[5];  //性别
    char id[15]; //学号
};
int main()
{
    //定义并初始化结构体变量
    struct Stu a = { "张三",20,"男","123456" };

    //.操作符：结构体类型的变量名.结构体中定义的变量名
    printf("name = %s age = %d sex = %s id = %s\n", a.name, a.age, a.sex, a.id);

    //->操作符,用在指针结构体类型的变量中
    struct Stu* ps = &a;

    printf("name = %s age = %d sex = %s id = %s\n", ps->name, ps->age, ps->sex, ps->id);
    return 0;
}

 9.sizeof

求变量、数组等的内存大小,即在内存中所占字节.

打印方式为%zu  --z 为 sizeof里的z   --u为unsigned里的u (回顾上面的无符号类型)

10.static

名为静态的,用于修饰局部变量、全局变量和函数

将局部变量前加上static后变量会放在静态区，生命周期变长，生命周期变为整个程序的生命周期。

那么请你告诉我下面代码执行后的结果是什么？

结果是打印1到10

将全局变量或者函数前加上static时会从外部链接属性变为内部链接属性，test.c不能extern声明add.c中被静态化的全局变量和函数。

 执行代码后会报错

扩展：内存中有三种分区

栈区：局部变量。。。(省略号代替是因为有些芝士现在不着急学，嘿嘿)

堆区：malloc/free。。。

静态区:静态变量，全局变量

2.define（标识符常量 or 宏定义）

1.标识符常量

用法:#define MAX 100  注意:define不是关键字，而是预处理指令

2.宏定义

格式:#define 宏名 （宏的参数）宏体  注意：这里的参数无类型

3.指针

1.指针具体内容：

即为地址，操作符为*，打印方式为%p

指针是内存中一个最小单元的编号，也就是地址

对于32位的机器，假设有32根地址线，那么假设每根地址线在寻址的时候产生高电平（高电压）和低电 平（低电压）就是（1或者0）；

那么32根地址线产生的地址就会是：

00000000000000000000000000000000
00000000000000000000000000000001
....
11111111111111111111111111111111

这里就有2的32次方个地址。 每个地址标识一个字节，那我们就可以给 （2^32Byte == 2^32/1024KB == 2^32/1024/1024MB==2^32/1024/1024/1024GB == 4GB） 4G的空闲进行编址。

32个比特位即4个字节，64个比特位即8个字节，所以指针的大小为4个字节或者8个字节

位数由编译器决定，例如VS2019中：

X86即32位，X64即64位

存放地址的变量就成为指针变量，运用&操作符来取出一个变量或者函数的地址，实际展示:

2.指针与数组的关联

void test(int* arr,	int sz)
{
	int i = 0;
	for (i = 0; i < sz; i++)
	{
		printf("%d ", *arr + i);   //*解引用操作符,arr+i相等于arr[i];
	}
}
int main()
{
	int arr[10] = { 1,2,3,4,5,6,7,8,9,10 };
	int sz = sizeof(arr) / sizeof(arr[0]);
	test(arr, sz);   //arr传的是首元素地址
	return 0;
}

打印结果为1到10; 

3.指针+-整数

指针+1得到的是指针+指针类型的字节

例如:

int main()
{
    int arr[3] = {1,2,3};
    printf("%d\n",*(arr+1));  //打印结果为2,因为arr为首元素地址+1跳过4个字节,*解引用打印arr下 
                                                                                标为1的内容
    return 0;
}

指针-指针得到的是元素之间的个数

4.指针和指针类型

当有这样的代码： 要将&num（num的地址）保存到p中，我们知道p就是一个指针变量，那它的类型是怎样的呢？ 我们给指针变量相应的类型。 这里可以看到，指针的定义方式是： type + * 。 其实： char* 类型的指针是为了存放 char 类型变量的地址。 short* 类型的指针是为了存放 short 类型变量的地址。 int* 类型的指针是为了存放 int 类型变量的地址。

5.指针解引用

指针解引用访问字节大小是由指针类型决定的

比如int*类型的变量a存放在char*变量b中，解引用b = 0时，只访问1个字节，所以a地址的后8位会变为0，其他位不变。

6.野指针

指针未初始化，指针越界访问(出现于数组)。

避免方式:指针未初始化时可初始化为NULL,NULL值为0,防止数组越界。

7.二级指针

存放一级指针的指针就是二级指针

例如：int*a = NULL；就是一个一级指针

           int**b = a; b就是一个二级指针，通过b可以访问到a，int**的第一个*是指针与int相接，是因为a是一个指针类型的变量，第二个*是指针相当于int*a中的*。

4.结构体

1.结构体的声明

struct Stu
{
 char name[20];//名字
 int age;//年龄
 char sex[5];//性别
 char id[20];//学号
}Stu；//分号不能丢

结构体内为结构体成员变量，结构体外为结构体类型的变量

2.结构体的使用

使用介绍：

struct Stu
{
	char name[20];//名字
	int age;//年龄
	char sex[5];//性别
	char id[20];//学号
};
int main()
{
	struct Stu a = { "zhangsan",18,"男","21041234" };
	struct Stu b = { "李四",19,"男","21041235" };
	printf("%s %d %s %s\n", a.name, a.age, a.sex, a.id);//.操作符
	struct Stu* c = &b;
	printf("%s %d %s %s\n", c->name, c->age, c->sex, c->id);//关于指针的->操作符
	return 0;
}

打印效果:

感谢你的阅读，如果对你有用，请把它分享给在IT行业死磕技术的程序员吧，就好比我有一个知识，你有一个知识，我们互相分享，这样我们每个人都会有更多的知识。