（C语言笔记精选）一篇代码带你快速复习c语言入门知识点

//#include "xxxx.h"或#include 为引用头文件，头文件中存在系统定义好的函数，可以·方便操作者使用 
#include 

//字符串strcpy处理的函数的出处 
#include  

//字符串atoi处理的函数的出处 
#include  

//使用assert函数检查文件是否为空 
#include 

//注：请从void main()开始看起 






//宏定义 
//#define 定义名字（标识符） 需替代的内容(字符串)
//注：不需以";"结尾 
//使用undef 标识符  语句 终止该标识符的作用域 
#define YELLOW 4
//定义带参数的宏 
#define V(a,b,c) a*b*c    //可类似简单小函数 


//自动变量：在函数体或复合语句中定义的非静态变量
//c语言编译时部队自动变量赋初始值，只有当程序执行到自动变量的作用域时，程序才自动分配空间，复合语句或函数执行完后，
// 自动变量才被释放销毁：自动变量存储在程序的为动态存储空间 

//register声明:寄存器变量 

//static 修饰的为静态局部变量，编译时程序需对静态变量赋初始值 ，运行期间均占用程序的存储空闲，直到程序退出后才释放该空间 
//外部变量（全局变量） :为静态储存空间， 运行期间均占用程序的存储空闲，直到程序退出后才释放该空间。 


//在定义变量或输出语句 以及do-while()、continue,break等的末尾需要添加";"号 



//void为空，引用该定义赋的函数可以存在不反回值，int,double,char,再函数开头定义的函数必须具有该定义类型的返回值
//函数定义：修饰符 函数名(形参，形参，...){...... return 修饰符修饰的该类型变量} 
//调用：函数名（实参，实参，....）;注：形参实参个数一一对应。例：以下面的函数为例，调用：  int a[]={1,2,3,4,5}         sort_bubble(a,9) 
//下面的函数的形参为int *array与int len;表名其中一个是数组类型或指针类型，另一个为int类型 
void sort_bubble(int *array,int len)
{
	int i,j,k;
		for(i=0;iarray[j+1]){
					k=array[j];
					array[j]=array[j+1];
					array[j+1]=k;
				}
			
			}
		}
}



