### C语言关键字浅析系列 ###

### ISO/ANSI C 关键字 ###

int，几乎是大部分学习C的人最早认识的一个关键字，似乎也是各种源代码中最常见的关键字之一

int不仅是很多main函数的类型，还陪伴了我们学习打印输出、加减乘除求模、排序、查找……

 

int的作用是：

定义或声明整数类型。

 

1、int的存储

通常int类型的数据在内存中用一个字来存储，比如旧时的IBM PC兼容机里面，int用16位来存储（能表示的区间-32768~32767）

现在的计算机一般用32位来存储一个int类型数据，从计算机的发展趋势上看，未来int仍然可能会进化为用64位存储

不过ISO/ANSI C里面还是规定了，int类型的最小取值范围应该是-32768~32767

同时需要注意的是，int类型的整数是有符号整数，所以int在内存中的一个字中有一位是符号位

虽然我们看到的打印出来的int数据是128、345、1949这样的十进制数据，但计算机是二进制的，在内存内部其实是按二进制存储的

如果你了解进制转换就应该清楚，把十进制转为二进制才能方便计算机存储：



2、int的使用

声明一个int变量是最基本的，当然基本是学习C中最简单的语法：

int n;     /* 定义一个整型变量n，未初始化 */
n = 2;     /* 将n赋值 */
int m = 1; /* 定义一个整型变量m，初始化为1 */
int max, min;   /* 一句中定义两个变量max和min，均未初始化 */
int temp = 25, humi = 45;   /* 一句定义两个变量temp和humi，均初始化 */
int width, height = 100;    /* 一句定义两个变量width和height，其中height赋值为100，
                               这种编程风格不提倡，容易引起两个变量都是100的错觉 */

如果你了解C语言的5个存储类，你就会知道上述的变量n是一个自动变量，定义后并没有初始化，所以没有值，但为其分配了内存空间

同样是自动变量的m，在定义时也初始化了，所以为其分配空间时也把值赋了进去

上述代码中还有1,2,25,45等这样的整数字样，其实在C语言中这些明写的数字叫做整数常量

如果一个整数常量的值在int能表示的范围内，C将会把它当做int类型看待，也叫做int常量

类似地，如果整数常量的值大于了int表示范围，C还有其他有更大表示范围的整数类型去看待（比如long）

不过如果你写成了1.0或者25.0，C就不会将其看做整数常量了（后面会讲到C默认把这样的数字看做double双精度浮点数类型）

 

3、int的输入输出

在C中，我们常使用scanf和printf来对数据进行输入和输出

对于int类型的数据，我们还有说明符%d辅助进行输入输出：

int n;
scanf("%d", &n);        /* int的说明符是%d，用scanf输入int数据的值的时候别忘了加&，表示地址引用 */
printf("n = %d", n);    /* int的输出也是使用%d，但后面无需再加&取地址符，注意这与scanf的区别 */

需要注意的是，%d只是最常见的对int数据进行十进制形式输出显示，如果需要八进制或者十进制输出，可以使用%o和%x：

int N = 100;
printf("%d, %o, %x\n", N, N, N);   /* 输出为100,144,64 */
printf("%d, %#o, %#x", N, N, N);   /* 输出为100,0144,0x64，#号是为了更直观地表示数的进制 */

 

——参考《C Primer Plus第五版》

 

相关文章：

C语言关键字浅析-long

C语言关键字浅析-short

C语言关键字浅析-signed

C语言关键字浅析-unsigned

    C语言中函数指针的主要用途是实现Strategy（策略）模式。为了在Java程序设计语言中实现这种模式，声明一个接口来表示该策略，并且为每个具体策略声明一个实现了该接口的类。如果一个具体策略被使用一次，那么通常使用匿名类来声明和实例化这个具体策略。如果一个具体策略需要被到处去以便重复使用，那么它的类通常是一个私有的静态成员类，并且通过一个公有静态final域被导出，其类型为该策略接口。

