int array[10] = {1,2,3,4,5,6,7,8,9,10};
//该数组是10个元素，下标的范围是0-9

#include<stdio.h>
int main()
{
	int i = 0;//使用i产生下标
	int arr[10] = { 1,2,3,4,5,6,7,8,9,10 };
	while (i < 10)
	{
		printf("%d ", arr[i]);//通过下标来访问数组
		i++;
	}
	putchar('\n');
	return 0;
}

!                逻辑反操作

-                负值

+               正值

&               取地址

sizeof       操作数的类型长度（以字节为单位）

~               对一个数的二进制按位取反

--               前置、后置--

++             前置、后置++

*                间接访问操作符(解引用操作符)

(类型)       强制类型转换

单目操作符：操作数只有一个，什么叫操作数呢？比如：2 + 3 --> 2和3就是操作数，由于‘+’有两个操作数，数以叫双目运算符。

注意：sizeof计算的是类型或者是由类型定义的变量的大小，单位是字节。 C语言中用0表示假，非0表示真 ，注意是非0表示真，即使是-1也表示真，Do you understand？

>

>=

<

<=

!=       用于测试“不相等”

==      用于测试“相等”

auto   break   case   char   const   continue   default   do   double else   enum  

extern    float     for     goto    if     int     long    register     return     short    signed

sizeof   static struct   switch   typedef union   unsigned   void   volatile   while

注意：关键字先暂时简单介绍两个，后面会详细介绍

比如：

typedef unsigned int uint_32;
//由于unsigned int比较复杂，所以用typedef将它重命名为uint_32,所以此时uint_32就是一个类型名，代表了unsigned int

3.2 关键字register

register---寄存器关键字 

 

register int a = 10; // a是寄存器变量

 register 是起到的是建议作用，“建议” 编译器将a放到寄存器中，不会真的放进去，它有自己的一套判断规则。

注意：不能对寄存器变量取地址，如上面的&a就是错误的

3.3 static关键字

static ---静态的

C语言中，static是用来修饰变量和函数的。

• 修饰局部变量---静态局部变量
• 修饰全局变量---静态全局变量
• 修饰函数---静态函数

1.static修饰局部变量

//代码1
#include<stdio.h>
void test()
{
	int a = 1;//局部变量a的作用域在test()中，当a出了作用域就被销毁了，下次调用test()时，又需要重新创建a
	a++;
	printf("%d ", a);
}

int main()
{
	int i = 0;
	for (i = 0; i < 10; i++)
	{
		test();
	}
	return 0;
}

 

//代码2
#include<stdio.h>
void test()
{
	//static修饰局部变量a
	static int a = 1;
	a++;
	printf("%d ",a);
}

int main()
{
	int i = 0;
	for (i = 0; i < 10; i++)
	{
		test();
	}
	return 0;
}

                 

看：上面的两个代码几乎一样，只不过第二个代码中自定义函数test()里面用static修饰局部变量，所以出现了这样的差异。

根据代码2的结果推测出每一次调用test(),使用的a都是上一次函数调用时留下的a；第二次调用test()时，由于上次函数调用产生的a没有被销毁，所以不会再次创建a，直接跳到了下一步，a++

注意：static修饰局部变量的时候，其实是改变了变量的存储类型，由栈区存储变成了静态区存储，从而使得静态的局部变量出了自己的作用域也不会被销毁，其实也就是相当于改变了这个变量的生命周期。

这里补充一条小知识点：

内存是一块比较大的空间，在使用内存的时候，会划分出不同的功能区域：栈区、堆区、静态区

 2.static修饰全局变量

//代码1
//add.c文件
int g_val = 2018;//g_val是在add.c文件中定义的

//test.c文件
//如果想使用来自其他文件（外部文件）的全局变量，要先声明一下
extern int g_val;
//extern是一个关键字，专门用来声明外部符号的
int main()
{
	printf("%d\n", g_val);
	return 0;
}

 上面这个程序是正常编译的，不过下面的这个程序就不一定了哦

/代码2
//add.c文件
static int g_val = 2018;

//test.c文件
extern int g_val;

int main()
{
	printf("%d\n", g_val);
	return 0;
}

上面这个程序编译的时候会报错，因为出现连接性错误。

