C Primer Plus 第六版源码

C5/P1/c1-1.c

@@ -1,7 +1,7 @@
-#include <stdio.h>                           // 这是编译预处理指令
-int main( )                                  // 定义主函数 
-{                                            // 函数开始的标志 
- printf ("This is a C program.\n");          // 输出所指定的一行信息 
- return 0;                                   // 函数执行完毕时返回函数值0
+#include <stdio.h>                           // 杩欐槸缂栬瘧棰勫�鐞嗘寚浠�
+int main( )                                  // 瀹氫箟涓诲嚱鏁� 
+{                                            // 鍑芥暟寮€濮嬬殑鏍囧織 
+ printf ("This is a C program.\n");          // 杈撳嚭鎵€鎸囧畾鐨勪竴琛屼俊鎭� 
+ return 0;                                   // 鍑芥暟鎵ц�瀹屾瘯鏃惰繑鍥炲嚱鏁板€�0
 }   
 

C5/P1/c1-2.c

@@ -1,13 +1,13 @@
-#include <stdio.h>                      // 这是编译预处理命令 
-int main( )                             // 定义主函数
-{                                       // 函数开始 
-  int a,b,sum;                          // 本行是程序的声明部分，定义a、b、sum为整型变量
-  a = 123;                              // 对变量a赋值    
-  b = 456;                              // 对变量b赋值 
-  sum = a + b;                          // 进行a+b 的运算，并把结果存放在变量sum中
-  printf("sum is %d\n",sum);            // 输出结果 
-  return 0;                             // 使函数返回值为0
-}                                       // 函数结束 
+#include <stdio.h>                      // 杩欐槸缂栬瘧棰勫�鐞嗗懡浠� 
+int main( )                             // 瀹氫箟涓诲嚱鏁�
+{                                       // 鍑芥暟寮€濮� 
+  int a,b,sum;                          // 鏈��鏄�▼搴忕殑澹版槑閮ㄥ垎锛屽畾涔塧銆乥銆乻um涓烘暣鍨嬪彉閲�
+  a = 123;                              // 瀵瑰彉閲廰璧嬪€�    
+  b = 456;                              // 瀵瑰彉閲廱璧嬪€� 
+  sum = a + b;                          // 杩涜�a+b 鐨勮繍绠楋紝骞舵妸缁撴灉瀛樻斁鍦ㄥ彉閲弒um涓�
+  printf("sum is %d\n",sum);            // 杈撳嚭缁撴灉 
+  return 0;                             // 浣垮嚱鏁拌繑鍥炲€间负0
+}                                       // 鍑芥暟缁撴潫 
 
   
 

C5/P1/c1-3.c

@@ -1,18 +1,18 @@
 #include <stdio.h>
-int main( )                          // 定义主函数
-{                                    // 主函数体开始
- int max(int x,int y);               // 对被调用函数max的声明 
- int a,b,c;                          // 定义变量a，b，c
- scanf("%d,%d",&a,&b);               // 输入变量a和b的值
- c = max(a,b);                       // 调用max函数，将得到的值赋给c 
- printf("max=%d\n",c);               // 输出c的值
- return 0;                           // 返回函数值为0
+int main( )                          // 瀹氫箟涓诲嚱鏁�
+{                                    // 涓诲嚱鏁颁綋寮€濮�
+ int max(int x,int y);               // 瀵硅�璋冪敤鍑芥暟max鐨勫０鏄� 
+ int a,b,c;                          // 瀹氫箟鍙橀噺a锛宐锛宑
+ scanf("%d,%d",&a,&b);               // 杈撳叆鍙橀噺a鍜宐鐨勫€�
+ c = max(a,b);                       // 璋冪敤max鍑芥暟锛屽皢寰楀埌鐨勫€艰祴缁檆 
+ printf("max=%d\n",c);               // 杈撳嚭c鐨勫€�
+ return 0;                           // 杩斿洖鍑芥暟鍊间负0
 }
 
-int max(int x,int y)                 //定义max函数,函数值为整型, 形式参数x和y为整型 
+int max(int x,int y)                 //瀹氫箟max鍑芥暟,鍑芥暟鍊间负鏁村瀷, 褰㈠紡鍙傛暟x鍜寉涓烘暣鍨� 
 {
- int z;                              // max函数中的声明部分，定义本函数中用到的变量z为整型 
+ int z;                              // max鍑芥暟涓�殑澹版槑閮ㄥ垎锛屽畾涔夋湰鍑芥暟涓�敤鍒扮殑鍙橀噺z涓烘暣鍨� 
  if (x > y) z = x;
  else z = y;
- return(z);                          //将z的值返回，通过max带回到调用函数的位置
+ return(z);                          //灏唞鐨勫€艰繑鍥烇紝閫氳繃max甯﹀洖鍒拌皟鐢ㄥ嚱鏁扮殑浣嶇疆
 }

C5/P10/c10-1.c

@@ -3,24 +3,24 @@
 int main()
   {FILE *fp;
    char ch,filename[10];
-   printf("请输入所用的文件名：");
+   printf("璇疯緭鍏ユ墍鐢ㄧ殑鏂囦欢鍚嶏細");
    scanf("%s",filename);
-   if((fp=fopen(filename,"w"))==NULL)       // 打开输出文件并使fp指向此文件 
+   if((fp=fopen(filename,"w"))==NULL)       // 鎵撳紑杈撳嚭鏂囦欢骞朵娇fp鎸囧悜姝ゆ枃浠� 
 	  {
-       printf("无法打开此文件\n");          // 如果打开时出错，就输出"打不开"的信息  
-       exit(0);                             // 终止程序*/
+       printf("鏃犳硶鎵撳紑姝ゆ枃浠禱n");          // 濡傛灉鎵撳紑鏃跺嚭閿欙紝灏辫緭鍑�"鎵撲笉寮€"鐨勪俊鎭�  
+       exit(0);                             // 缁堟�绋嬪簭*/
        }
-   ch=getchar( );                           // 接收在执行scanf语句时最后输入的回车符  
-   printf("请输入一个准备存储到磁盘的字符串(以#结束)：");
-   ch=getchar( );                           // 接收从键盘输入的第一个字符 
-   while(ch!='#')                           // 当输入'#'时结束循环  
+   ch=getchar( );                           // 鎺ユ敹鍦ㄦ墽琛宻canf璇�彞鏃舵渶鍚庤緭鍏ョ殑鍥炶溅绗�  
+   printf("璇疯緭鍏ヤ竴涓�噯澶囧瓨鍌ㄥ埌纾佺洏鐨勫瓧绗︿覆(浠�#缁撴潫)锛�");
+   ch=getchar( );                           // 鎺ユ敹浠庨敭鐩樿緭鍏ョ殑绗�竴涓�瓧绗� 
+   while(ch!='#')                           // 褰撹緭鍏�'#'鏃剁粨鏉熷惊鐜�  
 	{
-	  fputc(ch,fp);                         // 向磁盘文件输出一个字符  
-      putchar(ch);                          // 将输出的字符显示在屏幕上  
-	  ch=getchar();                         // 再接收从键盘输入的一个字符  
+	  fputc(ch,fp);                         // 鍚戠�鐩樻枃浠惰緭鍑轰竴涓�瓧绗�  
+      putchar(ch);                          // 灏嗚緭鍑虹殑瀛楃�鏄剧ず鍦ㄥ睆骞曚笂  
+	  ch=getchar();                         // 鍐嶆帴鏀朵粠閿�洏杈撳叆鐨勪竴涓�瓧绗�  
 
 	 }
-   fclose(fp);                              // 关闭文件  
-   putchar(10);                             // 向屏幕输出一个换行符，换行符的ASCII代码为10 
+   fclose(fp);                              // 鍏抽棴鏂囦欢  
+   putchar(10);                             // 鍚戝睆骞曡緭鍑轰竴涓�崲琛岀�锛屾崲琛岀�鐨凙SCII浠ｇ爜涓�10 
    return 0;
   }

C5/P10/c10-2.c

@@ -2,28 +2,28 @@
 #include <stdlib.h>
 int main( )
   {FILE *in,*out;
-   char  ch,infile[10],outfile[10];     // 定义两个字符数组，分别存放两个文件名  
-   printf("输入读入文件的名字:");
-   scanf("%s",infile);                  // 输入一个输入文件的名字  
-   printf("输入输出文件的名字:");
-   scanf("%s",outfile);                 // 输入一个输出文件的名字  
-   if((in=fopen(infile,"r"))==NULL)     // 打开输入文件  
-      {printf("无法打开此文件\n");
+   char  ch,infile[10],outfile[10];     // 瀹氫箟涓や釜瀛楃�鏁扮粍锛屽垎鍒�瓨鏀句袱涓�枃浠跺悕  
+   printf("杈撳叆璇诲叆鏂囦欢鐨勫悕瀛�:");
+   scanf("%s",infile);                  // 杈撳叆涓€涓�緭鍏ユ枃浠剁殑鍚嶅瓧  
+   printf("杈撳叆杈撳嚭鏂囦欢鐨勫悕瀛�:");
+   scanf("%s",outfile);                 // 杈撳叆涓€涓�緭鍑烘枃浠剁殑鍚嶅瓧  
+   if((in=fopen(infile,"r"))==NULL)     // 鎵撳紑杈撳叆鏂囦欢  
+      {printf("鏃犳硶鎵撳紑姝ゆ枃浠禱n");
        exit(0);
       }
-   if((out=fopen(outfile,"w"))==NULL)   // 打开输出文件  
-     {printf("无法打开此文件\n");
+   if((out=fopen(outfile,"w"))==NULL)   // 鎵撳紑杈撳嚭鏂囦欢  
+     {printf("鏃犳硶鎵撳紑姝ゆ枃浠禱n");
       exit(0);
      }
-   ch=fgetc(in);                       //从输入文件读入一个字符，放在变量ch中
-   while(!feof(in))                    // 如果未遇到输入文件的结束标志  
-     {fputc(ch,out);                   // 将ch写到输出文件中  
-      putchar(ch);                     // 将ch显示在屏幕上  
-	  ch=fgetc(in);                    // 从输入文件读入一个字符，放在变量ch中 
+   ch=fgetc(in);                       //浠庤緭鍏ユ枃浠惰�鍏ヤ竴涓�瓧绗︼紝鏀惧湪鍙橀噺ch涓�
+   while(!feof(in))                    // 濡傛灉鏈�亣鍒拌緭鍏ユ枃浠剁殑缁撴潫鏍囧織  
+     {fputc(ch,out);                   // 灏哻h鍐欏埌杈撳嚭鏂囦欢涓�  
+      putchar(ch);                     // 灏哻h鏄剧ず鍦ㄥ睆骞曚笂  
+	  ch=fgetc(in);                    // 浠庤緭鍏ユ枃浠惰�鍏ヤ竴涓�瓧绗︼紝鏀惧湪鍙橀噺ch涓� 
      }
-   putchar(10);                        // 显示完全部字符后换行  
-   fclose(in);                         // 关闭输入文件  
-   fclose(out);                        // 关闭输出文件  
+   putchar(10);                        // 鏄剧ず瀹屽叏閮ㄥ瓧绗﹀悗鎹㈣�  
+   fclose(in);                         // 鍏抽棴杈撳叆鏂囦欢  
+   fclose(out);                        // 鍏抽棴杈撳嚭鏂囦欢  
    return 0;
   }
 

C5/P10/c10-3-1.c

@@ -3,13 +3,13 @@
 #include <string.h> 
 int main()
 {  FILE *fp;
-   char  str[3][10],temp[10];   // str是用来存放字符串的二维数组，temp是临时数组  
+   char  str[3][10],temp[10];   // str鏄�敤鏉ュ瓨鏀惧瓧绗︿覆鐨勪簩缁存暟缁勶紝temp鏄�复鏃舵暟缁�  
    int i,j,k,n=3;
-   printf("Enter strings:\n");    // 提示输入字符串 */
+   printf("Enter strings:\n");    // 鎻愮ず杈撳叆瀛楃�涓� */
    for(i=0;i<n;i++)         
-     gets(str[i]);              // 输入字符串
+     gets(str[i]);              // 杈撳叆瀛楃�涓�
    
-   for(i=0;i<n-1;i++)           // 用选择法对字符串排序  
+   for(i=0;i<n-1;i++)           // 鐢ㄩ€夋嫨娉曞�瀛楃�涓叉帓搴�  
      {k=i;
       for(j=i+1;j<n;j++)
 	    if(strcmp(str[k],str[j])>0) k=j;
@@ -19,15 +19,15 @@ int main()
 	     strcpy(str[k],temp);
         }
 	 }
-   if((fp=fopen("D:\\CC\\string.dat","w"))==NULL)     // 打开磁盘文件  
+   if((fp=fopen("D:\\CC\\string.dat","w"))==NULL)     // 鎵撳紑纾佺洏鏂囦欢  
         {
 	     printf("can't open file!\n");
 	     exit(0);
         }
    printf("\nThe new sequence:\n");
    for(i=0;i<n;i++)
-	  {fputs(str[i],fp);fputs("\n",fp);       // 撤号 
-	   printf("%s\n",str[i]);                 // 在屏幕上显示字符串  
+	  {fputs(str[i],fp);fputs("\n",fp);       // 鎾ゅ彿 
+	   printf("%s\n",str[i]);                 // 鍦ㄥ睆骞曚笂鏄剧ず瀛楃�涓�  
      }
    return 0;
 }

C5/P10/c10-3-2.c

@@ -4,7 +4,7 @@ int main()
 { FILE *fp;
    char  str[3][10];
    int i=0;
-   if((fp=fopen("D:\\CC\\string.dat","r"))==NULL)      // 注意文件名必须与前相同 
+   if((fp=fopen("D:\\CC\\string.dat","r"))==NULL)      // 娉ㄦ剰鏂囦欢鍚嶅繀椤讳笌鍓嶇浉鍚� 
      {printf("can't open file!\n");
 	  exit(0);
      }

C5/P10/c10-4-1.c

@@ -5,12 +5,12 @@ struct student_type
   int num;
   int age;
   char addr[15];
- }stud[SIZE];                // 定义全局结构体数组stud，包含10个学生数据  
+ }stud[SIZE];                // 瀹氫箟鍏ㄥ眬缁撴瀯浣撴暟缁剆tud锛屽寘鍚�10涓��鐢熸暟鎹�  
 
-void save( )                 // 定义函数save，向文件输出SIZE个学生的数据  
+void save( )                 // 瀹氫箟鍑芥暟save锛屽悜鏂囦欢杈撳嚭SIZE涓��鐢熺殑鏁版嵁  
   {FILE *fp;
    int i;
-   if((fp=fopen ("stu.dat","wb"))==NULL)    // 打开输出文件atu_list  
+   if((fp=fopen ("stu.dat","wb"))==NULL)    // 鎵撳紑杈撳嚭鏂囦欢atu_list  
       {printf("cannot open file\n");
        return;
       }
@@ -23,7 +23,7 @@ void save( )                 //
 int main()
   {int i;
    printf("Please enter data of students:\n");
-   for(i=0;i<SIZE;i++)           // 输入SIZE个学生的数据，存放在数组stud中  
+   for(i=0;i<SIZE;i++)           // 杈撳叆SIZE涓��鐢熺殑鏁版嵁锛屽瓨鏀惧湪鏁扮粍stud涓�  
      scanf("%s%d%d%s",stud[i].name,&stud[i].num,&stud[i].age,stud[i].addr);
    save( );
    return 0;

C5/P10/c10-4-2.c

@@ -11,16 +11,16 @@ struct student_type
 int main( )
   {int i;
    FILE *fp;
-   if((fp=fopen ("stu.dat","rb"))==NULL)        // 打开输入文件atu.dat  
+   if((fp=fopen ("stu.dat","rb"))==NULL)        // 鎵撳紑杈撳叆鏂囦欢atu.dat  
       {printf("cannot open file\n");
        exit(0) ;
       }
    for(i=0;i<SIZE;i++)
-     {fread (&stud[i],sizeof(struct student_type),1,fp);       // 从fp指向的文件读入一组数据  
+     {fread (&stud[i],sizeof(struct student_type),1,fp);       // 浠巉p鎸囧悜鐨勬枃浠惰�鍏ヤ竴缁勬暟鎹�  
       printf ("%-10s %4d %4d  %-15s\n",stud[i].name,stud[i].num,stud[i]. age,stud[i].addr);
-            // 在屏幕上输出这组数据 
+            // 鍦ㄥ睆骞曚笂杈撳嚭杩欑粍鏁版嵁 
      }
-   fclose (fp);                                  // 关闭文件"stu.dat" 
+   fclose (fp);                                  // 鍏抽棴鏂囦欢"stu.dat" 
    return 0;
   }
 

C5/P10/c10-4-3.c

@@ -5,17 +5,17 @@ struct student_type
   int num;
   int age;
   char addr[15];
- }stud[SIZE];                // 定义全局结构体数组stud，包含10个学生数据  
+ }stud[SIZE];                // 瀹氫箟鍏ㄥ眬缁撴瀯浣撴暟缁剆tud锛屽寘鍚�10涓��鐢熸暟鎹�  
 
 void load( )
   {FILE *fp;
    int i;
-   if((fp=fopen("stu_list","rb"))==NULL)     // 打开输入文件stu_list  
+   if((fp=fopen("stu_list","rb"))==NULL)     // 鎵撳紑杈撳叆鏂囦欢stu_list  
      {printf("cannot open infile\n");
       return;
      }
    for(i=0;i<SIZE;i++)
-     if(fread(&stud[i],sizeof(struct student_type),1,fp)!=1)  // 从stu_ list文件中读数据  
+     if(fread(&stud[i],sizeof(struct student_type),1,fp)!=1)  // 浠巗tu_ list鏂囦欢涓��鏁版嵁  
        {if(feof(fp)) 
 	     {fclose(fp); 
           return;
@@ -25,10 +25,10 @@ void load( )
    fclose (fp);
   }   
        
-void save( )                // 定义函数save，向文件输出SIZE个学生的数据  
+void save( )                // 瀹氫箟鍑芥暟save锛屽悜鏂囦欢杈撳嚭SIZE涓��鐢熺殑鏁版嵁  
   {FILE *fp;
    int i;
-   if((fp=fopen ("stu.dat","wb"))==NULL)    // 打开输出文件atu_list  
+   if((fp=fopen ("stu.dat","wb"))==NULL)    // 鎵撳紑杈撳嚭鏂囦欢atu_list  
       {printf("cannot open file\n");
        return;
       }

C5/P10/c10-5.c

@@ -1,12 +1,12 @@
 #include<stdio.h>
 int main()
   {FILE *fp1,*fp2;
-   fp1=fopen("file1.dat","r");              // 打开输入文件  
-   fp2=fopen("file2.dat","w");              // 打开输出文件  
-   while(!feof(fp1)) putchar(getc(fp1));    // 逐个读入字符并输出到屏幕  
-   putchar(10);                             // 输出一个换行 
-   rewind(fp1);                             // 使文件位置指示器返回文件头  
-   while(!feof(fp1)) putc(getc(fp1),fp2);   // 从文件头重新逐个读字符，输出到file2文件  
+   fp1=fopen("file1.dat","r");              // 鎵撳紑杈撳叆鏂囦欢  
+   fp2=fopen("file2.dat","w");              // 鎵撳紑杈撳嚭鏂囦欢  
+   while(!feof(fp1)) putchar(getc(fp1));    // 閫愪釜璇诲叆瀛楃�骞惰緭鍑哄埌灞忓箷  
+   putchar(10);                             // 杈撳嚭涓€涓�崲琛� 
+   rewind(fp1);                             // 浣挎枃浠朵綅缃�寚绀哄櫒杩斿洖鏂囦欢澶�  
+   while(!feof(fp1)) putc(getc(fp1),fp2);   // 浠庢枃浠跺ご閲嶆柊閫愪釜璇诲瓧绗︼紝杈撳嚭鍒癴ile2鏂囦欢  
    fclose(fp1);fclose(fp2);
    return 0;
   }

C5/P10/c10-6.c

@@ -1,6 +1,6 @@
 #include <stdlib.h>
 #include<stdio.h>
-struct student_type       // 学生数据类型  
+struct student_type       // 瀛︾敓鏁版嵁绫诲瀷  
  { char name[10];
    int num;
    int age;
@@ -10,14 +10,14 @@ struct student_type       // 学
 int main()
   { int i;
     FILE  *fp;         
-	if((fp=fopen("stu.dat","rb"))==NULL)   // 以只读方式打开二进制文件  
+	if((fp=fopen("stu.dat","rb"))==NULL)   // 浠ュ彧璇绘柟寮忔墦寮€浜岃繘鍒舵枃浠�  
       {printf("can not open file\n");
        exit(0);
       }
     for(i=0;i<10;i+=2)
-     {fseek(fp,i*sizeof(struct student_type),0);        // 移动位置指针 
-      fread(&stud[i], sizeof(struct student_type),1,fp);  // 读一个数据块到结构体变量 
-      printf("%-10s %4d %4d %-15s\n",stud[i].name,stud[i].num,stud[i].age,stud[i].addr); // 在屏幕输出 
+     {fseek(fp,i*sizeof(struct student_type),0);        // 绉诲姩浣嶇疆鎸囬拡 
+      fread(&stud[i], sizeof(struct student_type),1,fp);  // 璇讳竴涓�暟鎹�潡鍒扮粨鏋勪綋鍙橀噺 
+      printf("%-10s %4d %4d %-15s\n",stud[i].name,stud[i].num,stud[i].age,stud[i].addr); // 鍦ㄥ睆骞曡緭鍑� 
      }
     fclose(fp);
 	return 0;

C5/P2/c2-19.c

@@ -2,7 +2,7 @@
 int main( )
  {
   int sign=1;
-  double deno=2.0,sum=1.0,term;    // ¶¨Òådeno,sum,termΪ˫¾«¶È±äÁ¿ 
+  double deno=2.0,sum=1.0,term;    // 定义deno,sum,term为�精度�� 
   while (deno<=100)
   {
    sign=-sign;

C5/P3/c3-1.c

@@ -1,9 +1,9 @@
 #include <stdio.h>
 int main ( )
  {
-  float f,c;                      // 隅砱f睿c峈等儕僅腹萸倰曹講 
-  f=64.;                          // 硌隅f腔硉 
-  c=(5.0/9)*(f-32);               // 瞳蚚鼠宒數呾c腔硉  
-  printf("f=%f\nc=%f\n",f,c);     // 怀堤c腔硉 
+  float f,c;                      // 摰帋�f�稪銝箏�蝎曉漲瘚桃��见��� 
+  f=64.;                          // ���f���� 
+  c=(5.0/9)*(f-32);               // �拍鍂�砍�霈∠�c����  
+  printf("f=%f\nc=%f\n",f,c);     // 颲枏枂c���� 
   return 0;
  }

C5/P3/c3-10-2.c

@@ -2,9 +2,9 @@
 int main ( )
 {
   char c1,c2;
-  c1=getchar();                                        // 从键盘读入一个大写字符，赋给字符变量c1  
-  c2=c1+32;	                                           // 得到对应的小写字符的ASCII代码，放在字符变量c2中  	       
-  printf("大写字母：%c\n小写字母：%c\n",c1,c2);        // 输出c1,c2的值---大小写字符  
+  c1=getchar();                                        // 浠庨敭鐩樿�鍏ヤ竴涓�ぇ鍐欏瓧绗︼紝璧嬬粰瀛楃�鍙橀噺c1  
+  c2=c1+32;	                                           // 寰楀埌瀵瑰簲鐨勫皬鍐欏瓧绗︾殑ASCII浠ｇ爜锛屾斁鍦ㄥ瓧绗﹀彉閲廲2涓�  	       
+  printf("澶у啓瀛楁瘝锛�%c\n灏忓啓瀛楁瘝锛�%c\n",c1,c2);        // 杈撳嚭c1,c2鐨勫€�---澶у皬鍐欏瓧绗�  
   return 0;
  }
 

C5/P3/c3-10.c

@@ -2,9 +2,9 @@
 int main ( )
 {
   char c1,c2;
-  c1=getchar();                   // 从键盘读入一个字符，赋给字符变量c1  
-  c2=c1+32;	                      // 得到字符'a'的ASCII代码，放在字符变量c2中  	       
-  putchar(c2);                    // 输出c2的值，是一个字符  
+  c1=getchar();                   // 浠庨敭鐩樿�鍏ヤ竴涓�瓧绗︼紝璧嬬粰瀛楃�鍙橀噺c1  
+  c2=c1+32;	                      // 寰楀埌瀛楃�'a'鐨凙SCII浠ｇ爜锛屾斁鍦ㄥ瓧绗﹀彉閲廲2涓�  	       
+  putchar(c2);                    // 杈撳嚭c2鐨勫€硷紝鏄�竴涓�瓧绗�  
   putchar('\n'); 
   return 0;
  }

C5/P3/c3-3.c

@@ -2,9 +2,9 @@
 int main ( )
 {
   char c1,c2;
-  c1='A';                         // 将字符'A'的ASCII代码放到c1变量中
-  c2=c1+32;	                      // 得到字符'a'的ASCII代码，放在c2变量中 
-  printf("%c\n",c2);              // 输出c2的值，是一个字符
-  printf("%d\n",c2);              // 输出c2的值，是字符'a'的ASCII代码
+  c1='A';                         // 灏嗗瓧绗�'A'鐨凙SCII浠ｇ爜鏀惧埌c1鍙橀噺涓�
+  c2=c1+32;	                      // 寰楀埌瀛楃�'a'鐨凙SCII浠ｇ爜锛屾斁鍦╟2鍙橀噺涓� 
+  printf("%c\n",c2);              // 杈撳嚭c2鐨勫€硷紝鏄�竴涓�瓧绗�
+  printf("%d\n",c2);              // 杈撳嚭c2鐨勫€硷紝鏄�瓧绗�'a'鐨凙SCII浠ｇ爜
   return 0;
 }

C5/P3/c3-4.c

@@ -2,14 +2,14 @@
 #include <math.h>
 int main ( )
  {
-   double a,b,c,s,area;                       // ¶¨Ňĺ¸÷±äÁżŁ¬ľůÎŞdoubleĐÍ 
-   a=3.67;                                    // ¶Ô±ßł¤a¸łÖµ 
-   b=5.43;                                    // ¶Ô±ßł¤b¸łÖµ 
-   c=6.21;                                    // ¶Ô±ßł¤c¸łÖµ  
-   s=(a+b+c)/2;	                              // ĽĆËăs 
-   area=sqrt(s*(s-a)*(s-b)*(s-c));            // ĽĆËăarea 
-   printf("a=%f\tb=%f\t%f\n",a,b,c);          // ĘäłöČý±ßa,b,cµÄÖµ 
-   printf("area=%f\n",area);                  // ĘäłöĂć»ýareaµÄÖµ
+   double a,b,c,s,area;                       // 定义��量，均为double型 
+   a=3.67;                                    // 对边长a赋值 
+   b=5.43;                                    // 对边长b赋值 
+   c=6.21;                                    // 对边长c赋值  
+   s=(a+b+c)/2;	                              // 计算s 
+   area=sqrt(s*(s-a)*(s-b)*(s-c));            // 计算area 
+   printf("a=%f\tb=%f\t%f\n",a,b,c);          // 输出三边a,b,c的值 
+   printf("area=%f\n",area);                  // 输出面积area的值
    return 0;
  }  
 

C5/P3/c3-5.c

@@ -1,13 +1,13 @@
 #include <stdio.h>
-#include  <math.h>                                // 程序中要调用求平方根函数sqrt  
+#include  <math.h>                                // 绋嬪簭涓��璋冪敤姹傚钩鏂规牴鍑芥暟sqrt  
 int main ( ) 
- {double a,b,c,disc,x1,x2,p,q;                    // disc是判别式sqrt(b*b-4ac)  
-  scanf("%lf%lf%lf",&a,&b,&c);                    // 输入实型变量的值要用格式声明"%f"  
+ {double a,b,c,disc,x1,x2,p,q;                    // disc鏄�垽鍒�紡sqrt(b*b-4ac)  
+  scanf("%lf%lf%lf",&a,&b,&c);                    // 杈撳叆瀹炲瀷鍙橀噺鐨勫€艰�鐢ㄦ牸寮忓０鏄�"%f"  
   disc=b*b-4*a*c;
   p=-b/(2.0*a);
   q=sqrt(disc)/(2.0*a);
-  x1=p+q;x2=p-q;                                  // 求出方程的两个根  
-  printf("x1=%7.2f\nx2=%7.2f\n",x1,x2);           // 输出方程的两个根   
+  x1=p+q;x2=p-q;                                  // 姹傚嚭鏂圭▼鐨勪袱涓�牴  
+  printf("x1=%7.2f\nx2=%7.2f\n",x1,x2);           // 杈撳嚭鏂圭▼鐨勪袱涓�牴   
   return 0;
 }
 

C5/P3/c3-8-2.c

@@ -1,11 +1,11 @@
 #include <stdio.h>
 int main ( )
 {
-  int a=66,b=79,c=89;                    // 定义3个字符变量，并初始化   
-  putchar(a);                            // 向显示器输出字符B  
-  putchar(b);                            // 向显示器输出字符O  
-  putchar(c);                            // 向显示器输出字符Y  
-  putchar ('\n');                        // 向显示器输出一个换行符  
+  int a=66,b=79,c=89;                    // 瀹氫箟3涓�瓧绗﹀彉閲忥紝骞跺垵濮嬪寲   
+  putchar(a);                            // 鍚戞樉绀哄櫒杈撳嚭瀛楃�B  
+  putchar(b);                            // 鍚戞樉绀哄櫒杈撳嚭瀛楃�O  
+  putchar(c);                            // 鍚戞樉绀哄櫒杈撳嚭瀛楃�Y  
+  putchar ('\n');                        // 鍚戞樉绀哄櫒杈撳嚭涓€涓�崲琛岀�  
   return 0;
  }
 

C5/P3/c3-8.c

@@ -1,12 +1,12 @@
 #include <stdio.h>
 int main ( )
 {
-  char a,b,c;                            // 定义3个字符变量  
-  a='B';b='O';c='Y';                     // 给3个字符变量赋值     
-  putchar(a);                            // 向显示器输出字符B  
-  putchar(b);                            // 向显示器输出字符O  
-  putchar(c);                            // 向显示器输出字符Y  
-  putchar ('\n');                        // 向显示器输出一个换行符  
+  char a,b,c;                            // 瀹氫箟3涓�瓧绗﹀彉閲�  
+  a='B';b='O';c='Y';                     // 缁�3涓�瓧绗﹀彉閲忚祴鍊�     
+  putchar(a);                            // 鍚戞樉绀哄櫒杈撳嚭瀛楃�B  
+  putchar(b);                            // 鍚戞樉绀哄櫒杈撳嚭瀛楃�O  
+  putchar(c);                            // 鍚戞樉绀哄櫒杈撳嚭瀛楃�Y  
+  putchar ('\n');                        // 鍚戞樉绀哄櫒杈撳嚭涓€涓�崲琛岀�  
   return 0;
  }
 

C5/P3/c3-9-2.c

@@ -1,8 +1,8 @@
 #include <stdio.h>
 int main ( )                
-{ putchar(getchar());           // 将接收到的字符输出 
-  putchar(getchar());           // 将接收到的字符输出 
-  putchar(getchar());           // 将接收到的字符输出 
+{ putchar(getchar());           // 灏嗘帴鏀跺埌鐨勫瓧绗﹁緭鍑� 
+  putchar(getchar());           // 灏嗘帴鏀跺埌鐨勫瓧绗﹁緭鍑� 
+  putchar(getchar());           // 灏嗘帴鏀跺埌鐨勫瓧绗﹁緭鍑� 
   putchar('\n'); 
   return 0;
 }

C5/P3/c3-9.c

@@ -1,14 +1,14 @@
 
 #include <stdio.h>
 int  main ( )                
-{ char a,b,c;                   // 定义字符变量a,b,c  
-  a=getchar();                  // 从键盘输入一个字符，送给字符变量a  
-  b=getchar();                  // 从键盘输入一个字符，送给字符变量b  
-  c=getchar();                  // 从键盘输入一个字符，送给字符变量c  
-  putchar(a);                   // 将变量a的值输出  
-  putchar(b);                   // 将变量a的值输出   
-  putchar(c);                   // 将变量a的值输出  
-  putchar('\n');                // 换行  
+{ char a,b,c;                   // 瀹氫箟瀛楃�鍙橀噺a,b,c  
+  a=getchar();                  // 浠庨敭鐩樿緭鍏ヤ竴涓�瓧绗︼紝閫佺粰瀛楃�鍙橀噺a  
+  b=getchar();                  // 浠庨敭鐩樿緭鍏ヤ竴涓�瓧绗︼紝閫佺粰瀛楃�鍙橀噺b  
+  c=getchar();                  // 浠庨敭鐩樿緭鍏ヤ竴涓�瓧绗︼紝閫佺粰瀛楃�鍙橀噺c  
+  putchar(a);                   // 灏嗗彉閲廰鐨勫€艰緭鍑�  
+  putchar(b);                   // 灏嗗彉閲廰鐨勫€艰緭鍑�   
+  putchar(c);                   // 灏嗗彉閲廰鐨勫€艰緭鍑�  
+  putchar('\n');                // 鎹㈣�  
   return 0;
  }
 

C5/P4/c4-1.c

@@ -1,16 +1,16 @@
 #include <stdio.h>
-#include  <math.h>                         // 程序中要调用求平方根函数sqrt  
+#include  <math.h>                         // 绋嬪簭涓��璋冪敤姹傚钩鏂规牴鍑芥暟sqrt  
 int main ( ) 
- {double a,b,c,disc,x1,x2,p,q;             // disc是判别式sqrt(b*b-4ac)  
-  scanf("%lf%lf%lf",&a,&b,&c);             // 输入双精度浮点型变量的值要用格式声明"%lf"  
+ {double a,b,c,disc,x1,x2,p,q;             // disc鏄�垽鍒�紡sqrt(b*b-4ac)  
+  scanf("%lf%lf%lf",&a,&b,&c);             // 杈撳叆鍙岀簿搴︽诞鐐瑰瀷鍙橀噺鐨勫€艰�鐢ㄦ牸寮忓０鏄�"%lf"  
   disc=b*b-4*a*c;
   if (disc<0)
 	printf("This equation hav't real roots\n");
   else
     { p=-b/(2.0*a);
       q=sqrt(disc)/(2.0*a);
-      x1=p+q;x2=p-q;                        // 求出方程的两个根  
-      printf("real roots:\nx1=%10.6f\nx2=%10.6f\n",x1,x2);        // 输出方程的两个根
+      x1=p+q;x2=p-q;                        // 姹傚嚭鏂圭▼鐨勪袱涓�牴  
+      printf("real roots:\nx1=%10.6f\nx2=%10.6f\n",x1,x2);        // 杈撳嚭鏂圭▼鐨勪袱涓�牴
     }
   return 0;
 }

C5/P4/c4-10.c

@@ -3,29 +3,29 @@ int main()
 { 
    int c,s;
    float p,w,d,f;
-   printf("please enter price,weight,discount:");      // 提示输入的数据
-   scanf("%f,%f,%d",&p,&w,&s);                         // 输入单价、重量、距离 
+   printf("please enter price,weight,discount:");      // 鎻愮ず杈撳叆鐨勬暟鎹�
+   scanf("%f,%f,%d",&p,&w,&s);                         // 杈撳叆鍗曚环銆侀噸閲忋€佽窛绂� 
    if(s>=3000)  
-	   c=12;                                           // 3000km以上为同一折扣
+	   c=12;                                           // 3000km浠ヤ笂涓哄悓涓€鎶樻墸
    else        
-	   c=s/250;                                        // 3000km以下各段折扣不同，c的值不相同
+	   c=s/250;                                        // 3000km浠ヤ笅鍚勬�鎶樻墸涓嶅悓锛宑鐨勫€间笉鐩稿悓
    switch(c)
    {
-     case 0:   d=0; break;                             // c=0,代表250km以下,折扣d=0
-     case 1:   d=2; break;                             // c=1,代表250到500km以下,折扣d=2%
+     case 0:   d=0; break;                             // c=0,浠ｈ〃250km浠ヤ笅,鎶樻墸d=0
+     case 1:   d=2; break;                             // c=1,浠ｈ〃250鍒�500km浠ヤ笅,鎶樻墸d=2%
      case 2: 
-     case 3:   d=5; break;                             // c=2和3,代表500到1000km以下,折扣d=5% 
+     case 3:   d=5; break;                             // c=2鍜�3,浠ｈ〃500鍒�1000km浠ヤ笅,鎶樻墸d=5% 
      case 4: 
      case 5:      
      case 6:      
-     case 7:   d=8; break;                             // c=4-7,代表1000到2000km以下,折扣d=8%    
+     case 7:   d=8; break;                             // c=4-7,浠ｈ〃1000鍒�2000km浠ヤ笅,鎶樻墸d=8%    
      case 8:  
      case 9:    
      case 10:   
-     case 11:  d=10; break;                            // c=8-11,代表2000KM到3000km以下,折扣d=10% 
-     case 12:  d=15; break;                            // c12,代表3000km以上,折扣d=15% 
+     case 11:  d=10; break;                            // c=8-11,浠ｈ〃2000KM鍒�3000km浠ヤ笅,鎶樻墸d=10% 
+     case 12:  d=15; break;                            // c12,浠ｈ〃3000km浠ヤ笂,鎶樻墸d=15% 
    }
-   f = p * w * s * (1 - d / 100);                      // 计算总运费
-   printf("freight=%10.2f\n",f);                       // 输出总运费，取两位小数
+   f = p * w * s * (1 - d / 100);                      // 璁＄畻鎬昏繍璐�
+   printf("freight=%10.2f\n",f);                       // 杈撳嚭鎬昏繍璐癸紝鍙栦袱浣嶅皬鏁�
    return 0;
 }

C5/P4/c4-3.c

@@ -8,19 +8,19 @@ int main()
      t=a;
      a=b;
      b=t;
-   }                            // ʵÏÖaºÍbµÄ»¥»» 
+   }                            // 实现a和b的互� 
    if(a>c)
    {
      t=a;
      a=c;
      c=t;
-   }                           // ʵÏÖaºÍcµÄ»¥»» 
+   }                           // 实现a和c的互� 
    if(b>c)
    {
      t=b;
      b=c;
      c=t;
-   }                           // ʵÏÖbºÍcµÄ»¥»» 
+   }                           // 实现b和c的互� 
    printf("%5.2f,%5.2f,%5.2f\n",a,b,c);
    return 0;
 }

C5/P4/c4-6.c

@@ -6,9 +6,9 @@ int main()
   printf("Your score:");
   switch(grade)
   { 
-	 case 'A': printf("85ĄŤ100\n");break;
-     case 'B': printf("70ĄŤ84\n");break;
-     case 'C': printf("60ĄŤ69\n");break;
+	 case 'A': printf("85йН100\n");break;
+     case 'B': printf("70йН84\n");break;
+     case 'C': printf("60йН69\n");break;
      case 'D': printf("<60\n");break;   
      default:  printf("data error!\n");	 
   }

C5/P5/C5-11-1.c

@@ -1,14 +1,14 @@
 #include <stdio.h>
 int main()
  {char c;
-  c=getchar();                             // 输入一个字符给字符变量c
-  while(c!='\n')                           // 检查c的值是否换行符'\n'  
-    {if((c>='a' && c<='z') || (c>='A' && c<='Z'))     // c如果是字母
-       { if(c>='W' && c<='Z' || c>='w' && c<='z') c=c-22;   // 如果是26个字母中最后4个字母之一
-         else c=c+4;                      // 如果是前面22个字母之一，就使c加4，即变成其后第4个字母
+  c=getchar();                             // 杈撳叆涓€涓�瓧绗︾粰瀛楃�鍙橀噺c
+  while(c!='\n')                           // 妫€鏌�鐨勫€兼槸鍚︽崲琛岀�'\n'  
+    {if((c>='a' && c<='z') || (c>='A' && c<='Z'))     // c濡傛灉鏄�瓧姣�
+       { if(c>='W' && c<='Z' || c>='w' && c<='z') c=c-22;   // 濡傛灉鏄�26涓�瓧姣嶄腑鏈€鍚�4涓�瓧姣嶄箣涓€
+         else c=c+4;                      // 濡傛灉鏄�墠闈�22涓�瓧姣嶄箣涓€锛屽氨浣縞鍔�4锛屽嵆鍙樻垚鍏跺悗绗�4涓�瓧姣�
 	   }
-     printf("%c",c);                      // 输出己改变的字符
-     c=getchar();                         // 再输入下一个字符给字符变量c
+     printf("%c",c);                      // 杈撳嚭宸辨敼鍙樼殑瀛楃�
+     c=getchar();                         // 鍐嶈緭鍏ヤ笅涓€涓�瓧绗︾粰瀛楃�鍙橀噺c
     }
   printf("\n");
   return 0;

C5/P5/C5-11-2.c

@@ -1,13 +1,13 @@
 #include <stdio.h>
 int main()
  {char c;
-  while((c=getchar())!='\n')          // 输入一个字符给字符变量c并检查它c的值是否换行符  
-    {if((c>='A' && c<='Z') || (c>='a' && c<='z'))     // c如果是字母
-       { c=c+4;                       // 只要是字母，都先加4
-	     if(c>='Z' && c<='Z'+4 || c>'z')   // 如果是26个字母中最后4个字母之一
-		    c=c-26;                   // c的值改变为26个字母中最前面的4个字母中对应的字母        
+  while((c=getchar())!='\n')          // 杈撳叆涓€涓�瓧绗︾粰瀛楃�鍙橀噺c骞舵�鏌ュ畠c鐨勫€兼槸鍚︽崲琛岀�  
+    {if((c>='A' && c<='Z') || (c>='a' && c<='z'))     // c濡傛灉鏄�瓧姣�
+       { c=c+4;                       // 鍙��鏄�瓧姣嶏紝閮藉厛鍔�4
+	     if(c>='Z' && c<='Z'+4 || c>'z')   // 濡傛灉鏄�26涓�瓧姣嶄腑鏈€鍚�4涓�瓧姣嶄箣涓€
+		    c=c-26;                   // c鐨勫€兼敼鍙樹负26涓�瓧姣嶄腑鏈€鍓嶉潰鐨�4涓�瓧姣嶄腑瀵瑰簲鐨勫瓧姣�        
 	   }
-     printf("%c",c);                  // 输出己改变的字符
+     printf("%c",c);                  // 杈撳嚭宸辨敼鍙樼殑瀛楃�
     }
   printf("\n");
   return 0;

C5/P5/c5-1.c

@@ -1,13 +1,13 @@
 #include <stdio.h>
 int main()
 {
-  int i=1,sum=0;                      // 定义变量i的初值为1,sum的初值为0  
-  while (i<=100)                      // 当i>100，条件表达式i<=100的值为假，不执行循环体
-  {                                   // 循环体开始
-   sum=sum+i;                         // 第一次累加后，sum的值为1
-   i++;                               // 加完后，i的值加1，为下次累加作准备
-  }                                   // 循环体结束
-  printf("sum=%d\n",sum);             // 输出1+2+3…+100的累加和
+  int i=1,sum=0;                      // 瀹氫箟鍙橀噺i鐨勫垵鍊间负1,sum鐨勫垵鍊间负0  
+  while (i<=100)                      // 褰搃>100锛屾潯浠惰〃杈惧紡i<=100鐨勫€间负鍋囷紝涓嶆墽琛屽惊鐜�綋
+  {                                   // 寰�幆浣撳紑濮�
+   sum=sum+i;                         // 绗�竴娆＄疮鍔犲悗锛宻um鐨勫€间负1
+   i++;                               // 鍔犲畬鍚庯紝i鐨勫€煎姞1锛屼负涓嬫�绱�姞浣滃噯澶�
+  }                                   // 寰�幆浣撶粨鏉�
+  printf("sum=%d\n",sum);             // 杈撳嚭1+2+3鈥�+100鐨勭疮鍔犲拰
   return 0;
 }
 

C5/P5/c5-10.c

@@ -2,15 +2,15 @@
 # include <math.h>
 int main()
  {int n,k,i,m=0;
-  for(n=101;n<=200;n=n+2)                        // n从100变化到200，对每个n进行判定
+  for(n=101;n<=200;n=n+2)                        // n浠�100鍙樺寲鍒�200锛屽�姣忎釜n杩涜�鍒ゅ畾
     { k=sqrt(n);
       for (i=2;i<=k;i++)                          
-        if (n%i==0) break;                      // 如果n被i整除，终止内循环，此时i<k+1
-      if (i>=k+1)                               // 若j>=k+1，表示n未被整除
-		{printf("%d ",n);                       // 应确定n是素数
-	     m=m+1;                                 // m用来控制换行，一行内输出10个录素数
+        if (n%i==0) break;                      // 濡傛灉n琚玦鏁撮櫎锛岀粓姝㈠唴寰�幆锛屾�鏃秈<k+1
+      if (i>=k+1)                               // 鑻�>=k+1锛岃〃绀簄鏈��鏁撮櫎
+		{printf("%d ",n);                       // 搴旂‘瀹歯鏄�礌鏁�
+	     m=m+1;                                 // m鐢ㄦ潵鎺у埗鎹㈣�锛屼竴琛屽唴杈撳嚭10涓�綍绱犳暟
 		}     
-	  if(m%10==0) printf("\n");                 // m累计到10的倍数，换行
+	  if(m%10==0) printf("\n");                 // m绱��鍒�10鐨勫€嶆暟锛屾崲琛�
     }
   printf ("\n");
   return 0;

C5/P5/c5-6-1.c

@@ -4,7 +4,7 @@ int main()
   int i,j,n=0;
   for (i=1;i<=4;i++)                      
     for (j=1;j<=5;j++,n++)
-	{ if(n%5==0)printf("\n");     //控制在输出5个数据后换行
+	{ if(n%5==0)printf("\n");     //鎺у埗鍦ㄨ緭鍑�5涓�暟鎹�悗鎹㈣�
 	  printf("%d\t",i*j);
 	}  
   printf("\n");	

C5/P5/c5-6-2.c

@@ -4,8 +4,8 @@ int main()
   int i,j,n=0;
   for (i=1;i<=4;i++)                      
     for (j=1;j<=5;j++,n++)
-	{ if(n%5==0)  printf("\n");     //¿ØÖÆÔÚÊä³ö5¸öÊý¾Ýºó»»ÐÐ
-	  if (i==3 && j==1)  break;    //Óöµ½µÚ3ÐеÚ1ÁУ¬ÖÕÖ¹ÄÚÑ­»·
+	{ if(n%5==0)  printf("\n");     //控制在输出5个数���行
+	  if (i==3 && j==1)  break;    //�到第3行第1列，终止内循环
 	  printf("%d\t",i*j);
 	}  
   printf("\n");	

C5/P5/c5-6-3.c

@@ -4,8 +4,8 @@ int main()
   int i,j,n=0;
   for (i=1;i<=4;i++)                      
     for (j=1;j<=5;j++,n++)
-	{ if(n%5==0)printf("\n");         //控制在输出5个数据后换行
-	  if (i==3 && j==1) continue;    //遇到第3行第1列，提前结束执行本次内循环体
+	{ if(n%5==0)printf("\n");         //鎺у埗鍦ㄨ緭鍑�5涓�暟鎹�悗鎹㈣�
+	  if (i==3 && j==1) continue;    //閬囧埌绗�3琛岀�1鍒楋紝鎻愬墠缁撴潫鎵ц�鏈��鍐呭惊鐜�綋
 	  printf("%d\t",i*j);
 	}  
   printf("\n");	

C5/P5/c5-7-1.c

@@ -2,16 +2,16 @@
 #include<math.h>
 int main()
 {
-  int sign=1;                        // sign用来表示数值的符号
-  double pi=0.0,n=1.0,term=1.0;      // pi代表π,n代表分母，term代表当前项的值
-  while(fabs(term)>=1e-6)            // 检查当前项term的绝对值是否大于或等于10的(-6)次方
+  int sign=1;                        // sign鐢ㄦ潵琛ㄧず鏁板€肩殑绗﹀彿
+  double pi=0.0,n=1.0,term=1.0;      // pi浠ｈ〃蟺,n浠ｈ〃鍒嗘瘝锛宼erm浠ｈ〃褰撳墠椤圭殑鍊�
+  while(fabs(term)>=1e-6)            // 妫€鏌ュ綋鍓嶉」term鐨勭粷瀵瑰€兼槸鍚﹀ぇ浜庢垨绛変簬10鐨�(-6)娆℃柟
   {
-     pi=pi+term;                     // 把当前项term累加到pi中
-     n=n+2;                          // n+2是下一项的分母 
-     sign=-sign;                     // sign代表符号，下一项的符号与上一项符号相反
-     term=sign/n;                    // 求出下一项的值term
+     pi=pi+term;                     // 鎶婂綋鍓嶉」term绱�姞鍒皃i涓�
+     n=n+2;                          // n+2鏄�笅涓€椤圭殑鍒嗘瘝 
+     sign=-sign;                     // sign浠ｈ〃绗﹀彿锛屼笅涓€椤圭殑绗﹀彿涓庝笂涓€椤圭�鍙风浉鍙�
+     term=sign/n;                    // 姹傚嚭涓嬩竴椤圭殑鍊紅erm
   }
-  pi=pi*4;                           // 多项式的和pi乘以4，才是π的近似值
-  printf("pi=%10.8f\n",pi);          // 输出π的近似值  
+  pi=pi*4;                           // 澶氶」寮忕殑鍜宲i涔樹互4锛屾墠鏄�€鐨勮繎浼煎€�
+  printf("pi=%10.8f\n",pi);          // 杈撳嚭蟺鐨勮繎浼煎€�  
   return 0;
 }

C5/P5/c5-7-2.c

@@ -2,17 +2,17 @@
 #include<math.h>
 int main()
 {
-  int sign=1;                      // sign用来表示数值的符号
-  int t=0;                         // t 代表当前执行循环体的次数
-  double pi=0.0,n=1.0,term=1.0;    // pi代表π,n代表分母，term代表当前项的值
-  while(fabs(term)>=1e-6)          // 检查当前项term的绝对值是否大于或等于10的(-6)次方
-  {t=t+1;                          // 每进入一次循环体，t的值加1 
-   pi=pi+term;                     // 把当前项term累加到pi中
-   n=n+2;                          // n+2是下一项的分母 
-   sign=-sign;                     // sign代表符号，下一项的符号与上一项符号相反
-   term=sign/n;                    // 求出下一项的值term
+  int sign=1;                      // sign鐢ㄦ潵琛ㄧず鏁板€肩殑绗﹀彿
+  int t=0;                         // t 浠ｈ〃褰撳墠鎵ц�寰�幆浣撶殑娆℃暟
+  double pi=0.0,n=1.0,term=1.0;    // pi浠ｈ〃蟺,n浠ｈ〃鍒嗘瘝锛宼erm浠ｈ〃褰撳墠椤圭殑鍊�
+  while(fabs(term)>=1e-6)          // 妫€鏌ュ綋鍓嶉」term鐨勭粷瀵瑰€兼槸鍚﹀ぇ浜庢垨绛変簬10鐨�(-6)娆℃柟
+  {t=t+1;                          // 姣忚繘鍏ヤ竴娆″惊鐜�綋锛宼鐨勫€煎姞1 
+   pi=pi+term;                     // 鎶婂綋鍓嶉」term绱�姞鍒皃i涓�
+   n=n+2;                          // n+2鏄�笅涓€椤圭殑鍒嗘瘝 
+   sign=-sign;                     // sign浠ｈ〃绗﹀彿锛屼笅涓€椤圭殑绗﹀彿涓庝笂涓€椤圭�鍙风浉鍙�
+   term=sign/n;                    // 姹傚嚭涓嬩竴椤圭殑鍊紅erm
   }
-  pi=pi*4;                         // 多项式的和pi乘以4，才是π的近似值
-  printf("pi=%10.6f\n",pi);        // 输出π的近似值  
+  pi=pi*4;                         // 澶氶」寮忕殑鍜宲i涔樹互4锛屾墠鏄�€鐨勮繎浼煎€�
+  printf("pi=%10.6f\n",pi);        // 杈撳嚭蟺鐨勮繎浼煎€�  
   return 0;
 }

C5/P5/c5-8-2.c

@@ -3,12 +3,12 @@ int main()
  { 
   int f1=1,f2=1;
   int i;
-  for(i=1; i<=20; i++)                    // 每个循环中输出2个月的数据，故循环20次即可
+  for(i=1; i<=20; i++)                    // 姣忎釜寰�幆涓�緭鍑�2涓�湀鐨勬暟鎹�紝鏁呭惊鐜�20娆″嵆鍙�
     {
-	  printf("%12d %12d ",f1,f2);         // 输出己知的两个月的兔子数
+	  printf("%12d %12d ",f1,f2);         // 杈撳嚭宸辩煡鐨勪袱涓�湀鐨勫厰瀛愭暟
       if(i%2==0) printf("\n");
-      f1=f1+f2;                       // 计算出下一个月的兔子数，并存放在f1中
-      f2=f2+f1;                       // 计算出下两个月的兔子数，并存放在f2中
+      f1=f1+f2;                       // 璁＄畻鍑轰笅涓€涓�湀鐨勫厰瀛愭暟锛屽苟瀛樻斁鍦╢1涓�
+      f2=f2+f1;                       // 璁＄畻鍑轰笅涓や釜鏈堢殑鍏斿瓙鏁帮紝骞跺瓨鏀惧湪f2涓�
     }
   return 0;
 }

C5/P6/c6-3.c

@@ -7,9 +7,9 @@ int main()
    for (i=0;i<10;i++)                    
      scanf("%d",&a[i]);                  
    printf("\n");
-   for(j=0;j<9;j++)                        // 进行9次循环，实现9趟比较
-	for(i=0;i<9-j;i++)                     // 在每一趟中进行9-j次比较                  
-	  if (a[i]>a[i+1])                     // 相邻两个数比较 
+   for(j=0;j<9;j++)                        // 杩涜�9娆″惊鐜�紝瀹炵幇9瓒熸瘮杈�
+	for(i=0;i<9-j;i++)                     // 鍦ㄦ瘡涓€瓒熶腑杩涜�9-j娆℃瘮杈�                  
+	  if (a[i]>a[i+1])                     // 鐩搁偦涓や釜鏁版瘮杈� 
 	    {t=a[i];a[i]=a[i+1];a[i+1]=t;}
    printf("the sorted numbers :\n");
    for(i=0;i<10;i++)

C5/P6/c6-5.c

@@ -1,14 +1,14 @@
 #include <stdio.h>
 int main()
  {int i,j,row=0,colum=0,max;
-  int a[3][4]={{1,2,3,4},{9,8,7,6},{-10,10,-5,2}};   // 定义数组并赋初值
-  max=a[0][0];                                       // 先认为a[0][0]最大
+  int a[3][4]={{1,2,3,4},{9,8,7,6},{-10,10,-5,2}};   // 瀹氫箟鏁扮粍骞惰祴鍒濆€�
+  max=a[0][0];                                       // 鍏堣�涓篴[0][0]鏈€澶�
   for (i=0;i<=2;i++)
     for (j=0;j<=3;j++)
-       if (a[i][j]>max)                              // 如果某元素大于max，就取代max的原值
+       if (a[i][j]>max)                              // 濡傛灉鏌愬厓绱犲ぇ浜巑ax锛屽氨鍙栦唬max鐨勫師鍊�
           {max=a[i][j];
-           row=i;                                    // 记下此元素的行号
-           colum=j;                                  // 记下此元素的列号
+           row=i;                                    // 璁颁笅姝ゅ厓绱犵殑琛屽彿
+           colum=j;                                  // 璁颁笅姝ゅ厓绱犵殑鍒楀彿
           }
   printf("max=%d\nrow=%d\ncolum=%d\n",max,row,colum);
   return 0;

C5/P6/c6-8.c

@@ -4,13 +4,13 @@ int main()
   char string[81];
   int i,num=0,word=0;
   char c;
-  gets(string);                           // 输入一个字符串给字符数组string
-  for (i=0;(c=string[i])!='\0';i++)       // 只要字符不是'\0'就继续执行循环
-    if(c==' ') word=0;                    // 如果是空格字符，使word置0
-    else if(word==0)                      // 如果不是空格字符且word原值为0
-		{word=1;                          // 使word置1
-	     num++;                           // num累加1，表示增加一个单词
+  gets(string);                           // 杈撳叆涓€涓�瓧绗︿覆缁欏瓧绗︽暟缁剆tring
+  for (i=0;(c=string[i])!='\0';i++)       // 鍙��瀛楃�涓嶆槸'\0'灏辩户缁�墽琛屽惊鐜�
+    if(c==' ') word=0;                    // 濡傛灉鏄�┖鏍煎瓧绗︼紝浣縲ord缃�0
+    else if(word==0)                      // 濡傛灉涓嶆槸绌烘牸瀛楃�涓攚ord鍘熷€间负0
+		{word=1;                          // 浣縲ord缃�1
+	     num++;                           // num绱�姞1锛岃〃绀哄�鍔犱竴涓�崟璇�
 		}
-  printf("There are %d words in this line.\n",num);  //输出结果
+  printf("There are %d words in this line.\n",num);  //杈撳嚭缁撴灉
   return 0;
 }

C5/P6/c6-9.c

@@ -2,17 +2,17 @@
 #include<string.h>
 int main ( )
 {
-  char str[3][20];                 // 定义二维字符数组
-  char string[20];                 // 定义一维字符数组，作为交换字符串时的临时字符数组
+  char str[3][20];                 // 瀹氫箟浜岀淮瀛楃�鏁扮粍
+  char string[20];                 // 瀹氫箟涓€缁村瓧绗︽暟缁勶紝浣滀负浜ゆ崲瀛楃�涓叉椂鐨勪复鏃跺瓧绗︽暟缁�
   int i;
   for (i=0;i<3;i++)
-      gets (str[i]);                 // 读入3个字符串，分别给str[0],str[1],str[2]   
-  if (strcmp(str[0],str[1])>0)     // 若str[0]大于str[1]
-	  strcpy(string,str[0]);       // 把str[0]的字符串赋给字符数组string
-  else                             // 若str[0]小于等于str[1]
-	  strcpy(string,str[1]);       // 把str[1]的字符串赋给字符数组string 
-  if (strcmp(str[2],string)>0)     // 若str[2]大于string
-      strcpy(string,str[2]);       // 把str[2]的字符串赋给字符数组string     
-  printf("\nthe largest string is:\n%s\n",string);  // 输出string
+      gets (str[i]);                 // 璇诲叆3涓�瓧绗︿覆锛屽垎鍒�粰str[0],str[1],str[2]   
+  if (strcmp(str[0],str[1])>0)     // 鑻�tr[0]澶т簬str[1]
+	  strcpy(string,str[0]);       // 鎶妔tr[0]鐨勫瓧绗︿覆璧嬬粰瀛楃�鏁扮粍string
+  else                             // 鑻�tr[0]灏忎簬绛変簬str[1]
+	  strcpy(string,str[1]);       // 鎶妔tr[1]鐨勫瓧绗︿覆璧嬬粰瀛楃�鏁扮粍string 
+  if (strcmp(str[2],string)>0)     // 鑻�tr[2]澶т簬string
+      strcpy(string,str[2]);       // 鎶妔tr[2]鐨勫瓧绗︿覆璧嬬粰瀛楃�鏁扮粍string     
+  printf("\nthe largest string is:\n%s\n",string);  // 杈撳嚭string
   return 0;
 }

C5/P7/c7-10.c

@@ -1,22 +1,22 @@
 #include <stdio.h>
 int main()
-{ float average(float array[10]);           // 函数声明
+{ float average(float array[10]);           // 鍑芥暟澹版槑
   float score[10],aver;
   int i;
   printf("input 10 scores:\n");
   for(i=0;i<10;i++)
       scanf("%f",&score[i]);
   printf("\n");
-  aver=average(score);                     // 调用average函数
+  aver=average(score);                     // 璋冪敤average鍑芥暟
   printf("average score is %5.2f\n",aver);
   return 0;
 } 
 
-float average(float array[10])             // 定义average函数
+float average(float array[10])             // 瀹氫箟average鍑芥暟
   {int i;
    float aver,sum=array[0];
    for(i=1;i<10;i++)
-       sum=sum+array[i];                  // 累加学生成绩
+       sum=sum+array[i];                  // 绱�姞瀛︾敓鎴愮哗
    aver=sum/10;
    return(aver);
 }

C5/P7/c7-14.c

@@ -1,5 +1,5 @@
 #include <stdio.h>
-float Max=0,Min=0;                                       // 定义全局变量Max,Min
+float Max=0,Min=0;                                       // 瀹氫箟鍏ㄥ眬鍙橀噺Max,Min
 int main()
 { float average(float array[ ],int n);
   float ave,score[10];
@@ -12,7 +12,7 @@ int main()
   return 0;
  }
 
-float average(float array[ ],int n)                       // 定义函数，有一形参是数组
+float average(float array[ ],int n)                       // 瀹氫箟鍑芥暟锛屾湁涓€褰㈠弬鏄�暟缁�
 { int i;
   float aver,sum=array[0];
   Max=Min=array[0];

C5/P7/c7-15.c

@@ -1,16 +1,16 @@
 #include <stdio.h>
-int a=3,b=5;                     // a,b是全局变量
+int a=3,b=5;                     // a,b鏄�叏灞€鍙橀噺
 int main()
 {
-  int max(int a,int b);           // 函数声明。a,b是形参
-  int a=8;                        // a是局局部变量  
-  printf("max=%d\n",max(a,b));    // 变量a是函数中定义的局部变量a
+  int max(int a,int b);           // 鍑芥暟澹版槑銆俛,b鏄�舰鍙�
+  int a=8;                        // a鏄�眬灞€閮ㄥ彉閲�  
+  printf("max=%d\n",max(a,b));    // 鍙橀噺a鏄�嚱鏁颁腑瀹氫箟鐨勫眬閮ㄥ彉閲廰
   return 0;
 } 
 
-int max(int a,int b)               // a,b是函数形参        
+int max(int a,int b)               // a,b鏄�嚱鏁板舰鍙�        
 {
   int c;
-  c=a>b?a:b;                       // 把a和b中的大者存放在c中 
+  c=a>b?a:b;                       // 鎶奱鍜宐涓�殑澶ц€呭瓨鏀惧湪c涓� 
   return(c);
 }

C5/P7/c7-18.c

@@ -1,14 +1,14 @@
 #include <stdio.h>
 int main()
 { int max( );     
-  extern int A,B,C;                        // 把外部变量A,B,C的作用域扩展到从此处开始
+  extern int A,B,C;                        // 鎶婂�閮ㄥ彉閲廇,B,C鐨勪綔鐢ㄥ煙鎵╁睍鍒颁粠姝ゅ�寮€濮�
   printf("Please enter three integer numbers:");
   scanf("%d %d %d",&A,&B,&C);
   printf("max is %d\n",max());
   return 0;
 }
 
-int A ,B ,C;                     // 定义外部变量A,B,C      
+int A ,B ,C;                     // 瀹氫箟澶栭儴鍙橀噺A,B,C      
 
 int max( )    
 { int m;

C5/P7/c7-2.c

@@ -9,9 +9,9 @@ int main()
   return 0;
 }
 
-int max(int x,int y)               // 定义max函数
+int max(int x,int y)               // 瀹氫箟max鍑芥暟
 {
-  int z;                           // 定义临时变量
-  z=x>y?x:y;                       // 把x和y中大者赋给z
-  return(z);                       // 把z作为max函数的伦值带回main函数
+  int z;                           // 瀹氫箟涓存椂鍙橀噺
+  z=x>y?x:y;                       // 鎶妜鍜寉涓�ぇ鑰呰祴缁檢
+  return(z);                       // 鎶妟浣滀负max鍑芥暟鐨勪鸡鍊煎甫鍥瀖ain鍑芥暟
 }

C5/P7/c7-20-1.c

@@ -4,11 +4,11 @@ int main()
 { extern void enter_string(char str[]);
   extern void delete_string(char str[],char ch);
   extern void print_string(char str[]);
-    // 以上3行声明在本函数中将要调用的已在其他文件中定义的3个函数
+    // 浠ヤ笂3琛屽０鏄庡湪鏈�嚱鏁颁腑灏嗚�璋冪敤鐨勫凡鍦ㄥ叾浠栨枃浠朵腑瀹氫箟鐨�3涓�嚱鏁�
   char c,str[80];
-  enter_string(str);                 // 调用在其他文件中定义的enter_string函数
+  enter_string(str);                 // 璋冪敤鍦ㄥ叾浠栨枃浠朵腑瀹氫箟鐨別nter_string鍑芥暟
   scanf("%c",&c);
-  delete_string(str,c);               // 调用在其他文件中定义的delete_string函数 
-  print_string(str);                  // 调用在其他文件中定义的print_string函数     
+  delete_string(str,c);               // 璋冪敤鍦ㄥ叾浠栨枃浠朵腑瀹氫箟鐨刣elete_string鍑芥暟 
+  print_string(str);                  // 璋冪敤鍦ㄥ叾浠栨枃浠朵腑瀹氫箟鐨刾rint_string鍑芥暟     
   return 0;     
 }

C5/P7/c7-5-1.c

@@ -1,26 +1,26 @@
 #include <stdio.h>
 int main()
-{ int max4(int a,int b,int c,int d);             // 对max4的函数声明
+{ int max4(int a,int b,int c,int d);             // 瀵筸ax4鐨勫嚱鏁板０鏄�
   int a,b,c,d,max;
-  printf("Please enter 4 interger numbers:");    // 提示输入4个数
-  scanf("%d %d %d %d",&a,&b,&c,&d);              // 输入4个数
-  max=max4(a,b,c,d);                             // 调用max4函数，得到4个数中的最大者
-  printf("max=%d \n",max);                       // 输出4个数中的最大者  
+  printf("Please enter 4 interger numbers:");    // 鎻愮ず杈撳叆4涓�暟
+  scanf("%d %d %d %d",&a,&b,&c,&d);              // 杈撳叆4涓�暟
+  max=max4(a,b,c,d);                             // 璋冪敤max4鍑芥暟锛屽緱鍒�4涓�暟涓�殑鏈€澶ц€�
+  printf("max=%d \n",max);                       // 杈撳嚭4涓�暟涓�殑鏈€澶ц€�  
   return 0;
 } 
 
-int max4(int a,int b,int c,int d)   // 定义max4函数 
-{int max2(int a,int b);             // 对max2的函数声明
+int max4(int a,int b,int c,int d)   // 瀹氫箟max4鍑芥暟 
+{int max2(int a,int b);             // 瀵筸ax2鐨勫嚱鏁板０鏄�
  int m; 
- m=max2(a,b);                       // 调用max2函数，得到a和b两个数中的大者，放在m中
- m=max2(m,c);                       // 调用max2函数，得到a,b,c三个数中的大者，放在m中                         
- m=max2(m,d);                       // 调用max2函数，得到a,b,c,d四个数中的大者，放在m中           
- return(m);                         // 把m作为函数值带回main函数
+ m=max2(a,b);                       // 璋冪敤max2鍑芥暟锛屽緱鍒癮鍜宐涓や釜鏁颁腑鐨勫ぇ鑰咃紝鏀惧湪m涓�
+ m=max2(m,c);                       // 璋冪敤max2鍑芥暟锛屽緱鍒癮,b,c涓変釜鏁颁腑鐨勫ぇ鑰咃紝鏀惧湪m涓�                         
+ m=max2(m,d);                       // 璋冪敤max2鍑芥暟锛屽緱鍒癮,b,c,d鍥涗釜鏁颁腑鐨勫ぇ鑰咃紝鏀惧湪m涓�           
+ return(m);                         // 鎶妋浣滀负鍑芥暟鍊煎甫鍥瀖ain鍑芥暟
 }
 
-int max2(int a,int b)               // 定义max2函数 
+int max2(int a,int b)               // 瀹氫箟max2鍑芥暟 
 {if(a>=b)
-   return a;                        // 若a>=b，将a为函数返回值 
+   return a;                        // 鑻�>=b锛屽皢a涓哄嚱鏁拌繑鍥炲€� 
  else 
-   return b;                        // 若a<b，将b为函数返回值
+   return b;                        // 鑻�<b锛屽皢b涓哄嚱鏁拌繑鍥炲€�
 }

C5/P7/c7-5-3.c

@@ -11,7 +11,7 @@ void main()
 int max4(int a,int b,int c,int d) 
 { int max2(int a,int b);
   int m; 
-  m=max2(max2(max2(a,b),c),d);         /* 仔细分析此行 */
+  m=max2(max2(max2(a,b),c),d);         /* 脳脨脧赂路脰脦枚麓脣脨脨 */
   return(m);
 }
 

C5/P7/c7-6.c

@@ -1,16 +1,16 @@
 #include <stdio.h>
 int main()
 { int age(int n);
-  printf("NO.5,age:%d\n",age(5));  //输出第5人的年龄
+  printf("NO.5,age:%d\n",age(5));  //杈撳嚭绗�5浜虹殑骞撮緞
   return 0;
 } 
 
-int age(int n)                     //定义递归函数    
+int age(int n)                     //瀹氫箟閫掑綊鍑芥暟    
  {int c;                
-  if(n==1)                         // 如果n等于1
-    c=10;                          // 年龄为10
-  else                             // 如果n不等于1     
-    c=age(n-1)+2;                  // 年龄是前一人的年龄加2(如第4人年龄是第3人年龄加2)
-  return(c);                       // 返回年龄
+  if(n==1)                         // 濡傛灉n绛変簬1
+    c=10;                          // 骞撮緞涓�10
+  else                             // 濡傛灉n涓嶇瓑浜�1     
+    c=age(n-1)+2;                  // 骞撮緞鏄�墠涓€浜虹殑骞撮緞鍔�2(濡傜�4浜哄勾榫勬槸绗�3浜哄勾榫勫姞2)
+  return(c);                       // 杩斿洖骞撮緞
 }
 

C5/P7/c7-8-2.c

@@ -10,7 +10,7 @@ void main()
 
 int max4(int a,int b,int c,int d) 
 {int max2(int a,int b);
- return max2(max2(max2(a,b),c),d);         /* 仔细分析此行 */
+ return max2(max2(max2(a,b),c),d);         /* 脳脨脧赂路脰脦枚麓脣脨脨 */
   
 }
 

C5/P7/c7-8.c

@@ -1,7 +1,7 @@
 #include <stdio.h>
 int main()
 {
-  void hanoi(int n,char one,char two,char three);         // ¶Ôhanoiº¯ÊýµÄÉùÃ÷ 
+  void hanoi(int n,char one,char two,char three);         // 对hanoi函数的声明 
   int m;
   printf("input the number of diskes:");
   scanf("%d",&m);
@@ -10,10 +10,10 @@ int main()
   return 0;
 }
 
-void hanoi(int n,char one,char two,char three)          // ¶¨Òåhanoiº¯Êý  
-    // ½«n¸öÅÌ´Óone×ù½èÖútwo×ù,ÒƵ½three×ù 
+void hanoi(int n,char one,char two,char three)          // 定义hanoi函数  
+    // 将n个盘从one座借助two座,移到three座 
  {
-   void move(char x,char y);       // ¶Ômoveº¯ÊýµÄÉùÃ÷ 
+   void move(char x,char y);       // 对move函数的声明 
    if(n==1)
      move(one,three);
    else
@@ -24,7 +24,7 @@ void hanoi(int n,char one,char two,char three)          //
     }
  }
 
- void move(char x,char y)           //  ¶¨Òåmoveº¯Êý 
+ void move(char x,char y)           //  定义move函数 
  {
     printf("%c-->%c\n",x,y);
  }

C5/P7/c7-9.c

@@ -8,9 +8,9 @@ int main()
    printf("\n");
    for(i=1,m=a[0],n=0;i<10;i++)
    {                       
-	  if (max(m,a[i])>m)                 // 若max函数返回的值大于m                  
-	  {m=max(m,a[i]);                    // max函数返回的值取代m原值
-	   n=i;                              // 把此数组元素的序号记下来，放在n中
+	  if (max(m,a[i])>m)                 // 鑻�ax鍑芥暟杩斿洖鐨勫€煎ぇ浜巑                  
+	  {m=max(m,a[i]);                    // max鍑芥暟杩斿洖鐨勫€煎彇浠�鍘熷€�
+	   n=i;                              // 鎶婃�鏁扮粍鍏冪礌鐨勫簭鍙疯�涓嬫潵锛屾斁鍦╪涓�
 	  }
    }
     printf("The largest number is %d\nit is the %dth number.\n",m,n+1);

C5/P8/c8-1.c

@@ -1,10 +1,10 @@
 #include <stdio.h>
 int main()
-{ int a=100,b=10;                            // 定义整型变量a,b，并初始化
-  int *pointer_1, *pointer_2;                // 定义指向整型数据的指针变量pointer_1, pointer_2
-  pointer_1=&a;                              // 把变量a的地址赋给指针变量pointer_1
-  pointer_2=&b;                              // 把变量b的地址赋给指针变量pointer_2 
-  printf("a=%d,b=%d\n",a,b);                 // 输出变量a和b的值
+{ int a=100,b=10;                            // 瀹氫箟鏁村瀷鍙橀噺a,b锛屽苟鍒濆�鍖�
+  int *pointer_1, *pointer_2;                // 瀹氫箟鎸囧悜鏁村瀷鏁版嵁鐨勬寚閽堝彉閲弍ointer_1, pointer_2
+  pointer_1=&a;                              // 鎶婂彉閲廰鐨勫湴鍧€璧嬬粰鎸囬拡鍙橀噺pointer_1
+  pointer_2=&b;                              // 鎶婂彉閲廱鐨勫湴鍧€璧嬬粰鎸囬拡鍙橀噺pointer_2 
+  printf("a=%d,b=%d\n",a,b);                 // 杈撳嚭鍙橀噺a鍜宐鐨勫€�
   printf("*pointer_1=%d,*pointer_2=%d\n",*pointer_1,*pointer_2);     //
   return 0;
 }

C5/P8/c8-10.c

@@ -1,22 +1,22 @@
 #include <stdio.h>
 int main()
-{ void sort(int x[ ],int n);                       // sort函数声明
+{ void sort(int x[ ],int n);                       // sort鍑芥暟澹版槑
   int i,*p,a[10];
-  p=a;                                             // 指针变量p指向a[0]
+  p=a;                                             // 鎸囬拡鍙橀噺p鎸囧悜a[0]
   printf("please enter 10 integer numberes:");
   for(i=0;i<10;i++)
-    scanf("%d",p++);                               // 输入10个整数
-  p=a;                                             // 指针变量p重新指向a[0]
-  sort(p,10);                                      // 调用sort函数
+    scanf("%d",p++);                               // 杈撳叆10涓�暣鏁�
+  p=a;                                             // 鎸囬拡鍙橀噺p閲嶆柊鎸囧悜a[0]
+  sort(p,10);                                      // 璋冪敤sort鍑芥暟
   for(p=a,i=0;i<10;i++)
-    {printf("%d ",*p);                             // 输出排序后的10个数组元素
+    {printf("%d ",*p);                             // 杈撳嚭鎺掑簭鍚庣殑10涓�暟缁勫厓绱�
      p++;
     }
   printf("\n");
   return 0;
 }
 
-void sort(int x[],int n)                           // 定义sort函数，x是形参数组名 
+void sort(int x[],int n)                           // 瀹氫箟sort鍑芥暟锛寈鏄�舰鍙傛暟缁勫悕 
  {int i,j,k,t;
   for(i=0;i<n-1;i++)
     {k=i;

C5/P8/c8-11.c

@@ -1,15 +1,15 @@
 #include <stdio.h>
 int main()
 { int a[3][4]={1,3,5,7,9,11,13,15,17,19,21,23};
-  printf("%d,%d\n",a,*a);                      // 0ĐĐĘ×µŘÖ·şÍ0ĐĐ0ÁĐÔŞËصŘÖ·
-  printf("%d,%d\n",a[0],*(a+0));               // 0ĐĐ0ÁĐÔŞËصŘÖ·
-  printf("%d,%d\n",&a[0],&a[0][0]);            // 0ĐĐĘ×µŘÖ·şÍ0ĐĐ0ÁĐÔŞËصŘÖ·
-  printf("%d,%d\n",a[1],a+1);                  // 1ĐĐ0ÁĐÔŞËصŘÖ·şÍ1ĐĐĘ×µŘÖ·
-  printf("%d,%d\n",&a[1][0],*(a+1)+0);         // 1ĐĐ0ÁĐÔŞËصŘÖ·
-  printf("%d,%d\n",a[2],*(a+2));               // 2ĐĐ0ÁĐÔŞËصŘÖ·
-  printf("%d,%d\n",&a[2],a+2);                 // 2ĐĐĘ×µŘÖ·
-  printf("%d,%d\n",a[1][0],*(*(a+1)+0));       // 1ĐĐ0ÁĐÔŞËصÄÖµ
-  printf("%d,%d\n",*a[2],*(*(a+2)+0));         // 2ĐĐ0ÁĐÔŞËصÄÖµ
+  printf("%d,%d\n",a,*a);                      // 0行首地址和0行0��素地址
+  printf("%d,%d\n",a[0],*(a+0));               // 0行0��素地址
+  printf("%d,%d\n",&a[0],&a[0][0]);            // 0行首地址和0行0��素地址
+  printf("%d,%d\n",a[1],a+1);                  // 1行0��素地址和1行首地址
+  printf("%d,%d\n",&a[1][0],*(a+1)+0);         // 1行0��素地址
+  printf("%d,%d\n",a[2],*(a+2));               // 2行0��素地址
+  printf("%d,%d\n",&a[2],a+2);                 // 2行首地址
+  printf("%d,%d\n",a[1][0],*(*(a+1)+0));       // 1行0��素的值
+  printf("%d,%d\n",*a[2],*(*(a+2)+0));         // 2行0��素的值
   return 0;
 }
 

C5/P8/c8-13.c

@@ -1,10 +1,10 @@
 #include <stdio.h>
 int main()
  {int a[3][4]={1,3,5,7,9,11,13,15,17,19,21,23};
-  int (*p)[4],i,j;                           // Ö¸Õë±äÁ¿pÖ¸Ïò°üº¬4¸öÕûÐÍÔªËصÄһάÊý×é
-  p=a;                                       // pÖ¸Ïò¶þάÊý×éµÄ0ÐÐ
+  int (*p)[4],i,j;                           // 指针��p指�包�4个整型元素的一维数组
+  p=a;                                       // p指�二维数组的0行
   printf("please enter row and colum:");
-  scanf("%d,%d",&i,&j);                      // Ö¸¶¨ÔªËصÄÐÐÁÐ
-  printf("a[%d,%d]=%d\n",i,j,*(*(p+i)+j));   // Êä³öa[i][j]µÄÖµ
+  scanf("%d,%d",&i,&j);                      // 指定元素的行列
+  printf("a[%d,%d]=%d\n",i,j,*(*(p+i)+j));   // 输出a[i][j]的值
   return 0;
  }

C5/P8/c8-16.c

@@ -1,7 +1,7 @@
 #include <stdio.h>
 int main()
   {char string[]="I love China!";           
-   printf("%s\n",string);                    // 用%s输出strung，可以输出整个字符串
+   printf("%s\n",string);                    // 鐢�%s杈撳嚭strung锛屽彲浠ヨ緭鍑烘暣涓�瓧绗︿覆
    printf("%c\n",string[7]);
    return 0;
 }

C5/P8/c8-18.c

@@ -3,12 +3,12 @@ int main()
  {char a[ ]="I am a student.",b[20];
   int i;
   for(i=0;*(a+i)!='\0';i++)
-     *(b+i)=*(a+i);                  //将a[i]的值赋给b[i]
-  *(b+i)='\0';                       //在b数组的有效字符之后加'\n'
-  printf("string a is:%s\n",a);      //输出a数组中全部字符
+     *(b+i)=*(a+i);                  //灏哸[i]鐨勫€艰祴缁檅[i]
+  *(b+i)='\0';                       //鍦╞鏁扮粍鐨勬湁鏁堝瓧绗︿箣鍚庡姞'\n'
+  printf("string a is:%s\n",a);      //杈撳嚭a鏁扮粍涓�叏閮ㄥ瓧绗�
   printf("string b is:");
   for(i=0;b[i]!='\0';i++)
-    printf("%c",b[i]);               //逐个输出b数组中全部字符
+    printf("%c",b[i]);               //閫愪釜杈撳嚭b鏁扮粍涓�叏閮ㄥ瓧绗�
   printf("\n");
   return 0;
  }

C5/P8/c8-19.c

@@ -1,11 +1,11 @@
 #include <stdio.h>
 int main()
  {char a[]="I am a boy.",b[20],*p1,*p2;
-  p1=a;p2=b;                                   // p1,p2分别指向a数组和b数组中的第一个元素
+  p1=a;p2=b;                                   // p1,p2鍒嗗埆鎸囧悜a鏁扮粍鍜宐鏁扮粍涓�殑绗�竴涓�厓绱�
   for(;*p1!='\0';p1++,p2++)
-     *p2=*p1;                                  // 将p1所指向的元素的值赋给p2所指向的元素
-  *p2='\0';                                    // 在复制完全部有效字符后加'\0'
-  printf("string a is:%s\n",a);                // 输出a数组中的字符
-  printf("string b is:%s\n",b);                // 输出b数组中的字符
+     *p2=*p1;                                  // 灏唒1鎵€鎸囧悜鐨勫厓绱犵殑鍊艰祴缁檖2鎵€鎸囧悜鐨勫厓绱�
+  *p2='\0';                                    // 鍦ㄥ�鍒跺畬鍏ㄩ儴鏈夋晥瀛楃�鍚庡姞'\0'
+  printf("string a is:%s\n",a);                // 杈撳嚭a鏁扮粍涓�殑瀛楃�
+  printf("string b is:%s\n",b);                // 杈撳嚭b鏁扮粍涓�殑瀛楃�
   return 0;
 }

C5/P8/c8-2.c

@@ -2,12 +2,12 @@
 int main()
  { int *p1,*p2,*p,a,b;
    printf("please enter two integer numbers:");
-   scanf("%d,%d",&a,&b);                   // 输入两个整数
-   p1=&a;                                  // 使p1指向变量a
-   p2=&b;                                  // 使p2指向变量b 
-   if(a<b)                                 // 如果a<b
-     {p=p1;p1=p2;p2=p;}                    // 使p1与p2的值互换
-   printf("a=%d,b=%d\n",a,b);              // 输出a,b
-   printf("max=%d,min=%d\n",*p1,*p2);      // 输出p1和p2所指向的变量的值
+   scanf("%d,%d",&a,&b);                   // 杈撳叆涓や釜鏁存暟
+   p1=&a;                                  // 浣縫1鎸囧悜鍙橀噺a
+   p2=&b;                                  // 浣縫2鎸囧悜鍙橀噺b 
+   if(a<b)                                 // 濡傛灉a<b
+     {p=p1;p1=p2;p2=p;}                    // 浣縫1涓巔2鐨勫€间簰鎹�
+   printf("a=%d,b=%d\n",a,b);              // 杈撳嚭a,b
+   printf("max=%d,min=%d\n",*p1,*p2);      // 杈撳嚭p1鍜宲2鎵€鎸囧悜鐨勫彉閲忕殑鍊�
    return 0;
 }

C5/P8/c8-20-3.c

@@ -3,15 +3,15 @@ int main()
 {void copy_string(char *from, char *to);
  char *a="I am a teacher.";
  char b[]="You are a student.";
- char *p=b;                                             // 使指针变量p指向b数组首元素
- printf("string a=%s\nstring b=%s\n",a,b);              // 输出a串和b串
+ char *p=b;                                             // 浣挎寚閽堝彉閲弍鎸囧悜b鏁扮粍棣栧厓绱�
+ printf("string a=%s\nstring b=%s\n",a,b);              // 杈撳嚭a涓插拰b涓�
  printf("\ncopy string a to string b:\n");
- copy_string(a,p);                                      // 调用copy_string函数，实现复制
+ copy_string(a,p);                                      // 璋冪敤copy_string鍑芥暟锛屽疄鐜板�鍒�
  printf("string a=%s\nstring b=%s\n",a,b);  
  return 0;
 }
 
-void copy_string(char *from, char *to)                  // 定义函数，形参为字符指针变量
+void copy_string(char *from, char *to)                  // 瀹氫箟鍑芥暟锛屽舰鍙備负瀛楃�鎸囬拡鍙橀噺
 {  for(;*from!='\0';from++,to++)
       {*to=*from;}
    *to='\0';

C5/P8/c8-22-2.c

@@ -1,17 +1,17 @@
 #include <stdio.h>
 int main()
  {int max(int,int);
-  int (*p)(int,int);                           // 定义指向函数的指针变量p
+  int (*p)(int,int);                           // 瀹氫箟鎸囧悜鍑芥暟鐨勬寚閽堝彉閲弍
   int a,b,c;
-  p=max;                                       // 使p指向max函数
+  p=max;                                       // 浣縫鎸囧悜max鍑芥暟
   printf("please enter a and b:");
   scanf("%d,%d",&a,&b);
-  c=(*p)(a,b);                                 // 通过指针变量调用max函数
+  c=(*p)(a,b);                                 // 閫氳繃鎸囬拡鍙橀噺璋冪敤max鍑芥暟
   printf("a=%d\nb=%d\nmax=%d\n",a,b,c);
   return 0;
 }
 
-int max(int x,int y)                            // 定义max函数
+int max(int x,int y)                            // 瀹氫箟max鍑芥暟
   {int z;
    if(x>y)  z=x;
    else     z=y;

C5/P8/c8-25.c

@@ -1,21 +1,21 @@
 #include <stdio.h>
 int main()
- {float score[ ][4]={{60,70,80,90},{56,89,67,88},{34,78,90,66}};   //定义数组，存放成绩
-  float  *search(float (*pointer)[4],int n);                       // 函数声明
+ {float score[ ][4]={{60,70,80,90},{56,89,67,88},{34,78,90,66}};   //瀹氫箟鏁扮粍锛屽瓨鏀炬垚缁�
+  float  *search(float (*pointer)[4],int n);                       // 鍑芥暟澹版槑
   float  *p;
   int i,k;
   printf("enter the number of student:");
-  scanf("%d",&k);                                                  // 输入要找的学生的序号
+  scanf("%d",&k);                                                  // 杈撳叆瑕佹壘鐨勫�鐢熺殑搴忓彿
   printf("The scores of No.%d are:\n",k);
-  p=search(score,k);                                    //调用search函数，返回score[k][0]的地址
+  p=search(score,k);                                    //璋冪敤search鍑芥暟锛岃繑鍥瀞core[k][0]鐨勫湴鍧€
   for(i=0;i<4;i++)
-    printf("%5.2f\t",*(p+i));                           // 输出score[k][0]到score[k][3]的值
+    printf("%5.2f\t",*(p+i));                           // 杈撳嚭score[k][0]鍒皊core[k][3]鐨勫€�
   printf("\n");
   return 0;
 }
 
-float *search(float (*pointer)[4],int n)               // 定义函数，形参pointer是指向一维数组的指针变量
+float *search(float (*pointer)[4],int n)               // 瀹氫箟鍑芥暟锛屽舰鍙俻ointer鏄�寚鍚戜竴缁存暟缁勭殑鎸囬拡鍙橀噺
   {float *pt;
-   pt=*(pointer+n);                                    // pt的值是&score[k][0]
+   pt=*(pointer+n);                                    // pt鐨勫€兼槸&score[k][0]
    return(pt);
 }

C5/P8/c8-26.c

@@ -1,26 +1,26 @@
 #include <stdio.h>
 int main()
- {float score[ ][4]={{60,70,80,90},{56,89,67,88},{34,78,90,66}};   //定义数组，存放成绩
-  float  *search(float (*pointer)[4]);                      // 函数声明
+ {float score[ ][4]={{60,70,80,90},{56,89,67,88},{34,78,90,66}};   //瀹氫箟鏁扮粍锛屽瓨鏀炬垚缁�
+  float  *search(float (*pointer)[4]);                      // 鍑芥暟澹版槑
   float  *p;
   int i,j;
   for(i=0;i<3;i++)
-     {p=search(score+i);                                    //调用search函数,如有不及格返回score[i][0]的地址，否则返回NULL，
-      if(p==*(score+i))                                     //如果返回的是score[i][0]的地址
+     {p=search(score+i);                                    //璋冪敤search鍑芥暟,濡傛湁涓嶅強鏍艰繑鍥瀞core[i][0]鐨勫湴鍧€锛屽惁鍒欒繑鍥濶ULL锛�
+      if(p==*(score+i))                                     //濡傛灉杩斿洖鐨勬槸score[i][0]鐨勫湴鍧€
         {printf("No.%d score:",i);
 		 for(j=0;j<4;j++)
-            printf("%5.2f  ",*(p+j));                       // 输出score[i][0]到score[i][3]的值
+            printf("%5.2f  ",*(p+j));                       // 杈撳嚭score[i][0]鍒皊core[i][3]鐨勫€�
          printf("\n");
         } 
      }
   return 0;
 }
 
-float *search(float (*pointer)[4])                            // 定义函数，形参pointer是指向一维数组的指针变量
+float *search(float (*pointer)[4])                            // 瀹氫箟鍑芥暟锛屽舰鍙俻ointer鏄�寚鍚戜竴缁存暟缁勭殑鎸囬拡鍙橀噺
   {int i=0;
    float *pt;
-   pt=NULL;                                                   // 先使pt的值为NULL
+   pt=NULL;                                                   // 鍏堜娇pt鐨勫€间负NULL
    for(;i<4;i++)
-     if(*(*pointer+i)<60) pt=*pointer;                        // 如果有不及格课程，使pt指向score[i][0] 
+     if(*(*pointer+i)<60) pt=*pointer;                        // 濡傛灉鏈変笉鍙婃牸璇剧▼锛屼娇pt鎸囧悜score[i][0] 
    return(pt);
 }

C5/P8/c8-30.c

@@ -1,19 +1,19 @@
 #include <stdio.h>
-#include <stdlib.h>                     // 程序中用了malloc函数，应包含stdlib.h
+#include <stdlib.h>                     // 绋嬪簭涓�敤浜唌alloc鍑芥暟锛屽簲鍖呭惈stdlib.h
 int main()
-{ void check(int *);                    // 函数声明
-  int *p1,i;                            // p1是int型指针
-  p1=(int *)malloc(5*sizeof(int));     // 开辟动态自由内存区，先将地址转换成 int *型，然后放在p1中
+{ void check(int *);                    // 鍑芥暟澹版槑
+  int *p1,i;                            // p1鏄痠nt鍨嬫寚閽�
+  p1=(int *)malloc(5*sizeof(int));     // 寮€杈熷姩鎬佽嚜鐢卞唴瀛樺尯锛屽厛灏嗗湴鍧€杞�崲鎴� int *鍨嬶紝鐒跺悗鏀惧湪p1涓�
   for(i=0;i<5;i++) 
-     scanf("%d",p1+i);                  // 输入5个学生的成绩 
-  check(p1);                            // 调用check函数
+     scanf("%d",p1+i);                  // 杈撳叆5涓��鐢熺殑鎴愮哗 
+  check(p1);                            // 璋冪敤check鍑芥暟
   return 0;
 }
   
-void check(int *p)                      // 定义check函数，形参是int*指针
+void check(int *p)                      // 瀹氫箟check鍑芥暟锛屽舰鍙傛槸int*鎸囬拡
 { int i;
   printf("They are fail:");
   for(i=0;i<5;i++)
-   if (p[i]<60) printf("%d ",p[i]);     // 输出不合格的成绩 
+   if (p[i]<60) printf("%d ",p[i]);     // 杈撳嚭涓嶅悎鏍肩殑鎴愮哗 
   printf("\n");
 }  

C5/P8/c8-5.c

@@ -1,6 +1,6 @@
 #include <stdio.h>
 int main()
-{ void exchange(int *q1, int *q2, int *q3);    // 函数声明  
+{ void exchange(int *q1, int *q2, int *q3);    // 鍑芥暟澹版槑  
   int a,b,c,*p1,*p2,*p3;
   printf("please enter three numbers:");
   scanf("%d,%d,%d",&a,&b,&c);
@@ -10,16 +10,16 @@ int main()
   return 0;
 }
 
-void exchange(int *q1, int *q2, int *q3)       // 定义将3个变量的值交换的函数   
-{ void swap(int *pt1, int *pt2);               // 函数声明  
-  if(*q1<*q2) swap(q1,q2);                     // 如果a<b，交换a和b的值  
-  if(*q1<*q3) swap(q1,q3);                     // 如果a<c，交换a和c的值  
-  if(*q2<*q3) swap(q2,q3);                     // 如果b<c，交换b和c的值  
+void exchange(int *q1, int *q2, int *q3)       // 瀹氫箟灏�3涓�彉閲忕殑鍊间氦鎹㈢殑鍑芥暟   
+{ void swap(int *pt1, int *pt2);               // 鍑芥暟澹版槑  
+  if(*q1<*q2) swap(q1,q2);                     // 濡傛灉a<b锛屼氦鎹�鍜宐鐨勫€�  
+  if(*q1<*q3) swap(q1,q3);                     // 濡傛灉a<c锛屼氦鎹�鍜宑鐨勫€�  
+  if(*q2<*q3) swap(q2,q3);                     // 濡傛灉b<c锛屼氦鎹�鍜宑鐨勫€�  
 }        
 
-void swap(int *pt1, int *pt2)                  // 定义交换2个变量的值的函数      
+void swap(int *pt1, int *pt2)                  // 瀹氫箟浜ゆ崲2涓�彉閲忕殑鍊肩殑鍑芥暟      
 { int temp;
-  temp=*pt1;                                   // 换*pt1和*pt2变量的值  
+  temp=*pt1;                                   // 鎹�*pt1鍜�*pt2鍙橀噺鐨勫€�  
   *pt1=*pt2;
   *pt2=temp;
 }  

C5/P8/c8-6-2.c

@@ -6,7 +6,7 @@ int main()
   for(i=0;i<10;i++)
     scanf("%d",&a[i]);
   for(i=0;i<10;i++)
-    printf("%d ",*(a+i));       //通过故数组名和元素序号计算元素地址，再找到该元素
+    printf("%d ",*(a+i));       //閫氳繃鏁呮暟缁勫悕鍜屽厓绱犲簭鍙疯�绠楀厓绱犲湴鍧€锛屽啀鎵惧埌璇ュ厓绱�
   printf("\n");
   return 0;
  }

C5/P8/c8-6-3-2.c

@@ -6,7 +6,7 @@ int main()
   for(p=a;p<(a+10);p++)
     scanf("%d",p);
   for(p=a;p<(a+10);p++)
-    printf("%d ",*p);                             // 用指针指向当前的数组元素
+    printf("%d ",*p);                             // 鐢ㄦ寚閽堟寚鍚戝綋鍓嶇殑鏁扮粍鍏冪礌
   printf("\n");
   return 0;
 }

C5/P8/c8-6-3.c

@@ -6,7 +6,7 @@ int main()
   for(i=0;i<10;i++)
     scanf("%d",&a[i]);
   for(p=a;p<(a+10);p++)
-    printf("%d ",*p);                             // 用指针指向当前的数组元素
+    printf("%d ",*p);                             // 鐢ㄦ寚閽堟寚鍚戝綋鍓嶇殑鏁扮粍鍏冪礌
   printf("\n");
   return 0;
 }

C5/P8/c8-8-1.c

@@ -4,21 +4,21 @@ int main()
  int i,a[10]={3,7,9,11,0,6,7,5,4,2};
  printf("The original array:\n");
  for(i=0;i<10;i++)
-   printf("%d ",a[i]);                   // 输出未交换时数组各元素的值
+   printf("%d ",a[i]);                   // 杈撳嚭鏈�氦鎹㈡椂鏁扮粍鍚勫厓绱犵殑鍊�
  printf("\n");
- inv(a,10);                               // 调用inv函数，进行交换
+ inv(a,10);                               // 璋冪敤inv鍑芥暟锛岃繘琛屼氦鎹�
  printf("The array has been inverted:\n");
  for(i=0;i<10;i++)
-   printf("%d ",a[i]);                    //  输出交换后数组各元素的值
+   printf("%d ",a[i]);                    //  杈撳嚭浜ゆ崲鍚庢暟缁勫悇鍏冪礌鐨勫€�
  printf("\n");
  return 0;
 }
 
-void inv(int x[ ],int n)                  // 形参x是蚊数组名
+void inv(int x[ ],int n)                  // 褰㈠弬x鏄�殜鏁扮粍鍚�
  {int temp,i,j,m=(n-1)/2;
   for(i=0;i<=m;i++)
     {j=n-1-i;
-     temp=x[i];x[i]=x[j];x[j]=temp;       // 把x[i]和x[j]交换
+     temp=x[i];x[i]=x[j];x[j]=temp;       // 鎶妜[i]鍜寈[j]浜ゆ崲
 	}
   return;
  }

C5/P8/c8-8-2.c

@@ -14,11 +14,11 @@ int main()
  return 0;
 }
 
-void inv(int *x,int n)                   //ÐβÎxÊÇÖ¸Õë±äÁ¿       
+void inv(int *x,int n)                   //形�x是指针��       
  {int temp,*i,*j;
   i=x;j=x+n-1;
   for(;i<=j;i++,j--)
-  {temp=*i;*i=*j;*j=temp;}               //*iÓë*j½»»»
+  {temp=*i;*i=*j;*j=temp;}               //*i与*j交�
   return;
  }
 

C5/P8/c8-9-2.c

@@ -1,12 +1,12 @@
 #include <stdio.h>
 int  main()
-{void inv(int *x,int n);                  // inv函数声明
- int i,*arr;                              // 指针变量arr未指向数组元素
+{void inv(int *x,int n);                  // inv鍑芥暟澹版槑
+ int i,*arr;                              // 鎸囬拡鍙橀噺arr鏈�寚鍚戞暟缁勫厓绱�
  printf("The original array:\n");
  for(i=0;i<10;i++)
    scanf("%d",arr+i);                   
  printf("\n");
- inv(arr,10);                             // 调用inv函数，实参arr是指针变量，但无指向
+ inv(arr,10);                             // 璋冪敤inv鍑芥暟锛屽疄鍙俛rr鏄�寚閽堝彉閲忥紝浣嗘棤鎸囧悜
  printf("The array has been inverted:\n");
  for(i=0;i<10;i++)
    printf("%d ",*(arr+i));
@@ -14,7 +14,7 @@ int  main()
  return 0;
 }
 
-void inv(int *x,int n)                      // 定义inv函数，形参x是指针变量 
+void inv(int *x,int n)                      // 瀹氫箟inv鍑芥暟锛屽舰鍙倄鏄�寚閽堝彉閲� 
  {int *p,m,temp,*i,*j;
   m=(n-1)/2;
   i=x;j=x+n-1;p=x+m;

C5/P8/c8-9.c

@@ -1,13 +1,13 @@
 #include <stdio.h>
 int  main()
-{void inv(int *x,int n);                  // inv函数声明
- int i,arr[10],*p=arr;                    // 指针变量p指向arr[0]
+{void inv(int *x,int n);                  // inv鍑芥暟澹版槑
+ int i,arr[10],*p=arr;                    // 鎸囬拡鍙橀噺p鎸囧悜arr[0]
  printf("The original array:\n");
  for(i=0;i<10;i++,p++)
-   scanf("%d",p);                         // 输入arr数组的元素
+   scanf("%d",p);                         // 杈撳叆arr鏁扮粍鐨勫厓绱�
  printf("\n");
- p=arr;                                    // 指针变量p重新指向arr[0]
- inv(p,10);                                // 调用inv函数，实参p是指针变量
+ p=arr;                                    // 鎸囬拡鍙橀噺p閲嶆柊鎸囧悜arr[0]
+ inv(p,10);                                // 璋冪敤inv鍑芥暟锛屽疄鍙俻鏄�寚閽堝彉閲�
  printf("The array has been inverted:\n");
  for(p=arr;p<arr+10;p++)
    printf("%d ",*p);
@@ -15,7 +15,7 @@ int  main()
  return 0;
 }
 
-void inv(int *x,int n)                      // 定义inv函数，形参x是指针变量 
+void inv(int *x,int n)                      // 瀹氫箟inv鍑芥暟锛屽舰鍙倄鏄�寚閽堝彉閲� 
  {int temp,*i,*j;
   i=x;j=x+n-1;
   for(;i<=j;i++,j--)

C5/P9/c9-10-1.c

@@ -1,19 +1,19 @@
 #include <stdio.h>
 #include <malloc.h>
 #define LEN sizeof(struct student)
-struct student                               //声明结构体类型struct student
+struct student                               //澹版槑缁撴瀯浣撶被鍨媠truct student
   {long num;
    float score;
    struct student *next;
   };
-int n;                                       //全局变量n  
-void print(struct student *head)             //定义print函数 
- {struct student *p;                         //在函数中定义struct student类型的变量p
+int n;                                       //鍏ㄥ眬鍙橀噺n  
+void print(struct student *head)             //瀹氫箟print鍑芥暟 
+ {struct student *p;                         //鍦ㄥ嚱鏁颁腑瀹氫箟struct student绫诲瀷鐨勫彉閲弍
   printf("\nNow,These %d records are:\n",n);      
-  p=head;                                     //使p指向第一个结点
-  if(head!=NULL)                              //若不是空表
+  p=head;                                     //浣縫鎸囧悜绗�竴涓�粨鐐�
+  if(head!=NULL)                              //鑻ヤ笉鏄�┖琛�
     do
-     {printf("%ld %5.1f\n",p->num,p->score);   //输出一个结点中的学号与成绩
-      p=p->next;                               //p指向下一个结点
-     }while(p!=NULL);                          //当p不是“空地址”
+     {printf("%ld %5.1f\n",p->num,p->score);   //杈撳嚭涓€涓�粨鐐逛腑鐨勫�鍙蜂笌鎴愮哗
+      p=p->next;                               //p鎸囧悜涓嬩竴涓�粨鐐�
+     }while(p!=NULL);                          //褰損涓嶆槸鈥滅┖鍦板潃鈥�
  }

C5/P9/c9-2.c

@@ -1,12 +1,12 @@
 #include <stdio.h>
 int main()
- {struct student                      // 声明结构体类型struct student 
+ {struct student                      // 澹版槑缁撴瀯浣撶被鍨媠truct student 
    {int num;
     char name[20];
     float score;
-   }student1,student2;                 // 定义两个结构体变量seudent1,student2 
-  scanf("%d%s%f",&student1.num,student1.name, &student1.score);    //输入学生1敌数据
-  scanf("%d%s%f",&student2.num,student2.name, &student2.score);    //输入学生1敌数据
+   }student1,student2;                 // 瀹氫箟涓や釜缁撴瀯浣撳彉閲弒eudent1,student2 
+  scanf("%d%s%f",&student1.num,student1.name, &student1.score);    //杈撳叆瀛︾敓1鏁屾暟鎹�
+  scanf("%d%s%f",&student2.num,student2.name, &student2.score);    //杈撳叆瀛︾敓1鏁屾暟鎹�
   printf("The higher score is:\n");
   if (student1.score>student2.score)
      printf("%d  %s  %6.2f\n",student1.num,student1.name, student1.score);

C5/P9/c9-3.c

@@ -1,14 +1,14 @@
 #include <string.h>
 #include <stdio.h>
-struct person                               // 声明结构体类型struct person
-  {char name[20];                           // 候选人姓名
-   int count;                               // 候选人得票数 
-  }leader[3]={"Li",0,"Zhang",0,"Sun",0};    // 定义结构体数组并初始化
+struct person                               // 澹版槑缁撴瀯浣撶被鍨媠truct person
+  {char name[20];                           // 鍊欓€変汉濮撳悕
+   int count;                               // 鍊欓€変汉寰楃エ鏁� 
+  }leader[3]={"Li",0,"Zhang",0,"Sun",0};    // 瀹氫箟缁撴瀯浣撴暟缁勫苟鍒濆�鍖�
 int main()
   {int i,j;
-   char leader_name[20];                    // 定义字符数组 
+   char leader_name[20];                    // 瀹氫箟瀛楃�鏁扮粍 
    for (i=1;i<=10;i++)
-	 {scanf("%s",leader_name);              // 输入所选的候选人姓名  
+	 {scanf("%s",leader_name);              // 杈撳叆鎵€閫夌殑鍊欓€変汉濮撳悕  
       for(j=0;j<3;j++)
 	    if(strcmp(leader_name,leader[j].name)==0) leader[j].count++;
      }

C5/P9/c9-4.c

@@ -1,22 +1,22 @@
 #include <stdio.h>
-struct student                                       // 声明结构体类型struct student  
+struct student                                       // 澹版槑缁撴瀯浣撶被鍨媠truct student  
    {int num;
     char name[20];
     float score;
    };   
 int main()
   {struct student stu[5]={{10101,"Zhang",78},{10103,"Wang",98.5},{10106,"Li",86},
-          {10108,"Ling",73.5},{10110,"Fun",100}};    // 定义结倒构体数组并初始化 
-   struct student temp;                              //定义结构体变量temp，用作交换时的临时变量  
+          {10108,"Ling",73.5},{10110,"Fun",100}};    // 瀹氫箟缁撳€掓瀯浣撴暟缁勫苟鍒濆�鍖� 
+   struct student temp;                              //瀹氫箟缁撴瀯浣撳彉閲弔emp锛岀敤浣滀氦鎹㈡椂鐨勪复鏃跺彉閲�  
    const int n=5;
    int i,j,k;
    printf("The order is:\n");
    for(i=0;i<n-1;i++)
       {k=i;
        for(j=i+1;j<n;j++)
-         if(stu[j].score>stu[k].score)                // 进行成绩的比较   
+         if(stu[j].score>stu[k].score)                // 杩涜�鎴愮哗鐨勬瘮杈�   
      		k=j;
-      temp=stu[k];stu[k]=stu[i];stu[i]=temp;           // stu[k]和stu[i]元素互换  
+      temp=stu[k];stu[k]=stu[i];stu[i]=temp;           // stu[k]鍜宻tu[i]鍏冪礌浜掓崲  
 	  }
    for(i=0;i<n;i++)
      printf("%6d %8s %6.2f\n",stu[i].num,stu[i].name,stu[i].score);

C5/P9/c9-5.c

@@ -7,14 +7,14 @@ int main()
      char sex;
      float score;
    };
-   struct student stu_1;          // 定义struct student类型的变量stu_1 
-   struct student * p;            // 定义指向struct student 类型数据的指针变量ｐ 
-   p=&stu_1;                      // ｐ指向stu_1 
-   stu_1.num=10101;               // 对结构体变量的成员赋值 
+   struct student stu_1;          // 瀹氫箟struct student绫诲瀷鐨勫彉閲弒tu_1 
+   struct student * p;            // 瀹氫箟鎸囧悜struct student 绫诲瀷鏁版嵁鐨勬寚閽堝彉閲忥綈 
+   p=&stu_1;                      // 锝愭寚鍚憇tu_1 
+   stu_1.num=10101;               // 瀵圭粨鏋勪綋鍙橀噺鐨勬垚鍛樿祴鍊� 
    strcpy(stu_1.name,"Li Lin");
    stu_1.sex='M';
    stu_1.score=89.5;
-   printf("No.:%ld\nname:%s\nsex:%c\nscore:%5.1f\n",stu_1.num,stu_1.name,stu_1.sex,stu_1.score);           // 输出结果 
+   printf("No.:%ld\nname:%s\nsex:%c\nscore:%5.1f\n",stu_1.num,stu_1.name,stu_1.sex,stu_1.score);           // 杈撳嚭缁撴灉 
    printf("\nNo.:%ld\nname:%s\nsex:%c\nscore:%5.1f\n",(*p).num,(*p).name,(*p).sex, (*p).score);
    return 0;
   } 

C5/P9/c9-6.c

@@ -5,10 +5,10 @@ struct student
    char sex;
    int age;
   };
-struct student stu[3]={{10101,"Li Lin",'M',18},{10102,"Zhang Fun",'M',19},{10104,"Wang Min",'F',20}};              // 定义结构体数组并初始化 
+struct student stu[3]={{10101,"Li Lin",'M',18},{10102,"Zhang Fun",'M',19},{10104,"Wang Min",'F',20}};              // 瀹氫箟缁撴瀯浣撴暟缁勫苟鍒濆�鍖� 
 
 int main()
- {struct student *p;                                            //定义指向struct student结构体的数组 
+ {struct student *p;                                            //瀹氫箟鎸囧悜struct student缁撴瀯浣撶殑鏁扮粍 
    printf(" No.  Name                 sex age\n");
    for (p=stu;p<stu+3;p++)
      printf("%5d %-20s %2c %4d\n",p->num, p->name, p->sex, p->age);

C5/P9/c9-7.c

@@ -1,39 +1,39 @@
 #include <stdio.h>
-#define N 3                                     // 学生数为3  
-struct student                                  // 建立结构体类型struct student  
- {int num;                                      // 学号  
-  char name[20];                                // 姓名   
-  float score[3];                               // 3门课成绩  
-  float aver;                                   // 平均成绩  
+#define N 3                                     // 瀛︾敓鏁颁负3  
+struct student                                  // 寤虹珛缁撴瀯浣撶被鍨媠truct student  
+ {int num;                                      // 瀛﹀彿  
+  char name[20];                                // 濮撳悕   
+  float score[3];                               // 3闂ㄨ�鎴愮哗  
+  float aver;                                   // 骞冲潎鎴愮哗  
  };
 
 int main()
- {void input(struct student stu[]);             // 函数声明  
-  struct student max(struct student stu[]);     // 函数声明    
-  void print(struct student stu);               // 函数声明  
-  struct student stu[N],*p=stu;                 // 定义结构体数组和指针  
-  input(p);                                     // 调用input函数  
-  print(max(p));                                // 调用print函数,以max函数的返回值作为实参  
+ {void input(struct student stu[]);             // 鍑芥暟澹版槑  
+  struct student max(struct student stu[]);     // 鍑芥暟澹版槑    
+  void print(struct student stu);               // 鍑芥暟澹版槑  
+  struct student stu[N],*p=stu;                 // 瀹氫箟缁撴瀯浣撴暟缁勫拰鎸囬拡  
+  input(p);                                     // 璋冪敤input鍑芥暟  
+  print(max(p));                                // 璋冪敤print鍑芥暟,浠�ax鍑芥暟鐨勮繑鍥炲€间綔涓哄疄鍙�  
   return 0;
  }
 
-void input(struct student stu[])   // 定义input 函数  
+void input(struct student stu[])   // 瀹氫箟input 鍑芥暟  
   {int i;
-   printf("请输入各学生的信息：学号、姓名、三门课成绩:\n");
+   printf("璇疯緭鍏ュ悇瀛︾敓鐨勪俊鎭�細瀛﹀彿銆佸�鍚嶃€佷笁闂ㄨ�鎴愮哗:\n");
    for(i=0;i<N;i++)
-   {scanf("%d %s %f %f %f",&stu[i].num,stu[i].name,&stu[i].score[0],&stu[i].score[1],&stu[i].score[2]);   // 输入数据  
-    stu[i].aver=(stu[i].score[0]+stu[i].score[1]+stu[i].score[2])/3.0;                                    // 求各人平均成绩  
+   {scanf("%d %s %f %f %f",&stu[i].num,stu[i].name,&stu[i].score[0],&stu[i].score[1],&stu[i].score[2]);   // 杈撳叆鏁版嵁  
+    stu[i].aver=(stu[i].score[0]+stu[i].score[1]+stu[i].score[2])/3.0;                                    // 姹傚悇浜哄钩鍧囨垚缁�  
    }
   }
 
-struct student max(struct student stu[])          // 定义max 函数  
-{int i,m=0;                                       // 用m存放成绩最高的学生在数组中的序号  
+struct student max(struct student stu[])          // 瀹氫箟max 鍑芥暟  
+{int i,m=0;                                       // 鐢╩瀛樻斁鎴愮哗鏈€楂樼殑瀛︾敓鍦ㄦ暟缁勪腑鐨勫簭鍙�  
   for(i=0;i<N;i++)
-     if (stu[i].aver>stu[m].aver) m=i;            // 找出平均成绩最高的学生在数组中的序号    
-  return stu[m];                                  // 返回包含该生信息的结构体元素  
+     if (stu[i].aver>stu[m].aver) m=i;            // 鎵惧嚭骞冲潎鎴愮哗鏈€楂樼殑瀛︾敓鍦ㄦ暟缁勪腑鐨勫簭鍙�    
+  return stu[m];                                  // 杩斿洖鍖呭惈璇ョ敓淇℃伅鐨勭粨鏋勪綋鍏冪礌  
 }
 
-void print(struct student stud)                   // 定义print函数  
-  { printf("\n成绩最高的学生是:\n");
-	printf("学号:%d\n姓名:%s\n三门课成绩:%5.1f,%5.1f,%5.1f\n平均成绩:%6.2f\n",stud.num,stud.name,stud.score[0],stud.score[1],stud.score[2],stud.aver);
+void print(struct student stud)                   // 瀹氫箟print鍑芥暟  
+  { printf("\n鎴愮哗鏈€楂樼殑瀛︾敓鏄�:\n");
+	printf("瀛﹀彿:%d\n濮撳悕:%s\n涓夐棬璇炬垚缁�:%5.1f,%5.1f,%5.1f\n骞冲潎鎴愮哗:%6.2f\n",stud.num,stud.name,stud.score[0],stud.score[1],stud.score[2],stud.aver);
  }

C5/P9/c9-8.c

@@ -1,22 +1,22 @@
 #include <stdio.h>
-struct student                                  // 声明结构体类型struct student  
+struct student                                  // 澹版槑缁撴瀯浣撶被鍨媠truct student  
   {int num;
    float score;
    struct student *next;
   };
 int main()
-  {struct student a,b,c,*head,*p;               // 定义3个结构体变量作为链表的结点  
-   a. num=10101; a.score=89.5;                  // 对结点a的num和score成员赋值  
-   b. num=10103; b.score=90;                    // 对结点b的num和score成员赋值       
-   c. num=10107; c.score=85;                    // 对结点c的num和score成员赋值  
-   head=&a;                                     // 将结点a的起始地址赋给头指针head  
-   a.next=&b;                                   // 将结点b的起始地址赋给a结点的next成员  
-   b.next=&c;                                   // 将结点c的起始地址赋给a结点的next成员  
-   c.next=NULL;                                 // c结点的next成员不存放其他结点地址  
-   p=head;                                      // 使p也指向a结点  
+  {struct student a,b,c,*head,*p;               // 瀹氫箟3涓�粨鏋勪綋鍙橀噺浣滀负閾捐〃鐨勭粨鐐�  
+   a. num=10101; a.score=89.5;                  // 瀵圭粨鐐筧鐨刵um鍜宻core鎴愬憳璧嬪€�  
+   b. num=10103; b.score=90;                    // 瀵圭粨鐐筨鐨刵um鍜宻core鎴愬憳璧嬪€�       
+   c. num=10107; c.score=85;                    // 瀵圭粨鐐筩鐨刵um鍜宻core鎴愬憳璧嬪€�  
+   head=&a;                                     // 灏嗙粨鐐筧鐨勮捣濮嬪湴鍧€璧嬬粰澶存寚閽坔ead  
+   a.next=&b;                                   // 灏嗙粨鐐筨鐨勮捣濮嬪湴鍧€璧嬬粰a缁撶偣鐨刵ext鎴愬憳  
+   b.next=&c;                                   // 灏嗙粨鐐筩鐨勮捣濮嬪湴鍧€璧嬬粰a缁撶偣鐨刵ext鎴愬憳  
+   c.next=NULL;                                 // c缁撶偣鐨刵ext鎴愬憳涓嶅瓨鏀惧叾浠栫粨鐐瑰湴鍧€  
+   p=head;                                      // 浣縫涔熸寚鍚慳缁撶偣  
    do        
-     {printf("%ld %5.1f\n",p->num,p->score);    // 输出p指向的结点的数据  
-      p=p->next;                                // 使p指向下一结点  
-	 }while(p!=NULL);                           // 输出完c结点后p的值为NULL，循环终止  
+     {printf("%ld %5.1f\n",p->num,p->score);    // 杈撳嚭p鎸囧悜鐨勭粨鐐圭殑鏁版嵁  
+      p=p->next;                                // 浣縫鎸囧悜涓嬩竴缁撶偣  
+	 }while(p!=NULL);                           // 杈撳嚭瀹宑缁撶偣鍚巔鐨勫€间负NULL锛屽惊鐜�粓姝�  
    return 0;
   }

C5/P9/c9-9.c

@@ -29,7 +29,7 @@ struct student *creat(void)
 
 int main()
 { struct student *pt;
-  pt=creat();                                                // 函数返回链表第一个结点的地址 
-  printf("\nnum:%ld\nscore:%5.1f\n",pt->num,pt->score);      // 输出第一个结点的成员值
+  pt=creat();                                                // 鍑芥暟杩斿洖閾捐〃绗�竴涓�粨鐐圭殑鍦板潃 
+  printf("\nnum:%ld\nscore:%5.1f\n",pt->num,pt->score);      // 杈撳嚭绗�竴涓�粨鐐圭殑鎴愬憳鍊�
   return 0;
 };

CPrimerPlus6E/Ch01/inform.c

@@ -0,0 +1,7 @@
+#include <stdio.h>
+int main(void)
+{
+    printf("A .c is used to end a C program filename.\n");
+    
+    return 0;
+}

CPrimerPlus6E/Ch01/listing1.c

@@ -0,0 +1,11 @@
+#include <stdio.h>
+int main(void)
+{
+    int dogs;
+    
+    printf("How many dogs do you have?\n");
+    scanf("%d", &dogs);
+    printf("So you have %d dog(s)!\n", dogs);
+    
+    return 0;
+}

CPrimerPlus6E/Ch01/listing2.c

@@ -0,0 +1,7 @@
+#include <stdio.h>
+int main(void)
+{
+    printf("Concrete contains gravel and cement.\n");
+    
+    return 0;
+}

CPrimerPlus6E/Ch02/fathm_ft.c

@@ -0,0 +1,14 @@
+// fathm_ft.c -- converts 2 fathoms to feet
+
+#include <stdio.h>
+int main(void)
+{
+    int feet, fathoms;
+    
+    fathoms = 2;
+    feet = 6 * fathoms;
+    printf("There are %d feet in %d fathoms!\n", feet, fathoms);
+    printf("Yes, I said %d feet!\n", 6 * fathoms);
+    
+    return 0;
+}

CPrimerPlus6E/Ch02/first.c

@@ -0,0 +1,13 @@
+// first.c
+#include <stdio.h>
+int main(void)                /* a simple program             */
+{
+    int num;                  /* define a variable called num */
+    num = 1;                  /* assign a value to num        */
+    
+    printf("I am a simple "); /* use the printf() function    */
+    printf("computer.\n");
+    printf("My favorite number is %d because it is first.\n",num);
+    
+    return 0;
+}

CPrimerPlus6E/Ch02/nogood.c

@@ -0,0 +1,14 @@
+/*  nogood.c -- a program with errors */
+#include <stdio.h>
+int main(void)
+(
+ int n, int n2, int n3;
+ 
+/* this program has several errors
+ n = 5;
+ n2 = n * n;
+ n3 = n2 * n2;
+ printf("n = %d, n squared = %d, n cubed = %d\n", n, n2, n3)
+ 
+ return 0;
+ )

CPrimerPlus6E/Ch02/stillbad.c

@@ -0,0 +1,14 @@
+/* stillbad.c -- a program with its syntax errors fixed */
+#include <stdio.h>
+int main(void)
+{
+    int n, n2, n3;
+    
+    /* this program has a semantic error */
+    n = 5;
+    n2 = n * n;
+    n3 = n2 * n2;
+    printf("n = %d, n squared = %d, n cubed = %d\n", n, n2, n3);
+    
+    return 0;
+}

CPrimerPlus6E/Ch02/two_func.c

@@ -0,0 +1,16 @@
+//* two_func.c -- a program using two functions in one file */
+#include <stdio.h>
+void butler(void);      /* ANSI/ISO C function prototyping */
+int main(void)
+{
+    printf("I will summon the butler function.\n");
+    butler();
+    printf("Yes. Bring me some tea and writeable DVDs.\n");
+    
+    return 0;
+}
+
+void butler(void)       /* start of function definition */
+{
+    printf("You rang, sir?\n");
+}

CPrimerPlus6E/Ch03/altnames.c

@@ -0,0 +1,16 @@
+/* altnames.c -- portable names for integer types */
+#include <stdio.h>
+#include <inttypes.h> // supports portable types
+int main(void)
+{
+    int32_t me32;     // me32 a 32-bit signed variable
+    
+    me32 = 45933945;
+    printf("First, assume int32_t is int: ");
+    printf("me32 = %d\n", me32);
+    printf("Next, let's not make any assumptions.\n");
+    printf("Instead, use a \"macro\" from inttypes.h: ");
+    printf("me32 = %" PRId32 "\n", me32);
+    
+    return 0;
+}

CPrimerPlus6E/Ch03/badcount.c

@@ -0,0 +1,15 @@
+/* badcount.c -- incorrect argument counts */
+#include <stdio.h>
+int main(void)
+{
+    int n = 4;
+    int m = 5;
+    float f = 7.0f;
+    float g = 8.0f;
+    
+    printf("%d\n", n, m);    /* too many arguments   */
+    printf("%d %d %d\n", n); /* too few arguments    */
+    printf("%d %d\n", f, g); /* wrong kind of values */
+    
+    return 0;
+}

CPrimerPlus6E/Ch03/bases.c

@@ -0,0 +1,11 @@
+/* bases.c--prints 100 in decimal, octal, and hex */
+#include <stdio.h>
+int main(void)
+{
+    int x = 100;
+    
+    printf("dec = %d; octal = %o; hex = %x\n", x, x, x);
+    printf("dec = %d; octal = %#o; hex = %#x\n", x, x, x);
+    
+    return 0;
+}

CPrimerPlus6E/Ch03/charcode.c

@@ -0,0 +1,12 @@
+/* charcode.c-displays code number for a character */
+#include <stdio.h>
+int main(void)
+{
+    char ch;
+    
+    printf("Please enter a character.\n");
+    scanf("%c", &ch);   /* user inputs character */
+    printf("The code for %c is %d.\n", ch, ch);
+    
+    return 0;
+}

CPrimerPlus6E/Ch03/escape.c

@@ -0,0 +1,15 @@
+/* escape.c -- uses escape characters */
+#include <stdio.h>
+int main(void)
+{
+    float salary;
+    
+    printf("\aEnter your desired monthly salary:");/* 1 */
+    printf(" $_______\b\b\b\b\b\b\b");             /* 2 */
+    scanf("%f", &salary);
+    printf("\n\t$%.2f a month is $%.2f a year.", salary,
+           salary * 12.0);                         /* 3 */
+    printf("\rGee!\n");                            /* 4 */
+    
+    return 0;
+}

CPrimerPlus6E/Ch03/floaterr.c

@@ -0,0 +1,12 @@
+/* floaterr.c--demonstrates round-off error */
+#include <stdio.h>
+int main(void)
+{
+    float a,b;
+    
+    b = 2.0e20 + 1.0;
+    a = b - 2.0e20;
+    printf("%f \n", a);
+    
+    return 0;
+}

CPrimerPlus6E/Ch03/platinum.c

@@ -0,0 +1,22 @@
+/* platinum.c  -- your weight in platinum */
+#include <stdio.h>
+int main(void)
+{
+    float weight;    /* user weight             */
+    float value;     /* platinum equivalent     */
+    
+    printf("Are you worth your weight in platinum?\n");
+    printf("Let's check it out.\n");
+    printf("Please enter your weight in pounds: ");
+    
+    /* get input from the user                     */
+    scanf("%f", &weight);
+    /* assume platinum is $1700 per ounce          */
+    /* 14.5833 converts pounds avd. to ounces troy */
+    value = 1700.0 * weight * 14.5833;
+    printf("Your weight in platinum is worth $%.2f.\n", value);
+    printf("You are easily worth that! If platinum prices drop,\n");
+    printf("eat more to maintain your value.\n");
+    
+    return 0;
+}

CPrimerPlus6E/Ch03/print1.c

@@ -0,0 +1,14 @@
+/* print1.c-displays some properties of printf() */
+#include <stdio.h>
+int main(void)
+{
+    int ten = 10;
+    int two = 2;
+    
+    printf("Doing it right: ");
+    printf("%d minus %d is %d\n", ten, 2, ten - two );
+    printf("Doing it wrong: ");
+    printf("%d minus %d is %d\n", ten );  // forgot 2 arguments
+    
+    return 0;
+}

CPrimerPlus6E/Ch03/print2.c

@@ -0,0 +1,16 @@
+/* print2.c-more printf() properties */
+#include <stdio.h>
+int main(void)
+{
+    unsigned int un = 3000000000; /* system with 32-bit int */
+    short end = 200;              /* and 16-bit short       */
+    long big = 65537;
+    long long verybig = 12345678908642;
+    
+    printf("un = %u and not %d\n", un, un);
+    printf("end = %hd and %d\n", end, end);
+    printf("big = %ld and not %hd\n", big, big);
+    printf("verybig= %lld and not %ld\n", verybig, verybig);
+    
+    return 0;
+}