冒泡排序
起泡排序，别名“冒泡排序”，该算法的核心思想是将无序表中的所有记录，通过两两比较关键字，得出升序序列或者降序序列。
更多学习资料Q群：569268376
例如，对无序表{49，38，65，97，76，13，27，49}进行升序排序的具体实现过程如图 1 所示：
图 1 第一次起泡
如图 1 所示是对无序表的第一次起泡排序，最终将无序表中的最大值 97 找到并存储在表的最后一个位置。具体实现过程为：
首先 49 和 38 比较，由于 38<49，所以两者交换位置，即从(1)到(2)的转变；
然后继续下标为 1 的同下标为 2 的进行比较，由于 49<65，所以不移动位置，(3)中 65 同 97 比较得知，两者也不需要移动位置；
直至(4)，97 同 76 进行比较，76<97，两者交换位置，如(5)所示；
同样 97>13(5)、97>27(6)、97>49(7)，所以经过一次冒泡排序，最终在无序表中找到一个最大值 97，第一次冒泡结束；
由于 97 已经判断为最大值，所以第二次冒泡排序时就需要找出除 97 之外的无序表中的最大值，比较过程和第一次完全相同。
经过第二次冒泡，最终找到了除 97 之外的又一个最大值 76，比较过程完全一样，这里不再描述。
通过一趟趟的比较，一个个的“最大值”被找到并移动到相应位置，直到检测到表中数据已经有序，或者比较次数等同于表中含有记录的个数，排序结束，这就是起泡排序。
完整代码
#include //交换 a 和 b 的位置的函数void swap(int *a, int *b);int main(){ int array[8] = {49,38,65,97,76,13,27,49}; int i, j; int key; //有多少记录，就需要多少次冒泡，当比较过程，所有记录都按照升序排列时，排序结束 for (i = 0; i < 8; i++){ key=0;//每次开始冒泡前，初始化 key 值为 0 //每次起泡从下标为 0 开始，到 8-i 结束 for (j = 0; j+1<8-i; j++){ if (array[j] > array[j+1]){ key=1; swap(&array[j], &array[j+1]); } } //如果 key 值为 0，表明表中记录排序完成 if (key==0) { break; } } for (i = 0; i < 8; i++){ printf("%d 

快速排序
快速排序是交换排序的一种，通过分而治之的策略，交换两个不相邻的元素，一次可以消去多个逆序，效率极高。

基本思想

在待排序的序列L[1~n]中，任意取一个元素pivot作为“枢轴”，凡是关键字小于枢轴的记录，均移动到该记录之前，关键字大于枢轴的记录，均移动到该记录之后，即对无序的记录进行“以此划分”，之后分别对分割所得的两个子序列“递归”调用进行快排。

通过一趟排序将待排序序列划分为具有如下特点的两部分：



一次划分会将一个元素pivot防止在它最终的位置上。

算法实现的思路

初始化标记low为划分部分第一个元素的位置，high为最后一个元素的位置，然后不断地移动两个标记并交换：

（1）high向前移动找到第一个比pivot小的元素

（2）low向后移动找到第一个比pivot大的元素

（3）交换当前两个位置的元素

（4）继续移动标记，执行1),2),3)的过程，直到low>=high为止。
C语言代码

#include <stdio.h>
int Partition(int A[],int low,int high);
void QuickSort(int A[],int low,int high);

int main() {
	int A[1024],n;
	printf("请输入要输入的元素个数：");
	scanf("%d",&n);
	printf("\n请输入要排序的序列：\n");
	for (int i=1; i<=n; i++) //输入的元素从1开始，0做哨兵
		scanf("%d",&A[i]);
	printf("\n使用快速排序算法后的结果：\n");
	QuickSort(A,1,n);
	for(int i=1; i<=n; i++)
		printf("%d\t",A[i]);
	printf("\n");
	return 0;
}
int Partition(int A[],int low,int high){
	int pivot=A[low];//pivot枢点 
	while(low<high){
		while(low<high&&A[high]>=pivot)
			high--;
		A[low]=A[high];
		while(low<high&&A[low]<=pivot)
			low++;
		A[high]=A[low];
	}A[low]=pivot;
	return low;
} 

void QuickSort(int A[],int low,int high){
	if(low<high){
		int pivotpos=Partition(A,low,high);
		QuickSort(A,low,pivotpos-1);
		QuickSort(A,pivotpos+1,high);
	}
}


运行结果
Notes

①平均时间复杂度O(nlog2n)，平均空间复杂度O(log2n)；最坏时间复杂度O(n^2)，最坏空间复杂度O(n)

②快速排序是不稳定的排序算法