//打印int数组成员的函数 
void printf_arrays(int *array,int len)
{
	int i;
	printf("数组排序后:");
	for(i=0;i	注：取值范围看指数位，精度看位数位	
						
						//4个字节	
						//（1位符号位，8位指数位，23位尾数位）
						//由于2^8=(-128——127) 所以取值范围：-2^128——2^127 	约为-3.4E38——3.4E38 
						//小数精度：2^23=8.3E6可表示小数点后七、八位根据编译器而定
					float Fnumber=25.12345678910111213;	
					printf("Fnumber= %9.8f",Fnumber); 
						//输出:Fnumber= 25.12345695 注：可根据自己想要结果调%f,例%10.8f 
					
					printf("\n");//换行符 
					
						//8个字节 
						//(1位符号位，11位指数位，52位尾数位)	 		
						//由于2^11=(-1024——1023) 所以取值范围：-2^1024——2^1023 	
						//小数精度:2^52=4.5E15可表示小数点的十五、十六位
					double Dnumber=25.12345678910111213; 	
					printf("Dnumber= %9.8lf",Dnumber); 	 
						//输出:Dnumber= 25.12345679
						
						
			printf("\n");//换行符 
			
			
			//字符型
					char ch='a';
					char ch2='a'; 
					char ArrayCh[]="abcd";
					char ArrayCh2[]="1234abc";
					printf("\n");
					printf("ch=%d",sizeof(ch));//一个字节 
					printf("\n");
					printf("ch2=%d",sizeof(ch2));//一个字节 
					printf("\n");
					printf("字符串1=%d",sizeof(ArrayCh));//五个字节，最后一个属于结尾符号 
					printf("\n");
					printf("字符串2=%d",sizeof(ArrayCh2));//八个字节,最后一个....
			
			//printf("%f") float 
			//printf("%lf") double
					printf("\n");
					int i=1234567;
					int i2=1234;
					int i3=125;
					printf("7w=%6d",i);
					printf("\n");
					printf("6w=%6d",i2);
					printf("\n");
					printf("5w=%5d",i3);
					printf("\n");
			//printf("%6d") 输出6位十进制数，超出按实际位数输出 ,不足将空出空格 
			//printf("%06d") 输出6位十进制数，超出按实际位数输出 ,不足将空出00补充 
			//printf("%s") 字符串 
			//printf("%c") 字符
			
					float a=1234532.83456;
					printf("a=%8.7f",a); //总共可输出8位 ，当前面8位整数满了时，后面小数化为0，最靠近小数点的那位采取四舍五入 
					//输出:a=12345322.0000000
					//输入:a=1234532.83456,输出为:a=1234532.8750000:此时小数点不固定 ,未知的以0补充 
			//printf("%8.7f") 
			//printf("%18.16lf") 同上 
			//printf("s[]=%6.9s")输出最多9个字符 
			//printf("%p") 输出指针的值
			//printf("%x") 输出八进制ASCII码 
			
	//注：类型级别由低到高（char，short—int——unsigned—long—double；float—double）的顺序进行转换。
			
			
			
			
	// 算法 、方法 
	//while()、do-while()、break、if()-else、switch-case-break、return、goto、for()、continue、
	//++i与i++、&&、||、+=、scanf()、getchar() 、putchar()、printf()、gets()、puts()、获取数组长度sizeof(arrays)/sizeof(arrays[0]) 
	
			//数组：有序数据的集合，元素类型相同，顺序存储结构，占用相同存储空间，且必须先定义后使用。
			//静态数组变量编译时自动将数据初始化为0，动态数组在执行时才分配空间，且初始值为随机
			//c语言只能逐个引用数组元素，不能一次性引用整个数组 
			char c;//在循环外面进行创建，避免了反复创建变量导致浪费空间的缺点 
			int Arraysi[]={2,34,5,64,123,-31,0,23,44};//第一种定义数组的方法 
			int Arraysi2[10]={1,42,23,14,35,66,47,28,99,0};//第二种，先定义长度，然后在里面定义内容 
			int TArray[3][3]={{1,2,3},{4,5,6},{7,8,9}};//格式int TArray[i][j]={{1,2,3,...},{4,5,6,...},{7,8,9,...},{....}};
			
			int conditionNumber=0; 
			//公式：do{......循环类容}while(判断条件);
			//公式：while(判断条件){执行内容} 
			//两者区别：do-while()不管条件成不成立都需要先执行一次内容，在开始判断，而while直接判断，符合条件的才开始执行内容 
			do{
				int conditionNumber=0;
				while((++conditionNumber)!=25)//++i先进行++,即先给conditionNumber赋值, 在进行判断 
				{
					printf("\n"); 
					printf("输入a,b,c,d,e,f:"); 
					printf("\n\ta:调用冒泡排序");
					printf("\n\tb:调用冒泡排序");
					printf("\n\tc:调用冒泡排序");
					printf("\n\td:调用冒泡排序");
					printf("\n\te:调用冒泡排序");
					printf("\n\tf:退出");
					printf("\n"); 
					printf("c= ");
					c=getchar();//输入字符，里面的空间可以调用外面空间的变量，而外面的不可以调用里面小空间的变量 
					putchar(c); //输出字符 
					printf("\n");
					
					//公式：if(判断条件){需执行的内容}
					//if(){}else{}
					//if(){}else if(){}
					//if(){}else if(){}else if(){}..... 
					if(c=='a'){				
						if(Arraysi2==NULL){
							printf("\n数组为空，第193行有误"); 
						}else{
							sort_bubble(Arraysi2,sizeof(Arraysi2)/sizeof(Arraysi2[0])); //调用冒泡排序方法（函数） 
							printf_arrays(Arraysi2,sizeof(Arraysi2)/sizeof(Arraysi2[0]));//调用打印数组函数，等价于下面 
								/*	int i;
									printf("数组排序后:");
									for(i=0;i15);
			
			int putNumber,sc;
			printf("\n请输入1~4之间的数字(测试switch-case代码，数字3使用goto语句):");
			scanf("%d",&putNumber);
		 	char sss='b';
			for(sc=0;sc<10;sc++){
				//公式：switch(传入的数据){case 匹配数据:...执行语句... break;（或continue或无，若无，将继续执行匹配）} 
				switch(putNumber){
					case 1:
						printf("1");
						break;
					case 2:
						printf("2");
						continue;//必须使用在有循环的地方 
					case 3:
						printf("3");
						sss='s';
						//s为定义的标记，goto为直接跳到s标记的语句处(定义：s:) 
						goto s;
					case YELLOW:
						printf("YELLOW");//采用宏定义，请查看开头 
						break;
				} 
			}
		
			s:if(sss=='s'){
				printf("\ngoto使用成功");
			}
			//二维数组的使用
			printf("\n打印二维数组\n");
			int p,q;
			for(p=0;p<3;p++){
				for(q=0;q<3;q++){
					printf("%d\t",TArray[p][q]);
				}
				printf("\n");//换行 
			} 
			
			
	//字符串处理： 
		/*	字符串反转：strRev
			字符串复制：strcpy
			字符串转化为整数：atoi
			字符串求长：strlen
			字符串连接：strcat 
			字符串比较：strcmp
			字符串查找字符：strchr 
		*/	 
				//strcpy 
				printf("\n字符串处理\n");
				char strcpyChar[10];
				char *strcpyCh="abcdefghi";
				strcpy(strcpyChar,strcpyCh);
				printf("\nstrcpy处理:%s\n",strcpyChar);
				
				//strcat
				char strcatChar[50];
				char *strcatCh1="欢迎",*strcatCh2="关注",*strcatCh3="President_";
				strcat(strcatChar,strcatCh1);
				strcat(strcatChar,strcatCh2);
				strcat(strcatChar,strcatCh3);
				printf("\nstrcat处理:%s\n\n",strcatChar);
					/*
					注：以下非本人编写，引用他人笔记，倘若想查询更多相关字符串处理，请自行搜索	
					注：以下非本人编写，引用他人笔记，倘若想查询更多相关字符串处理，请自行搜索	
					注：以下非本人编写，引用他人笔记，倘若想查询更多相关字符串处理，请自行搜索	
					注：以下非本人编写，引用他人笔记，倘若想查询更多相关字符串处理，请自行搜索	
					注：以下非本人编写，引用他人笔记，倘若想查询更多相关字符串处理，请自行搜索	
							
									函数名: strcpy 
								功  能: 拷贝一个字符串到另一个 
								用  法: char *stpcpy(char *destin, char *source); 
								程序例: 
								#include  
								#include  
								int main(void) 
								{ 
								   char string[10]; 
								   char *str1 = "abcdefghi"; 
								   stpcpy(string, str1); 
								   printf("%sn", string); 
								   return 0; 
								} 
								  
								
								函数名: strcat 
								功  能: 字符串拼接函数 
								用  法: char *strcat(char *destin, char *source); 
								程序例: 
								#include  
								#include  
								int main(void) 
								{ 
								   char destination[25]; 
								   char *blank = " ", *c = "C++", *Borland = "Borland"; 
								   strcpy(destination, Borland); 
								   strcat(destination, blank); 
								   strcat(destination, c); 
								   printf("%sn", destination); 
								   return 0; 
								} 
								  
								  
								函数名: strchr 
								功  能: 在一个串中查找给定字符的第一个匹配之处 
								用  法: char *strchr(char *str, char c); 
								程序例: 
								#include  
								#include  
								int main(void) 
								{ 
								    char string[15]; 
								    char *ptr, c = 'r'; 
								    strcpy(string, "This is a string"); 
								    ptr = strchr(string, c); 
								    if (ptr) 
								       printf("The character %c is at position: %dn", c, ptr-string); 
								    else 
								       printf("The character was not foundn"); 
								    return 0; 
								} 
								  
								  
								函数名: strcmp 
								功  能: 串比较 
								用  法: int strcmp(char *str1, char *str2); 
								看Asic码，str1>str2，返回值 > 0；两串相等，返回0
								程序例: 
								#include  
								#include  
								int main(void) 
								{ 
								    char *buf1 = "aaa", *buf2 = "bbb", *buf3 = "ccc"; 
								    int ptr; 
								    ptr = strcmp(buf2, buf1); 
								    if (ptr > 0) 
								       printf("buffer 2 is greater than buffer 1n"); 
								    else 
								       printf("buffer 2 is less than buffer 1n"); 
								    ptr = strcmp(buf2, buf3); 
								    if (ptr > 0) 
								       printf("buffer 2 is greater than buffer 3n"); 
								    else 
								       printf("buffer 2 is less than buffer 3n"); 
								    return 0; 
								} 
								  
								  
								函数名: strncmpi 
								功  能: 将一个串中的一部分与另一个串比较, 不管大小写 
								用  法: int strncmpi(char *str1, char *str2, unsigned maxlen); 
								程序例: 
								#include  
								#include  
								int main(void) 
								{ 
								   char *buf1 = "BBB", *buf2 = "bbb"; 
								   int ptr; 
								   ptr = strcmpi(buf2, buf1); 
								   if (ptr > 0) 
								      printf("buffer 2 is greater than buffer 1n"); 
								   if (ptr < 0) 
								      printf("buffer 2 is less than buffer 1n"); 
								   if (ptr == 0) 
								      printf("buffer 2 equals buffer 1n"); 
								   return 0; 
								} 
								  
								  
								函数名: strcpy 
								功  能: 串拷贝 
								用  法: char *strcpy(char *str1, char *str2); 
								程序例: 
								#include  
								#include  
								int main(void) 
								{ 
								    char string[10]; 
								    char *str1 = "abcdefghi"; 
								    strcpy(string, str1); 
								    printf("%sn", string); 
								    return 0; 
								} 
								  
								  
								函数名: strcspn 
								功  能: 在串中查找第一个给定字符集内容的段 
								用  法: int strcspn(char *str1, char *str2); 
								程序例: 
								#include  
								#include  
								#include  
								int main(void) 
								{ 
								    char *string1 = "1234567890"; 
								    char *string2 = "747DC8"; 
								    int length; 
								    length = strcspn(string1, string2); 
								    printf("Character where strings intersect is at position %dn", length); 
								    return 0; 
								} 
								  
								  
								函数名: strdup 
								功  能: 将串拷贝到新建的位置处 
								用  法: char *strdup(char *str); 
								程序例: 
								#include  
								#include  
								#include  
								int main(void) 
								{ 
								    char *dup_str, *string = "abcde"; 
								    dup_str = strdup(string); 
								    printf("%sn", dup_str); 
								    free(dup_str); 
								    return 0; 
								} 
								
								
								函数名: strcmp 
								功  能: 比较字符串str1和str2。
								用  法: int strcmp(char *str1, char *str2); 
								说  明: 当s1s2时，返回值>0 　　
								           即：两个字符串自左向右逐个字符相比（按ASCII值大小相比较），直到出现不同的字符或遇'\0'为止。
								程序例: 
								#include 　　
								#include 　　
								void main() 　　
								{ 　　
								    char string[20]; 　　
								    char str[3][20]; 　　
								    int i; 　　
								    for(i=0;i<3;i++) 　　
								    gets(str[i]); 　　
								    if(strcmp(str[0],str[1])>0) 　　
								    strcpy(string,str[0]); 　　
								    else 　　
								    strcpy(string,str[1]); 　　
								    if(strcmp(str[2],string)>0) 　　
								    strcpy(string,str[2]); 　　
								    printf("\nThe largest string is %s\n",string); 　　
								} 
								
								
								  
								函数名: stricmp 
								功  能: 以大小写不敏感方式比较两个串 
								用  法: int stricmp(char *str1, char *str2); 
								程序例: 
								#include  
								#include  
								int main(void) 
								{ 
								   char *buf1 = "BBB", *buf2 = "bbb"; 
								   int ptr; 
								   ptr = stricmp(buf2, buf1); 
								   if (ptr > 0) 
								      printf("buffer 2 is greater than buffer 1n"); 
								   if (ptr < 0) 
								      printf("buffer 2 is less than buffer 1n"); 
								   if (ptr == 0) 
								      printf("buffer 2 equals buffer 1n"); 
								   return 0; 
								} 
								  
								  
								函数名: strerror 
								功  能: 返回指向错误信息字符串的指针 
								用  法: char *strerror(int errnum); 
								程序例: 
								#include  
								#include  
								int main(void) 
								{ 
								   char *buffer; 
								   buffer = strerror(errno); 
								   printf("Error: %sn", buffer); 
								   return 0; 
								} 
								  
								  
								函数名: strcmpi 
								功  能: 将一个串与另一个比较, 不管大小写 
								用  法: int strcmpi(char *str1, char *str2); 
								程序例: 
								#include  
								#include  
								int main(void) 
								{ 
								   char *buf1 = "BBB", *buf2 = "bbb"; 
								   int ptr; 
								   ptr = strcmpi(buf2, buf1); 
								   if (ptr > 0) 
								      printf("buffer 2 is greater than buffer 1n"); 
								   if (ptr < 0) 
								      printf("buffer 2 is less than buffer 1n"); 
								   if (ptr == 0) 
								      printf("buffer 2 equals buffer 1n"); 
								   return 0; 
								} 
								  
								  
								函数名: strncmp 
								功  能: 串比较 
								用  法: int strncmp(char *str1, char *str2, int maxlen); 
								程序例: 
								#include  
								#include  
								int  main(void) 
								{ 
								   char *buf1 = "aaabbb", *buf2 = "bbbccc", *buf3 = "ccc"; 
								   int ptr; 
								   ptr = strncmp(buf2,buf1,3); 
								   if (ptr > 0) 
								      printf("buffer 2 is greater than buffer 1n"); 
								   else 
								      printf("buffer 2 is less than buffer 1n"); 
								   ptr = strncmp(buf2,buf3,3); 
								   if (ptr > 0) 
								      printf("buffer 2 is greater than buffer 3n"); 
								   else 
								      printf("buffer 2 is less than buffer 3n"); 
								   return(0); 
								} 
								  
								  
								函数名: strncmpi 
								功  能: 把串中的一部分与另一串中的一部分比较, 不管大小写 
								用  法: int strncmpi(char *str1, char *str2); 
								程序例: 
								#include  
								#include  
								int main(void) 
								{ 
								   char *buf1 = "BBBccc", *buf2 = "bbbccc"; 
								   int ptr; 
								   ptr = strncmpi(buf2,buf1,3); 
								   if (ptr > 0) 
								      printf("buffer 2 is greater than buffer 1n"); 
								   if (ptr < 0) 
								      printf("buffer 2 is less than buffer 1n"); 
								   if (ptr == 0) 
								      printf("buffer 2 equals buffer 1n"); 
								   return 0; 
								} 
								  
								  
								函数名: strncpy 
								功  能: 串拷贝 
								用  法: char *strncpy(char *destin, char *source, int maxlen); 
								程序例: 
								#include  
								#include  
								int main(void) 
								{ 
								   char string[10]; 
								   char *str1 = "abcdefghi"; 
								   strncpy(string, str1, 3); 
								   string[3] = ''; 
								   printf("%sn", string); 
								   return 0; 
								} 
								  
								  
								函数名: strnicmp 
								功  能: 不注重大小写地比较两个串 
								用  法: int strnicmp(char *str1, char *str2, unsigned maxlen); 
								程序例: 
								#include  
								#include  
								int main(void) 
								{ 
								   char *buf1 = "BBBccc", *buf2 = "bbbccc"; 
								   int ptr; 
								   ptr = strnicmp(buf2, buf1, 3); 
								   if (ptr > 0) 
								      printf("buffer 2 is greater than buffer 1n"); 
								   if (ptr < 0) 
								      printf("buffer 2 is less than buffer 1n"); 
								   if (ptr == 0) 
								      printf("buffer 2 equals buffer 1n"); 
								   return 0; 
								} 
								  
								  
								函数名: strnset 
								功  能: 将一个串中的所有字符都设为指定字符 
								用  法: char *strnset(char *str, char ch, unsigned n); 
								程序例: 
								#include  
								#include  
								int main(void) 
								{ 
								   char *string = "abcdefghijklmnopqrstuvwxyz"; 
								   char letter = 'x'; 
								   printf("string before strnset: %sn", string); 
								   strnset(string, letter, 13); 
								   printf("string after  strnset: %sn", string); 
								   return 0; 
								} 
								  
								  
								函数名: strpbrk 
								功  能: 在串中查找给定字符集中的字符 
								用  法: char *strpbrk(char *str1, char *str2); 
								程序例: 
								#include  
								#include  
								int main(void) 
								{ 
								   char *string1 = "abcdefghijklmnopqrstuvwxyz"; 
								   char *string2 = "onm"; 
								   char *ptr; 
								   ptr = strpbrk(string1, string2); 
								   if (ptr) 
								      printf("strpbrk found first character: %cn", *ptr); 
								   else 
								      printf("strpbrk didn't find character in setn"); 
								   return 0; 
								} 
								  
								  
								函数名: strrchr 
								功  能: 在串中查找指定字符的最后一个出现 
								用  法: char *strrchr(char *str, char c); 
								程序例: 
								#include  
								#include  
								int main(void) 
								{ 
								   char string[15]; 
								   char *ptr, c = 'r'; 
								   strcpy(string, "This is a string"); 
								   ptr = strrchr(string, c); 
								   if (ptr) 
								      printf("The character %c is at position: %dn", c, ptr-string); 
								   else 
								      printf("The character was not foundn"); 
								   return 0; 
								} 
								  
								  
								函数名: strrev 
								功  能: 串倒转 
								用  法: char *strrev(char *str); 
								程序例: 
								#include  
								#include  
								int main(void) 
								{ 
								   char *forward = "string"; 
								   printf("Before strrev(): %sn", forward); 
								   strrev(forward); 
								   printf("After strrev():  %sn", forward); 
								   return 0; 
								} 
								  
								函数名: strset 
								功  能: 将一个串中的所有字符都设为指定字符 
								用  法: char *strset(char *str, char c); 
								程序例: 
								#include  
								#include  
								int main(void) 
								{ 
								   char string[10] = "123456789"; 
								   char symbol = 'c'; 
								   printf("Before strset(): %sn", string); 
								   strset(string, symbol); 
								   printf("After strset():  %sn", string); 
								   return 0; 
								} 
								  
								  
								  
								函数名: strspn 
								功  能: 在串中查找指定字符集的子集的第一次出现 
								用  法: int strspn(char *str1, char *str2); 
								程序例: 
								#include  
								#include  
								#include  
								int main(void) 
								{ 
								   char *string1 = "1234567890"; 
								   char *string2 = "123DC8"; 
								   int length; 
								   length = strspn(string1, string2); 
								   printf("Character where strings differ is at position %dn", length); 
								   return 0; 
								} 
								  
								  
								函数名: strstr 
								功  能: 在串中查找指定字符串的第一次出现 
								用  法: char *strstr(char *str1, char *str2); 
								程序例: 
								#include  
								#include  
								int main(void) 
								{ 
								   char *str1 = "Borland International", *str2 = "nation", *ptr; 
								   ptr = strstr(str1, str2); 
								   printf("The substring is: %sn", ptr); 
								   return 0; 
								} 
								  
								  
								函数名: strtod 
								功  能: 将字符串转换为double型值 
								用  法: double strtod(char *str, char **endptr); 
								程序例: 
								#include  
								#include  
								int main(void) 
								{ 
								   char input[80], *endptr; 
								   double value; 
								   printf("Enter a floating point number:"); 
								   gets(input); 
								   value = strtod(input, &endptr); 
								   printf("The string is %s the number is %lfn", input, value); 
								   return 0; 
								} 
								
								
								函数名: strsep
								功  能: 分解字符串为一组字符串。从str1指向的位置起向后扫描，遇到delim指向位置的字符后，将此字符替换为NULL，返回str1指向的地址。
								用  法: char *strtok(char **str1, const char *delim); 
								程序例: 
								int main() 　　
								{ 　
								　int len, nel; 　
								　char query[] ="user_command=appleboy&test=1&test2=2"; 　
								　char *q, *name, *value; 　　
								　q = query; 　　fprintf(stderr, "CGI[query string] : %s\n",query); 　
								　len = strlen(query); 　
								　nel = 1; 　
								　while (strsep(&q, "&")) 　
								　nel++; 　
								　fprintf(stderr, "CGI[nel string] : %d\n", nel); 　
								　for (q = query; q< (query + len);) 
								   { 　
								　    value = name = q; 　　
								　　fprintf(stderr, "CGI[string] :%s\n", q); 
								　　fprintf(stderr, "CGI[stringlen] : %d\n", strlen(q)); 
								　　fprintf(stderr, "CGI[address] :%x\n", q); 
								　　for (q += strlen(q); q < (query +len) && !*q; q++); 　　
								　　name = strsep(&value,"="); 
								　　fprintf(stderr, "CGI[name ] :%s\n", name); 
								　　fprintf(stderr, "CGI[value] :%s\n", value); 
								　} 　
								　return 0; 　　
								} 
								
								  
								函数名: strtok 
								功  能: 查找由在第二个串中指定的分界符分隔开的单词 
								用  法: char *strtok(char *str1, char *str2); 
								程序例: 
								#include  
								#include  
								int main(void) 
								{ 
								   char input[16] = "abc,d"; 
								   char *p; 
																   [ strtok places a NULL terminator 
																   in front of the token, if found ]
								   p = strtok(input, ","); 
								   if (p)   printf("%sn", p); 
																   [A second call to strtok using a NULL 
																   as the first parameter returns a pointer 
																   to the character following the token  ]
								   p = strtok(NULL, ","); 
								   if (p)   printf("%sn", p); 
								   return 0; 
								} 
								  
								  
								函数名: strtol 
								功  能: 将串转换为长整数 
								用  法: long strtol(char *str, char **endptr, int base); 
								程序例: 
								#include  
								#include  
								int main(void) 
								{ 
								   char *string = "87654321", *endptr; 
								   long lnumber; 
								 											  [ strtol converts string to long integer  ]
								   lnumber = strtol(string, &endptr, 10); 
								   printf("string = %s  long = %ldn", string, lnumber); 
								   return 0; 
								} 
								  
								函数名: strupr 
								功  能: 将串中的小写字母转换为大写字母 
								用  法: char *strupr(char *str); 
								程序例: 
								#include  
								#include  
								int main(void) 
								{ 
								   char *string = "abcdefghijklmnopqrstuvwxyz", *ptr; 
								   												[ converts string to upper case characters ]
								   ptr = strupr(string); 
								   printf("%sn", ptr); 
								   return 0; 
								} 
								  
								  
								函数名: swab 
								功  能: 交换字节 
								用  法: void swab (char *from, char *to, int nbytes); 
								程序例: 
								#include  
								#include  
								#include  
								char source[15] = "rFna koBlrna d"; 
								char target[15]; 
								int main(void) 
								{ 
								   swab(source, target, strlen(source)); 
								   printf("This is target: %sn", target); 
								   return 0; 
								}
								
								
								
								PS:isalpha()是字符函数，不是字符串函数，
								
								isalpha 
								  
								
								
								  原型：extern int isalpha(int c);
								  
								  用法：#include 
								  
								  功能：判断字符c是否为英文字母
								  
								  说明：当c为英文字母a-z或A-Z时，返回非零值，否则返回零。
								  
								  举例：
								
								      // isalpha.c
								      
								    	#include  
										#include  
										#include  
								
								      main()
								      {
								        int c;
								        
								        clrscr();        // clear screen
								        printf("Press a key");
								        for(;;)
								        {
								          c=getchar();
								          clrscr();
								          printf("%c: %s letter",c,isalpha(c)?"is":"not");
								        }
								        return 0; // just to avoid warnings by compiler
								      }
								      
								      
								      
								      
								      
					注：以上非本人编写，引用他人笔记，倘若想查询更多相关字符串处理，请自行搜索	
					注：以上非本人编写，引用他人笔记，倘若想查询更多相关字符串处理，请自行搜索	
					注：以上非本人编写，引用他人笔记，倘若想查询更多相关字符串处理，请自行搜索	
					注：以上非本人编写，引用他人笔记，倘若想查询更多相关字符串处理，请自行搜索	
					注：以上非本人编写，引用他人笔记，倘若想查询更多相关字符串处理，请自行搜索											
					
					*/
	
	
	
	
	
	
	
	//指针：
	//变量的防问方式：
				//直接防问：
				printf("\n测试指针\n"); 
				int ZZnumber=10;
				//间接防问:
				int *ZZp=NULL;//定义一个int类型的指针变量，可以先将初始指针初始化，不然容易报错 （防止指针已经存储了随即值） 
				ZZp=&ZZnumber;//指向ZZnumber的地址 
				int ZZnumberb;//定义另一个变量 
				ZZnumberb=*ZZp;//取出ZZp地址中储存的值赋给ZZnumberb 
				printf("\nZZnumberb=%d",ZZnumberb);//打印出：10 
				*ZZp=100;//由于*ZZp已经将地址指向了ZZnumber,所以此时给他：ZZp地址中储存的值赋值于100，等于是说给ZZnumber赋值 
				printf("\nZZnumber=%d",ZZnumber);//打印出:100 
			
	//指针与数组
			 char ZZChari[]={'a','b','c','d','x','y','z'};
			 char ZZC=NULL;
			 ZZC=&ZZChari;
			 printf("\n\n\n指针与数组的互换\n");
			 sort_printf(ZZC,sizeof(ZZChari)/sizeof(ZZChari[0]));//自定义的数组输出函数 ,传入的是ZZC指针，与数组的长度，指针与数组的互换请看自定义函数的注释 
			//输出了排序后的数组元素 



	//共用体
		//	1、共用体指将几种不同类型的变量存储在同一段内存单元中。
		//	2、共用体变量的存储单元大小等于最长成员变量所占内存的长度
		//	3、共用体变量中起作用的是最后一次存放成员。
		//	4、共用体类型声明方式：union公用体类型名称｛成员变量列表｝；
		//	5、共用体变量声明方式：
		//		（1）union公用体类型名称｛成员列表｝共用体变量；
		//		（2）先声明共用体类型，然后声明共用体变量，union公用体类型名称共用体变量。		 
		union Dog{
			int age;
			char name[20];
			char color;
		};
		printf("\n\n\n共用体特征");
		union Dog dog;
		printf("\n\ndog sizeof=%d",sizeof(dog));
		//明显共用体的单元大小等于最长成员变量所占内存的长度：20
		dog.age=7;
		dog.color='r';
		strcpy(dog.name,"大黄");//赋值名字给dog
		printf("\n\nage=%d color=%c name=%s",dog.age,dog.color,dog.name); 
		//输出明显前两个值有损失，而最后一次存放的成员是dog.name，所以可以完好输出 
		dog.age=6;
		printf("\n\nage=%d",dog.age);//输出6 
		dog.color='b';
		printf("\ncolor=%d",dog.color);//输出b 
		strcpy(dog.name,"小黄");
		printf("\nname=%d",dog.name);//输出小黄 
		//显然每一次输入一个值后，便可以每一个完好输出 
		
		
		
		
			 
	//宏定义：详细看代码开头 
	int Hnumber=V(2,3,5);
	printf("\n\n\n宏数字：%d",Hnumber);
			 
	//结构体		 
	//1、作用——将不同类型的数据组合成一个有机的整体。
	//2、结构体的定义——结构体是一种数据结构，按照某种规则定义，将若干个不同数据类型（也可相同）的数据项的组合成的一个有机整体.
	//公式一：struct 结构体类型名字 { 		类型标识符1 成员名1；	类型标识符2 成员名2；		} ；	
			// 接着在定义该结构体实例： struct 结构体类型名字  结构体实例名字
	//公式二：struct 结构体类型名字 {		类型标识符1 成员名1；	类型标识符2 成员名2；		}结构体实例名字1，结构体实例名字2; 
	//公式三：struct {}结构体实例名字1，结构体实例名字2; 
	//注：当结构体实例为指针时，将使用  指针名 ->结构体内容 
	
	
	//以下将链表、文件与结构体结合一起叙述：
	
			//单项链表结构：链表有一个头指针和表尾null指针。每个结点包含实际数据和下一个结点的地址。 
			//双向链表以及堆栈之类的可在我的CSDN号：Presidnet;（欢迎关注）的另一分类算法与数据结构中讲述 
			
			//文件 ：C语言中对文件的存取是以字符（字节）为单位的，一个输入输出流就是一个字节流或二进制流。
			//文件的存储方式分为缓冲文件系统和非缓冲文件系统。
			//区别是缓冲文件系统是系统自动开辟缓冲区，非缓冲文件系统是由程序为每个文件设定缓冲区。ANSIC标准只采用缓冲文件系统来处理文件。 
			//FILE结构体类型原型：
				
				//typedef :作用：typedef声明新的类型名替代了已有的类型名（有点复杂）
				//typedef 类型名称 新的类型名称
				//例子：一、typedef int A    二、使用A定义一个声明：   A a           三、等价替换 :      int a       
				//例子：一、typedef int A[2]    二、使用A定义一个声明：   A a           三、等价替换 :      int a[2]    
				//例子：一、typedef int A[M][N]    二、使用A定义一个声明：   A a           三、等价替换 :      int a[M][N]  
				//例子：一、typedef int *A           二、使用A定义一个声明：    A a      	  三、等价替换 :      int *a 
				//例子：一、typedef int *A[M]           二、使用A定义一个声明：   A a            三、等价替换 :      int *a[M] 
				//例子：一、typedef int Function(....)    二、使用Function定义一个声明：   Function A      三、等价替换 :      int A(....) 
				
				//例子结构体：一、typedef struct Person{....}Student,*StudentNumber;    二、使用Student定义一个声明： Student xiaoming      三、等价替换 :  struct Persion{...} xiaoming  
			
				//也就是说，此时Student 来声明Person类型 															-----这里看不懂可以不看
				//接着看  *StudentNumber   表示属于Student类型的指针,即属于struct Person{...}类型的指针  			-----这里看不懂可以不看     
				//typedef struct Person{....}Student,*StudentNumber等价于typedef Student *StudentNumber  			-----这里看不懂可以不看
				
				//最终定义： StudentNumber xiaohong	等价于 struct Persion{...} *xiaohong;
				
				/*	typedef struct｛
								shortlevel;／*缓冲区“满”或“空”的程度*／
								unsignedflags;／*文件状态标志*／
								charfd;／*文件描述符*／
								unsignedcharhold;／*如无缓冲区不读取字符*／
								shortbsize;／*缓冲区的大小*／
								unsignedchar*buffer;/ *数据缓冲区的位置* /
								unsignedchar*curp;/ *指针，当前的指向* /
								unsignedistemp;/ *临时文件，指示器* /
								-15-shorttoken;/ *用于有效性检查* /
						｝FILE； 
				*/
				// FILE *file这里者属于这个匿名结构体的指针，他使用了FILE替代（声明）了他 
				
				
			//每个被使用的文件都会在内存中开闭一个FILE结构体类型的区
			//FILE *file声明了一个指针，指向 FILE的指针 
			//FILE fil[5] 声明了一个文件结构体数组（类似int a[],char s[]之类） 
			//File 变量 声明一个文件结构体变量 
	
	//链表 
	printf("\n\n\n链表与结构体（点名器）\n");
	struct student xiaoling,xiaohong,xiaowang,*oneNumber,*dianMingQi;
	xiaoling.num=101;xiaoling.score=77;
	xiaohong.num=102;xiaohong.score=88;
	xiaowang.num=103;xiaowang.score=99;
	//oneNumber称头指针
	oneNumber=&xiaoling;
	xiaoling.next=&xiaohong;
	xiaohong.next=&xiaowang;
	xiaowang.next=NULL;
	dianMingQi=oneNumber;
	//注：当结构体实例为指针时，将使用  指针名 ->结构体内容 
	do{
		printf("num=%d\tscore=%d\n",dianMingQi->num,dianMingQi->score);
		dianMingQi=dianMingQi->next;
	}while(dianMingQi!=NULL);
	
	//文件 
	printf("\n\n\n文件与结构体（读取in.txt）\n");
		FILE *fp;
	fp=fopen("in.txt","r");
	assert(fp!=NULL);
	stu uu[128];
	int ii=0;
	FILE *wp;
	wp=fopen("out.txt","w");
	assert(wp!=NULL);
	
	while(fscanf(fp,"%s%d%s%d",uu[ii].name,&uu[ii].num,uu[ii].sex,&uu[ii].score)!=EOF)
	{
		printf("\t%d \t%s \t%s \t%d \n",uu[ii].num,uu[ii].name,uu[ii].sex,uu[ii].score);
		fprintf(wp,"\t%s \t%d \t%s \t%d \n",uu[ii].name,uu[ii].num,uu[ii].sex,uu[ii].score);
		ii++;
	}
	fclose(fp);
	
	fclose(wp);
	
	/*
			文件操作 
					fopen()				打开文件 
					fclose()			关闭文件 
					fseek()				改变文件指针的位置 
					Rewind()			使文件位置指针重新置于文件开头 
					Ftell()				返回文件指针当前值 
			文件状态
					feof()				判断是否到达文件末尾，是返回为真				
					Ferror()			若对文件操作出错，返回值为真 
					Clearerr()			使上面两项函数值至为0   feof()    Ferror()
			文件读写
					fgetc(),getc()		从指定文件取得一个字符
					fputc(),putc()		把字符输出到指定文件
					fgets()				从指定文件读取字符串
					fputs()				把字符串输出到指定文件
					getw()				从指定文件读取一个字（int型）
					putw()				把一个字输出到指定文件
					fread()				从指定文件中读取数据项
					fwrite()			把数据项写到指定文件中
					fscanf()			从指定文件按格式输入数据
					fprintf()			按指定格式将数据写到指定文件中
	*/ 
	//注:其中文件路径为相对路径，所以需要读取的最好先将文件存储在于改程序文件的相同目录下 
	
	//枚举
			//1、枚举类型——指将变量的值一一列举出来，变量的值只限于列举出来的值的范围内的一个。
			//2、声明枚举类型：enum枚举类型名称｛枚举常量列表｝；
			//3、声明枚举变量：enum枚举类型名称枚举类型变量； 
			//枚举是一种数据类型 
		//枚举的使用与介绍

printf("\n\n\n测试枚举\n");
//声明的方法一
enum Color{
	Red,Yello=6,Blue,Black,White=3,Green
}; 
enum Color Cone;
enum Color Ctwo;
enum Color Cx,Cy;
//其中Cone,Ctwo,Cx,Cy全属于enum Color枚举型 
				//(1) 枚举型是一个集合，集合中的元素(枚举成员)是一些命名的整型常量，元素之间用逗号,隔开。
				
				//(2) Color是一个标识符，可以看成这个集合的名字，是一个可选项，即是可有可无的项。
				
				//(3) 第一个枚举成员的默认值为整型的0，后续枚举成员的值在前一个成员上加1。
				
				//(4) 可以人为设定枚举成员的值，从而自定义某个范围内的整数。
				
				//(5) 枚举型是预处理指令#define的替代。
				
				//(6) 类型定义以分号;结束。

			/*
			
						枚举类型的定义形式为：
							enum typeName{ valueName1, valueName2, valueName3, ...... };
							enum是一个新的关键字，专门用来定义枚举类型，这也是它在C语言中的唯一用途；typeName是枚举类型的名字；
							valueName1, valueName2, valueName3, ......是每个值对应的名字的列表。注意最后的;不能少。
							例如，列出一个星期有几天：
							enum week{ Mon, Tues, Wed, Thurs, Fri, Sat, Sun };
							可以看到，我们仅仅给出了名字，却没有给出名字对应的值，这是因为枚举值默认从 0 开始，往后逐个加 1（递增）；
							也就是说，week 中的 Mon、Tues ...... Sun 对应的值分别为 0、1 ...... 6。
							我们也可以给每个名字都指定一个值：
							enum week{ Mon = 1, Tues = 2, Wed = 3, Thurs = 4, Fri = 5, Sat = 6, Sun = 7 };
							更为简单的方法是只给第一个名字指定值：
							enum week{ Mon = 1, Tues, Wed, Thurs, Fri, Sat, Sun };
							这样枚举值就从 1 开始递增，跟上面的写法是等效的。
							枚举是一种类型，通过它可以定义枚举变量：
							enum week a, b, c;
							也可以在定义枚举类型的同时定义变量：
							enum week{ Mon = 1, Tues, Wed, Thurs, Fri, Sat, Sun } a, b, c;
							有了枚举变量，就可以把列表中的值赋给它：
							enum week{ Mon = 1, Tues, Wed, Thurs, Fri, Sat, Sun };
							enum week a = Mon, b = Wed, c = Sat;
							或者：
							enum week{ Mon = 1, Tues, Wed, Thurs, Fri, Sat, Sun } a = Mon, b = Wed, c = Sat
							
							
			*/

		/*
			enum Color{
				Red,Yello=6,Blue,Black,White=3,Green
			}; 
			enum Color Cone;
			enum Color Ctwo;
			enum Color Cx,Cy;
		*/
Cx= Red;
printf("\nCx= Red:%d\n",Cx);//输出0 
Cx=Yello;
printf("\nCx= Yello:%d\n",Cx);//输出6
Cx=Blue;
printf("\nCx= Blue:%d\n",Cx);//输出7
Cx=Black;
printf("\nCx= Black:%d\n",Cx);//输出8
Cx=White;
printf("\nCx= White:%d\n",Cx);//输出3
Cx=Green;
printf("\nCx= Green:%d\n",Cx);//输出4
printf("\n\n请输入上面对应的值，调用switch-case:\n");
scanf("%d",&Cy);
switch(Cy){
	case Red:puts("Red");break;
	case Yello:puts("Yello");break;
	case Blue:puts("Blue");break;
	case Black:puts("Black");break;
	case White:puts("White");break;
	case Green:puts("Green");break;
}

				
	
}

自己写的有点累了，其中省略了不少知识点，好比整数与字符的互换、强制转型，各类的排序法..，望大家体谅。