解释：一个全局变量在整个工程中的其他子文件内部能被使用，是因为全局变量具有外部链接属性 ，什么叫外部链接属性，一个变量在一个文件中定义，但是在另一个文件中可以使用（访问）叫外部链接属性。当一个全局变量被static修饰的时候。其外部链接属性就变成了内部连接属性；使得这个全局变量只能在只能在自己的源文件内部使用，其他文件不能再使用，因为它不再具有外部链接属性，给我们的感觉是作用域变小了。

另外，局部变量只有内部连接属性

3.static修饰函数

//代码1
//add.c文件
int Add(int x, int y)
{
	return x + y;
}

//test.c文件
extern int Add(int x, int y);
int main()
{
	printf("%d\n", Add(2, 3));
	return 0;
}

上面的程序编译正常，但是下面的程序编译时会出现错误哦。

//代码2
//add.c文件
static int Add(int x, int y)
{
	return x + y;
}

//test.c文件
extern int Add(int x, int y);
int main()
{
	printf("%d\n", Add(2, 3));
	return 0;
}

 这个程序编译时出现连接性错误。

因为函数也具有外部链接属性，static修饰函数的时候，函数本来是具有外部链接属性的，但是被static修饰后，就变成了内部连接属性，导致这个函数只能在自己的源文件内部使用，给我们的感觉是改变了作用域。

4、#define定义常量和宏

//define定义标识符常量
#define MAX 100

//define定义宏（宏和函数是非常相似的）
#define Add(x, y) ((x) + (y))

5、指针

指针这块内容是非常重要的，与此同时，指针也是很难的，不过铁汁们放心哦，后面笔者会用大量的篇幅去介绍它，这里，简单让大家了解一下。

内存是电脑上特别重要的存储器，计算机中程序的运行都是在内存中进行的，为了有效的使用内存，就把内存划分成一个个小的内存单元，每个内存单元的大小是1个字节，为了能够有效的访问到内存中的每个单元，就把内存单元进行了编号，这些编号被称为内存单元的地址。

#include<stdio.h>
int main()
{
	int num = 10;//num要在内存中开辟空间

	&num;// 取出num的地址，地址也称为指针，注意这里num是一个整型变量，4个字节，每个字节都有地址
	//但是取出的是第一个字节的地址（较小的地址）
	printf("%p\n", &num);//%p是以地址的形式进行打印

	int* p = &num;

	*p = 20;//p是用来存放地址的，p是一个指针变量

	return 0;
}

上面代码中的num 和 p 在内存中就像下图那样存储，只是一个抽象的图，现在看不懂没关系，因为这里只是简单了解，后面笔者会详细介绍的。 

 这里分析一段程序：

#include<stdio.h>
int main()
{
	int num = 10;

	int* p = &num;//int前面的‘*’告诉我们p是一个指针变量，这里的int表示p指向一个整型变量

	*p = 20;//‘*’是解引用操作符，通过p的值，我们找到了p所指向的对象，所以‘*p’就是‘num’


	return 0;
}

 计算指针变量的大小：

指针变量有多大？地址的存放需要多大空间？地址是如何产生的？地址是什么样的数据？

指针大小在32位平台占4个字节，64位平台占8个字节

注意编译器上X86代表32位，X64代表64位

 

 6、结构体

结构体是C语言中特别重要的知识点，结构体使得C语言有能力描述复杂类型

人：复杂对象（名字 + 年龄 + 性别 + ...）;

书：复杂对象（书名 + 作者 + 出版社 + ...）

.......

生活中还有很多这样的复杂对象

#include<stdio.h>
int main()
{
	struct Stu//结构体类型
	{
		char name[20];//名字
		int age;//年龄
		char sex[5];//性别
	};

	//结构体初始化
	struct Stu s = { "小高", 20, "未知" };

	//'.'为结构体成员访问操作符    用法：结构体变量 . 结构体成员
	printf("name = %s age = %d sex = %s\n", s.name, s.age, s.sex);

	//'->'操作符
	struct Stu* ps = &s;
	printf("name = %s age = %d sex = %s\n", (*ps).name, (*ps).age, (*ps).sex);
	printf("name = %s age = %d sex = %s\n", ps->name, ps->age, ps->sex);

	//注意'.'和'->'都是结构体成员访问操作符
	return 0;
}

 

 

 补充：一个汉字是占两个字节的哟。

7、结束语

初始C语言部分到此就结束咯，下一篇博文将会介绍选择语句和循环语句，感觉有所收获的铁汁们给笔者来个三连吧，感谢喔。